@flightdev/core 0.6.7

package/dist/middleware/index.d.ts

@@ -0,0 +1,305 @@
+/**
+ * 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.
+ *
+ * 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 */
+    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 - type-safe with generics */
+    locals: TLocals;
+    /** 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 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) */
+    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
+ */
+/**
+ * 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;
+    /** 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 */
+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;
+/**
+ * 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
+ */
+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 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

@@ -0,0 +1,3 @@
+export { compose, compress, cors, createContextFromRequest, createMiddlewareChain, createResponseFromContext, errorHandler, logger, securityHeaders } from '../chunk-OYF2OAKS.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/react/index.d.ts

@@ -0,0 +1,73 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { FlightError } from '../errors/index.js';
+
+/**
+ * Error context value
+ */
+interface ErrorContextValue {
+    /** Current error, if any */
+    error: FlightError | null;
+    /** Clear the current error */
+    clearError: (options?: {
+        redirect?: string;
+    }) => void;
+    /** Whether an error is currently active */
+    hasError: boolean;
+}
+/**
+ * Error provider props
+ */
+interface ErrorProviderProps {
+    children: ReactNode;
+    /** Called when an error occurs */
+    onError?: (error: FlightError) => void;
+    /** Called when error is cleared */
+    onClear?: () => void;
+}
+declare const ErrorContext: react.Context<ErrorContextValue | null>;
+/**
+ * Error context provider for React applications.
+ *
+ * Wraps your app to provide error state management via useError() hook.
+ *
+ * @example
+ * ```tsx
+ * import { ErrorProvider } from '@flightdev/core/react';
+ *
+ * function App() {
+ *     return (
+ *         <ErrorProvider onError={(e) => console.log('Error:', e)}>
+ *             <MyApp />
+ *         </ErrorProvider>
+ *     );
+ * }
+ * ```
+ */
+declare function ErrorProvider({ children, onError, onClear }: ErrorProviderProps): ReactNode;
+/**
+ * Access the current error state from anywhere in your React app.
+ *
+ * Returns null values if used outside of ErrorProvider (non-breaking behavior).
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *     const { error, clearError, hasError } = useError();
+ *
+ *     if (hasError) {
+ *         return (
+ *             <div>
+ *                 <p>Error: {error?.message}</p>
+ *                 <button onClick={() => clearError()}>Dismiss</button>
+ *             </div>
+ *         );
+ *     }
+ *
+ *     return <div>Normal content</div>;
+ * }
+ * ```
+ */
+declare function useError(): ErrorContextValue;
+
+export { ErrorContext, type ErrorContextValue, ErrorProvider, type ErrorProviderProps, useError };

package/dist/react/index.js

@@ -0,0 +1,52 @@
+import { getError, clearError } from '../chunk-Q7BS5QC5.js';
+import '../chunk-LWVETFJV.js';
+import { createContext, useState, useEffect, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var ErrorContext = createContext(null);
+function ErrorProvider({ children, onError, onClear }) {
+  const [error, setError] = useState(() => getError());
+  useEffect(() => {
+    const handleError = (event) => {
+      setError(event.detail);
+      onError?.(event.detail);
+    };
+    const handleClear = () => {
+      setError(null);
+      onClear?.();
+    };
+    window.addEventListener("flight:error", handleError);
+    window.addEventListener("flight:error-clear", handleClear);
+    return () => {
+      window.removeEventListener("flight:error", handleError);
+      window.removeEventListener("flight:error-clear", handleClear);
+    };
+  }, [onError, onClear]);
+  const clearError2 = useCallback((options) => {
+    clearError(options);
+    setError(null);
+    onClear?.();
+  }, [onClear]);
+  const value = {
+    error,
+    clearError: clearError2,
+    hasError: error !== null
+  };
+  return /* @__PURE__ */ jsx(ErrorContext.Provider, { value, children });
+}
+function useError() {
+  const context = useContext(ErrorContext);
+  if (!context) {
+    return {
+      error: null,
+      clearError: () => {
+      },
+      hasError: false
+    };
+  }
+  return context;
+}
+
+export { ErrorContext, ErrorProvider, useError };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/hooks/useError.tsx"],"names":["clearError"],"mappings":";;;;;AA0CA,IAAM,YAAA,GAAe,cAAwC,IAAI;AAwB1D,SAAS,aAAA,CAAc,EAAE,QAAA,EAAU,OAAA,EAAS,SAAQ,EAAkC;AACzF,EAAA,MAAM,CAAC,KAAA,EAAO,QAAQ,IAAI,QAAA,CAA6B,MAAM,UAAU,CAAA;AAGvE,EAAA,SAAA,CAAU,MAAM;AACZ,IAAA,MAAM,WAAA,GAAc,CAAC,KAAA,KAAoC;AACrD,MAAA,QAAA,CAAS,MAAM,MAAM,CAAA;AACrB,MAAA,OAAA,GAAU,MAAM,MAAM,CAAA;AAAA,IAC1B,CAAA;AAEA,IAAA,MAAM,cAAc,MAAM;AACtB,MAAA,QAAA,CAAS,IAAI,CAAA;AACb,MAAA,OAAA,IAAU;AAAA,IACd,CAAA;AAEA,IAAA,MAAA,CAAO,gBAAA,CAAiB,gBAAgB,WAA4B,CAAA;AACpE,IAAA,MAAA,CAAO,gBAAA,CAAiB,sBAAsB,WAAW,CAAA;AAEzD,IAAA,OAAO,MAAM;AACT,MAAA,MAAA,CAAO,mBAAA,CAAoB,gBAAgB,WAA4B,CAAA;AACvE,MAAA,MAAA,CAAO,mBAAA,CAAoB,sBAAsB,WAAW,CAAA;AAAA,IAChE,CAAA;AAAA,EACJ,CAAA,EAAG,CAAC,OAAA,EAAS,OAAO,CAAC,CAAA;AAErB,EAAA,MAAMA,WAAAA,GAAa,WAAA,CAAY,CAAC,OAAA,KAAoC;AAChE,IAAA,UAAA,CAAiB,OAAO,CAAA;AACxB,IAAA,QAAA,CAAS,IAAI,CAAA;AACb,IAAA,OAAA,IAAU;AAAA,EACd,CAAA,EAAG,CAAC,OAAO,CAAC,CAAA;AAEZ,EAAA,MAAM,KAAA,GAA2B;AAAA,IAC7B,KAAA;AAAA,IACA,UAAA,EAAAA,WAAAA;AAAA,IACA,UAAU,KAAA,KAAU;AAAA,GACxB;AAEA,EAAA,uBACI,GAAA,CAAC,YAAA,CAAa,QAAA,EAAb,EAAsB,OAClB,QAAA,EACL,CAAA;AAER;AA6BO,SAAS,QAAA,GAA8B;AAC1C,EAAA,MAAM,OAAA,GAAU,WAAW,YAAY,CAAA;AAIvC,EAAA,IAAI,CAAC,OAAA,EAAS;AACV,IAAA,OAAO;AAAA,MACH,KAAA,EAAO,IAAA;AAAA,MACP,YAAY,MAAM;AAAA,MAAE,CAAA;AAAA,MACpB,QAAA,EAAU;AAAA,KACd;AAAA,EACJ;AAEA,EAAA,OAAO,OAAA;AACX","file":"index.js","sourcesContent":["/**\r\n * @flightdev/core - React Error Hook\r\n * \r\n * Optional React hook for accessing error state.\r\n * Developers can use this or bring their own solution.\r\n */\r\n\r\nimport { createContext, useContext, useState, useEffect, useCallback } from 'react';\r\nimport type { ReactNode } from 'react';\r\nimport { FlightError, getError, clearError as clearGlobalError } from '../../errors/index.js';\r\n\r\n// ============================================================================\r\n// Types\r\n// ============================================================================\r\n\r\n/**\r\n * Error context value\r\n */\r\nexport interface ErrorContextValue {\r\n    /** Current error, if any */\r\n    error: FlightError | null;\r\n    /** Clear the current error */\r\n    clearError: (options?: { redirect?: string }) => void;\r\n    /** Whether an error is currently active */\r\n    hasError: boolean;\r\n}\r\n\r\n/**\r\n * Error provider props\r\n */\r\nexport interface ErrorProviderProps {\r\n    children: ReactNode;\r\n    /** Called when an error occurs */\r\n    onError?: (error: FlightError) => void;\r\n    /** Called when error is cleared */\r\n    onClear?: () => void;\r\n}\r\n\r\n// ============================================================================\r\n// Context\r\n// ============================================================================\r\n\r\nconst ErrorContext = createContext<ErrorContextValue | null>(null);\r\n\r\n// ============================================================================\r\n// Provider Component\r\n// ============================================================================\r\n\r\n/**\r\n * Error context provider for React applications.\r\n * \r\n * Wraps your app to provide error state management via useError() hook.\r\n * \r\n * @example\r\n * ```tsx\r\n * import { ErrorProvider } from '@flightdev/core/react';\r\n * \r\n * function App() {\r\n *     return (\r\n *         <ErrorProvider onError={(e) => console.log('Error:', e)}>\r\n *             <MyApp />\r\n *         </ErrorProvider>\r\n *     );\r\n * }\r\n * ```\r\n */\r\nexport function ErrorProvider({ children, onError, onClear }: ErrorProviderProps): ReactNode {\r\n    const [error, setError] = useState<FlightError | null>(() => getError());\r\n\r\n    // Listen for error events from showError()\r\n    useEffect(() => {\r\n        const handleError = (event: CustomEvent<FlightError>) => {\r\n            setError(event.detail);\r\n            onError?.(event.detail);\r\n        };\r\n\r\n        const handleClear = () => {\r\n            setError(null);\r\n            onClear?.();\r\n        };\r\n\r\n        window.addEventListener('flight:error', handleError as EventListener);\r\n        window.addEventListener('flight:error-clear', handleClear);\r\n\r\n        return () => {\r\n            window.removeEventListener('flight:error', handleError as EventListener);\r\n            window.removeEventListener('flight:error-clear', handleClear);\r\n        };\r\n    }, [onError, onClear]);\r\n\r\n    const clearError = useCallback((options?: { redirect?: string }) => {\r\n        clearGlobalError(options);\r\n        setError(null);\r\n        onClear?.();\r\n    }, [onClear]);\r\n\r\n    const value: ErrorContextValue = {\r\n        error,\r\n        clearError,\r\n        hasError: error !== null,\r\n    };\r\n\r\n    return (\r\n        <ErrorContext.Provider value={value} >\r\n            {children}\r\n        </ErrorContext.Provider>\r\n    );\r\n}\r\n\r\n// ============================================================================\r\n// Hook\r\n// ============================================================================\r\n\r\n/**\r\n * Access the current error state from anywhere in your React app.\r\n * \r\n * Returns null values if used outside of ErrorProvider (non-breaking behavior).\r\n * \r\n * @example\r\n * ```tsx\r\n * function MyComponent() {\r\n *     const { error, clearError, hasError } = useError();\r\n *     \r\n *     if (hasError) {\r\n *         return (\r\n *             <div>\r\n *                 <p>Error: {error?.message}</p>\r\n *                 <button onClick={() => clearError()}>Dismiss</button>\r\n *             </div>\r\n *         );\r\n *     }\r\n *     \r\n *     return <div>Normal content</div>;\r\n * }\r\n * ```\r\n */\r\nexport function useError(): ErrorContextValue {\r\n    const context = useContext(ErrorContext);\r\n\r\n    // Return safe defaults if used outside provider\r\n    // This allows the hook to be used without forcing ErrorProvider\r\n    if (!context) {\r\n        return {\r\n            error: null,\r\n            clearError: () => { },\r\n            hasError: false,\r\n        };\r\n    }\r\n\r\n    return context;\r\n}\r\n\r\n// ============================================================================\r\n// Re-exports for convenience\r\n// ============================================================================\r\n\r\nexport { ErrorContext };\r\n"]}

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/adapters/index.d.ts

@@ -0,0 +1,8 @@
+export { ReactConsumerOptions, ReactServerComponent, createReactAdapter, createReactConsumer, markAsClientComponent } from './react.js';
+export { VueConsumerOptions, VueDependencies, VueServerComponent, createVueAdapter, createVueConsumer, markAsVueClientComponent } from './vue.js';
+export { SolidConsumerOptions, SolidDependencies, SolidServerComponent, createSolidAdapter, createSolidConsumer, isServer as isSolidServer, markAsSolidClientComponent } from './solid.js';
+export { PreactConsumerOptions, PreactDependencies, PreactServerComponent, createPreactAdapter, createPreactConsumer, markAsPreactClientComponent, lazy as preactLazy } from './preact.js';
+export { ElementTypeInfo, UIAdapter } from '../renderer.js';
+import 'react';
+import '../context.js';
+import '../payload.js';

package/dist/rsc/adapters/index.js

@@ -0,0 +1,7 @@
+import '../../chunk-Y22AMGTM.js';
+export { createReactAdapter, createReactConsumer, markAsClientComponent } from '../../chunk-AE3JTS73.js';
+export { createVueAdapter, createVueConsumer, markAsVueClientComponent } from '../../chunk-DCLVXFVH.js';
+export { createSolidAdapter, createSolidConsumer, isServer as isSolidServer, markAsSolidClientComponent } from '../../chunk-7ZZF4ULK.js';
+export { createPreactAdapter, createPreactConsumer, markAsPreactClientComponent, lazy as preactLazy } from '../../chunk-KX6UYWWR.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map