@flightdev/core 0.6.7

package/dist/rsc/renderer.js

@@ -0,0 +1,5 @@
+export { FlightRenderer, createRenderer, renderServerComponent, renderServerComponentStreaming } from '../chunk-P6S43FYZ.js';
+import '../chunk-7CNW24MQ.js';
+import '../chunk-AP5NLUSB.js';
+//# sourceMappingURL=renderer.js.map
+//# sourceMappingURL=renderer.js.map

package/dist/rsc/renderer.js.map

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

package/dist/rsc/stream.d.ts

@@ -0,0 +1,129 @@
+import { FlightChunk, ServerComponentChunk, ErrorBoundaryChunk } from './payload.js';
+
+/**
+ * @flightdev/core - Flight Stream
+ *
+ * Protocolo de streaming para Server Components.
+ * Usa NDJSON (Newline Delimited JSON) para máxima debuggabilidad.
+ *
+ * Filosofía Flight:
+ * - Formato abierto y documentado
+ * - Works con cualquier runtime (Node, Deno, Bun, Edge)
+ * - Fácil de debuggear (text-based)
+ * - Sin dependencias
+ *
+ * @module @flightdev/core/rsc/stream
+ */
+
+/**
+ * Opciones para crear un FlightStream
+ */
+interface FlightStreamOptions {
+    /** Incluir timestamps en chunks */
+    timestamps?: boolean;
+    /** Prefix para IDs generados */
+    idPrefix?: string;
+    /** Callback cuando un chunk es enviado */
+    onChunk?: (chunk: FlightChunk) => void;
+    /** Callback cuando el stream termina */
+    onComplete?: () => void;
+    /** Callback en caso de error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Resultado del parsing de un FlightStream
+ */
+interface FlightStreamResult {
+    /** Chunks recibidos */
+    chunks: FlightChunk[];
+    /** Componente raíz */
+    root?: ServerComponentChunk;
+    /** Errores encontrados */
+    errors: ErrorBoundaryChunk[];
+    /** Tiempo total de streaming en ms */
+    duration: number;
+}
+/**
+ * Crea un ReadableStream desde un AsyncIterable de chunks
+ *
+ * @example
+ * ```typescript
+ * async function* renderApp() {
+ *   yield createServerChunk('root', tree);
+ *   yield createClientChunk('counter', './Counter', 'default', { initial: 0 });
+ * }
+ *
+ * const stream = createFlightStream(renderApp());
+ * return new Response(stream, { headers: { 'Content-Type': 'text/x-flight' } });
+ * ```
+ */
+declare function createFlightStream(chunks: AsyncIterable<FlightChunk>, options?: FlightStreamOptions): ReadableStream<Uint8Array>;
+/**
+ * Crea un FlightStream desde un array de chunks
+ */
+declare function createFlightStreamFromArray(chunks: FlightChunk[], options?: FlightStreamOptions): ReadableStream<Uint8Array>;
+/**
+ * Parsea un FlightStream a chunks individuales
+ *
+ * @example
+ * ```typescript
+ * // En el cliente
+ * const response = await fetch('/page');
+ * const chunks = parseFlightStream(response.body!);
+ *
+ * for await (const chunk of chunks) {
+ *   handleChunk(chunk);
+ * }
+ * ```
+ */
+declare function parseFlightStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<FlightChunk>;
+/**
+ * Parsea un string completo de FlightStream
+ */
+declare function parseFlightStreamSync(data: string): FlightChunk[];
+/**
+ * Consume un FlightStream y retorna todos los chunks
+ */
+declare function consumeFlightStream(stream: ReadableStream<Uint8Array>): Promise<FlightStreamResult>;
+/**
+ * Crea una Response con Flight payload
+ */
+declare function createFlightResponse(chunks: AsyncIterable<FlightChunk>, options?: FlightResponseOptions): Response;
+interface FlightResponseOptions {
+    status?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * Crea una Response HTML con streaming SSR + Flight payload embebido
+ */
+declare function createHybridResponse(htmlStream: ReadableStream<Uint8Array>, flightChunks: FlightChunk[], options?: FlightResponseOptions): Response;
+/**
+ * Crea un stream controller para enviar chunks progresivamente
+ */
+declare function createStreamController(): {
+    stream: ReadableStream<Uint8Array>;
+    enqueue: (chunk: FlightChunk) => void;
+    error: (error: Error) => void;
+    close: () => void;
+};
+/**
+ * Merge múltiples streams en uno solo (para rendering paralelo)
+ */
+declare function mergeFlightStreams(...streams: ReadableStream<Uint8Array>[]): ReadableStream<Uint8Array>;
+/**
+ * Pipe a flight stream through a transform
+ */
+declare function transformFlightStream(stream: ReadableStream<Uint8Array>, transform: (chunk: FlightChunk) => FlightChunk | null | Promise<FlightChunk | null>): ReadableStream<Uint8Array>;
+/**
+ * Pretty print Flight chunks para debugging
+ */
+declare function prettyPrintChunks(chunks: FlightChunk[]): string;
+/**
+ * Error durante parsing de FlightStream
+ */
+declare class FlightStreamError extends Error {
+    readonly rawData?: string | undefined;
+    constructor(message: string, rawData?: string | undefined);
+}
+
+export { type FlightResponseOptions, FlightStreamError, type FlightStreamOptions, type FlightStreamResult, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream };

package/dist/rsc/stream.js

@@ -0,0 +1,3 @@
+export { FlightStreamError, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from '../chunk-SUG56SZO.js';
+//# sourceMappingURL=stream.js.map
+//# sourceMappingURL=stream.js.map

package/dist/rsc/stream.js.map

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

package/dist/rsc/vite-plugin.d.ts

@@ -0,0 +1,78 @@
+import { Plugin } from 'vite';
+
+/**
+ * @flightdev/vite-plugin-rsc
+ *
+ * Vite plugin for Flight Server Components.
+ * Transforms 'use client' and 'use server' directives at build time.
+ *
+ * Philosophy:
+ * - Zero config for common cases
+ * - Full control when needed
+ * - Works with any Vite project
+ * - No Next.js dependencies
+ *
+ * @module @flightdev/vite-plugin-rsc
+ */
+
+/**
+ * Plugin configuration
+ */
+interface FlightRSCPluginOptions {
+    /** Include patterns (glob) */
+    include?: string[];
+    /** Exclude patterns (glob) */
+    exclude?: string[];
+    /** Server actions endpoint */
+    actionsEndpoint?: string;
+    /** Client manifest output path */
+    clientManifest?: string;
+    /** Server manifest output path */
+    serverManifest?: string;
+    /** Enable dev mode features */
+    dev?: boolean;
+    /** Custom transforms */
+    transforms?: {
+        /** Transform client components */
+        client?: (code: string, id: string) => string | null;
+        /** Transform server actions */
+        server?: (code: string, id: string) => string | null;
+    };
+}
+/**
+ * Client manifest entry
+ */
+interface ClientManifestEntry {
+    id: string;
+    file: string;
+    exports: string[];
+    chunks?: string[];
+}
+/**
+ * Server manifest entry
+ */
+interface ServerManifestEntry {
+    id: string;
+    file: string;
+    actions: string[];
+}
+/**
+ * Flight RSC Vite Plugin
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { flightRSC } from '@flightdev/core/rsc/vite-plugin';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     flightRSC({
+ *       actionsEndpoint: '/_flight/action',
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+declare function flightRSC(options?: FlightRSCPluginOptions): Plugin[];
+
+export { type ClientManifestEntry, type FlightRSCPluginOptions, type ServerManifestEntry, flightRSC as default, flightRSC };

package/dist/rsc/vite-plugin.js

@@ -0,0 +1,4 @@
+export { vite_plugin_default as default, flightRSC } from '../chunk-63LWTEDQ.js';
+import '../chunk-AP5NLUSB.js';
+//# sourceMappingURL=vite-plugin.js.map
+//# sourceMappingURL=vite-plugin.js.map

package/dist/rsc/vite-plugin.js.map

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

package/dist/server/index.d.ts

@@ -0,0 +1,135 @@
+import { Router } from '../router/index.js';
+import { Middleware, MiddlewareChain } from '../middleware/index.js';
+import { FlightUserConfig, FlightConfig } from '../config/index.js';
+import { FlightAdapter } from '../adapters/index.js';
+import '../render/index.js';
+
+/**
+ * Flight Server - Main server factory
+ *
+ * Creates a Flight server instance that handles routing, middleware, and rendering.
+ * This is the primary entry point for Flight applications.
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from '@flightdev/core';
+ *
+ * const server = createServer();
+ *
+ * server.get('/api/health', () => Response.json({ status: 'ok' }));
+ *
+ * // Just works! Auto-detects Node.js, Bun, or Deno
+ * server.listen(3000);
+ * ```
+ */
+
+/** Route handler function signature */
+type RouteHandler = (context: RouteHandlerContext) => Promise<Response> | Response;
+/** Context passed to route handlers */
+interface RouteHandlerContext {
+    /** The incoming request */
+    request: Request;
+    /** URL parameters from routing */
+    params: Record<string, string | string[]>;
+    /** Query parameters */
+    query: URLSearchParams;
+    /** Parsed URL */
+    url: URL;
+    /** Local data from middleware */
+    locals: Record<string, unknown>;
+    /** Database instance (if configured) */
+    db?: unknown;
+    /** Auth instance (if configured) */
+    auth?: unknown;
+    /** Email instance (if configured) */
+    email?: unknown;
+}
+/** Server options */
+interface ServerOptions {
+    /** Server configuration */
+    config?: FlightUserConfig;
+    /** Deployment adapter */
+    adapter?: FlightAdapter;
+    /** Database instance */
+    db?: unknown;
+    /** Auth instance */
+    auth?: unknown;
+    /** Email instance */
+    email?: unknown;
+}
+/** Route definition for the server */
+interface ServerRoute {
+    /** HTTP method (GET, POST, etc.) */
+    method: string | string[];
+    /** Route path pattern */
+    path: string;
+    /** Route handler */
+    handler: RouteHandler;
+}
+/** Listen options */
+interface ListenOptions {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Hostname to bind to (default: 'localhost') */
+    hostname?: string;
+    /** Callback when server starts */
+    onListen?: (info: {
+        port: number;
+        hostname: string;
+    }) => void;
+}
+/** Flight Server instance */
+interface FlightServer {
+    /** Add a route */
+    route(method: string | string[], path: string, handler: RouteHandler): FlightServer;
+    /** Convenience methods for common HTTP methods */
+    get(path: string, handler: RouteHandler): FlightServer;
+    post(path: string, handler: RouteHandler): FlightServer;
+    put(path: string, handler: RouteHandler): FlightServer;
+    delete(path: string, handler: RouteHandler): FlightServer;
+    patch(path: string, handler: RouteHandler): FlightServer;
+    /** Add middleware */
+    use(middleware: Middleware): FlightServer;
+    use(path: string, middleware: Middleware): FlightServer;
+    /** Handle incoming request (Web standard Request/Response) */
+    handle(request: Request): Promise<Response>;
+    /**
+     * Start the HTTP server
+     * Auto-detects runtime: Node.js, Bun, or Deno
+     */
+    listen(port?: number | ListenOptions): Promise<void>;
+    /** Fetch handler for Bun.serve() and Deno.serve() */
+    fetch(request: Request): Promise<Response>;
+    /** Get the resolved configuration */
+    readonly config: FlightConfig;
+    /** Get the router instance */
+    readonly router: Router<RouteHandler>;
+    /** Get the middleware chain */
+    readonly middleware: MiddlewareChain;
+}
+type Runtime = 'node' | 'bun' | 'deno' | 'unknown';
+/**
+ * Create a new Flight server instance
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from '@flightdev/core';
+ *
+ * const server = createServer();
+ *
+ * server.get('/api/users', async ({ db }) => {
+ *   const users = await db.query('SELECT * FROM users');
+ *   return Response.json(users);
+ * });
+ *
+ * // Works on Node.js, Bun, and Deno!
+ * server.listen(3000);
+ * ```
+ */
+declare function createServer(options?: ServerOptions): FlightServer;
+/** Type guard to check if an object is a FlightServer */
+declare function isFlightServer(obj: unknown): obj is FlightServer;
+/** Get current runtime */
+declare function getRuntime(): Runtime;
+
+export { type FlightServer, type ListenOptions, type RouteHandler, type RouteHandlerContext, type ServerOptions, type ServerRoute, createServer, getRuntime, isFlightServer };

package/dist/server/index.js

@@ -0,0 +1,6 @@
+export { createServer, getRuntime, isFlightServer } from '../chunk-DZMWWDFD.js';
+import '../chunk-OYF2OAKS.js';
+import '../chunk-NCGPUFWV.js';
+import '../chunk-GCQZ4FHI.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

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

package/dist/streaming/adapters/index.d.ts

@@ -0,0 +1,223 @@
+import { StreamingRenderOptions, StreamingRenderResult } from '../index.js';
+
+/**
+ * @flightdev/core - Multi-Framework Streaming Adapters
+ *
+ * Streaming SSR adapters for React, Vue, Svelte, Solid, and HTMX.
+ * Uses dependency injection pattern for optional framework dependencies.
+ *
+ * Best Practices 2026:
+ * - Dependency injection for optional peer dependencies
+ * - Support both Node.js and Edge runtimes
+ * - Progressive hydration support
+ * - Error boundary integration
+ *
+ * @example
+ * ```typescript
+ * // React adapter with your imports
+ * import { renderToReadableStream } from 'react-dom/server';
+ *
+ * const adapter = createReactStreamAdapter({
+ *     renderToReadableStream,
+ *     bootstrapModules: ['/client.js'],
+ * });
+ * ```
+ */
+
+/**
+ * Framework-specific streaming adapter
+ */
+interface StreamingAdapter<TComponent = unknown> {
+    /** Adapter name */
+    readonly name: string;
+    /** Framework version support */
+    readonly framework: string;
+    /** Runtime support */
+    readonly runtime: 'universal' | 'node' | 'edge';
+    /**
+     * Create a streaming response from a component
+     */
+    stream(component: TComponent, options?: StreamingRenderOptions): Promise<StreamingRenderResult>;
+    /**
+     * Render to static string (for comparison/fallback)
+     */
+    renderToString?(component: TComponent): Promise<string>;
+}
+/**
+ * Common adapter options
+ */
+interface AdapterOptions {
+    /** Enable streaming (default: true) */
+    streaming?: boolean;
+    /** Scripts to bootstrap on client */
+    bootstrapScripts?: string[];
+    /** Modules to bootstrap on client */
+    bootstrapModules?: string[];
+    /** Error handling strategy */
+    onError?: (error: Error) => void;
+    /** Shell ready callback */
+    onShellReady?: () => void;
+    /** All content ready callback */
+    onAllReady?: () => void;
+}
+/**
+ * React streaming adapter options with required dependencies
+ */
+interface ReactAdapterOptions extends AdapterOptions {
+    /** React's renderToReadableStream (for Edge) */
+    renderToReadableStream?: (element: unknown, options?: {
+        bootstrapScripts?: string[];
+        bootstrapModules?: string[];
+        identifierPrefix?: string;
+        signal?: AbortSignal;
+        onError?: (error: unknown) => void;
+    }) => Promise<ReadableStream<Uint8Array> & {
+        allReady: Promise<void>;
+    }>;
+    /** React's renderToString (for static fallback) */
+    renderToString?: (element: unknown) => string;
+    /** Custom identifier prefix */
+    identifierPrefix?: string;
+    /** Abort signal */
+    signal?: AbortSignal;
+}
+/**
+ * Create a React streaming adapter
+ *
+ * @example
+ * ```typescript
+ * import { renderToReadableStream, renderToString } from 'react-dom/server';
+ *
+ * const adapter = createReactStreamAdapter({
+ *     renderToReadableStream,
+ *     renderToString,
+ *     bootstrapModules: ['/client.js'],
+ * });
+ *
+ * const result = await adapter.stream(<App />);
+ * ```
+ */
+declare function createReactStreamAdapter(options: ReactAdapterOptions): StreamingAdapter;
+/**
+ * Vue streaming adapter options
+ */
+interface VueAdapterOptions extends AdapterOptions {
+    /** Vue's renderToWebStream */
+    renderToWebStream?: (app: unknown, context?: Record<string, unknown>) => ReadableStream;
+    /** Vue's renderToString */
+    renderToString?: (app: unknown) => Promise<string>;
+    /** Vue app context */
+    context?: Record<string, unknown>;
+}
+/**
+ * Create a Vue 3 streaming adapter
+ *
+ * @example
+ * ```typescript
+ * import { renderToWebStream, renderToString } from 'vue/server-renderer';
+ *
+ * const adapter = createVueStreamAdapter({
+ *     renderToWebStream,
+ *     renderToString,
+ * });
+ *
+ * const result = await adapter.stream(createSSRApp(App));
+ * ```
+ */
+declare function createVueStreamAdapter(options: VueAdapterOptions): StreamingAdapter;
+/**
+ * Solid streaming adapter options
+ */
+interface SolidAdapterOptions extends AdapterOptions {
+    /** Solid's renderToStream */
+    renderToStream?: (fn: () => unknown, options?: {
+        nonce?: string;
+        onCompleteShell?: () => void;
+        onCompleteAll?: () => void;
+    }) => {
+        pipeTo: (writable: WritableStream) => void;
+    };
+    /** Solid's renderToString */
+    renderToString?: (fn: () => unknown) => string;
+    /** Nonce for CSP */
+    nonce?: string;
+}
+/**
+ * Create a Solid.js streaming adapter
+ *
+ * @example
+ * ```typescript
+ * import { renderToStream, renderToString } from 'solid-js/web';
+ *
+ * const adapter = createSolidStreamAdapter({
+ *     renderToStream,
+ *     renderToString,
+ * });
+ *
+ * const result = await adapter.stream(() => <App />);
+ * ```
+ */
+declare function createSolidStreamAdapter(options: SolidAdapterOptions): StreamingAdapter;
+/**
+ * Svelte streaming adapter options
+ */
+interface SvelteAdapterOptions extends AdapterOptions {
+    /** Svelte's render function */
+    render?: (component: unknown, options?: {
+        props?: Record<string, unknown>;
+    }) => {
+        body: string;
+        head?: string;
+    };
+    /** Props for the component */
+    props?: Record<string, unknown>;
+}
+/**
+ * Create a Svelte 5 streaming adapter
+ * Note: Svelte's SSR is primarily string-based, streaming is simulated
+ *
+ * @example
+ * ```typescript
+ * import { render } from 'svelte/server';
+ *
+ * const adapter = createSvelteStreamAdapter({
+ *     render,
+ *     props: { name: 'World' },
+ * });
+ *
+ * const result = await adapter.stream(App);
+ * ```
+ */
+declare function createSvelteStreamAdapter(options: SvelteAdapterOptions): StreamingAdapter;
+/**
+ * HTMX streaming adapter options
+ */
+interface HTMXAdapterOptions extends AdapterOptions {
+    /** Event name for SSE */
+    eventName?: string;
+    /** Retry interval for SSE */
+    retryMs?: number;
+}
+/**
+ * Create an HTMX SSE streaming adapter
+ * Uses Server-Sent Events for progressive updates
+ *
+ * @example
+ * ```typescript
+ * const adapter = createHTMXStreamAdapter({
+ *     eventName: 'update',
+ *     retryMs: 3000,
+ * });
+ *
+ * const result = await adapter.stream(['<div>Part 1</div>', '<div>Part 2</div>']);
+ * ```
+ */
+declare function createHTMXStreamAdapter(options?: HTMXAdapterOptions): StreamingAdapter<string[]>;
+type FrameworkType = 'react' | 'vue' | 'solid' | 'svelte' | 'htmx';
+/**
+ * Create a streaming adapter for any supported framework
+ * Note: For react, vue, solid, svelte you need to pass the required dependencies
+ */
+declare function createStreamAdapter(framework: FrameworkType, options?: AdapterOptions & Record<string, unknown>): StreamingAdapter;
+
+export { type AdapterOptions, type FrameworkType, type HTMXAdapterOptions, type ReactAdapterOptions, type SolidAdapterOptions, type StreamingAdapter, type SvelteAdapterOptions, type VueAdapterOptions, createHTMXStreamAdapter, createReactStreamAdapter, createSolidStreamAdapter, createStreamAdapter, createSvelteStreamAdapter, createVueStreamAdapter };

package/dist/streaming/adapters/index.js

@@ -0,0 +1,3 @@
+export { createHTMXStreamAdapter, createReactStreamAdapter, createSolidStreamAdapter, createStreamAdapter, createSvelteStreamAdapter, createVueStreamAdapter } from '../../chunk-SDYPG3JD.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/streaming/adapters/index.js.map

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