@flightdev/core 0.6.7

package/dist/actions/index.d.ts

@@ -0,0 +1,743 @@
+/**
+ * @flightdev/core - Action Middleware
+ *
+ * Agnostic middleware system for Server Actions.
+ * Flight provides the PRIMITIVES, you build YOUR solution.
+ *
+ * @example
+ * ```typescript
+ * // Create your own auth middleware (Flight doesn't impose any auth provider)
+ * const withAuth = createActionMiddleware(async (ctx, next) => {
+ *     const session = await yourAuthProvider.getSession(ctx.headers);
+ *     if (!session) {
+ *         return { success: false, error: 'UNAUTHORIZED' };
+ *     }
+ *     ctx.set('session', session);
+ *     return next();
+ * });
+ *
+ * // Create your own rate limiter (Flight doesn't impose any rate limit provider)
+ * const withRateLimit = createActionMiddleware(async (ctx, next) => {
+ *     const allowed = await yourRateLimiter.check(ctx.get('session').userId);
+ *     if (!allowed) {
+ *         return { success: false, error: 'RATE_LIMITED' };
+ *     }
+ *     return next();
+ * });
+ *
+ * // Compose them
+ * const protectedAction = pipeline(withAuth, withRateLimit)(myAction);
+ * ```
+ */
+/**
+ * Action context - holds request data and middleware-set values
+ */
+interface ActionContext {
+    /** Original request (if available) */
+    readonly request?: Request;
+    /** Request headers */
+    readonly headers: Headers;
+    /** Action ID being executed */
+    readonly actionId: string;
+    /** Action arguments */
+    readonly args: unknown[];
+    /** Abort signal for cancellation */
+    readonly signal?: AbortSignal;
+    /** Get a value set by previous middleware */
+    get<T = unknown>(key: string): T | undefined;
+    /** Set a value for subsequent middleware/action */
+    set<T = unknown>(key: string, value: T): void;
+}
+/**
+ * Action result following Flight conventions
+ */
+interface ActionResult$1<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    code?: string;
+}
+/**
+ * Next function to call the next middleware or action
+ */
+type ActionNext<T = unknown> = () => Promise<ActionResult$1<T>>;
+/**
+ * Middleware handler function
+ */
+type ActionMiddlewareHandler<TContext extends ActionContext = ActionContext> = (ctx: TContext, next: ActionNext) => Promise<ActionResult$1> | ActionResult$1;
+/**
+ * A middleware instance
+ */
+interface ActionMiddleware {
+    /** Unique name for debugging */
+    readonly name: string;
+    /** The handler function */
+    readonly handler: ActionMiddlewareHandler;
+}
+/**
+ * An action function
+ */
+type Action<TInput = unknown, TOutput = unknown> = (...args: TInput extends unknown[] ? TInput : [TInput]) => Promise<ActionResult$1<TOutput>>;
+/**
+ * Options for creating middleware
+ */
+interface CreateMiddlewareOptions {
+    /** Name for debugging/logging */
+    name?: string;
+}
+/**
+ * Create an action context from request or minimal data
+ */
+declare function createActionContext(options: {
+    request?: Request;
+    headers?: Headers;
+    actionId: string;
+    args: unknown[];
+    signal?: AbortSignal;
+}): ActionContext;
+/**
+ * Create a reusable action middleware.
+ *
+ * Flight provides this PRIMITIVE - you define WHAT the middleware does.
+ *
+ * @example
+ * ```typescript
+ * // Authentication middleware (you choose the auth provider)
+ * const withAuth = createActionMiddleware(async (ctx, next) => {
+ *     const token = ctx.headers.get('Authorization');
+ *     const user = await myAuthLib.verify(token); // YOUR auth library
+ *
+ *     if (!user) {
+ *         return { success: false, error: 'Unauthorized', code: 'AUTH_ERROR' };
+ *     }
+ *
+ *     ctx.set('user', user);
+ *     return next();
+ * });
+ *
+ * // Validation middleware (you choose the validator)
+ * const withValidation = (schema: ZodSchema) => createActionMiddleware(
+ *     async (ctx, next) => {
+ *         const result = schema.safeParse(ctx.args[0]);
+ *         if (!result.success) {
+ *             return { success: false, error: 'Validation failed', code: 'VALIDATION_ERROR' };
+ *         }
+ *         return next();
+ *     },
+ *     { name: 'validation' }
+ * );
+ * ```
+ */
+declare function createActionMiddleware(handler: ActionMiddlewareHandler, options?: CreateMiddlewareOptions): ActionMiddleware;
+/**
+ * Compose multiple middleware into a pipeline that wraps an action.
+ *
+ * Middleware executes in order: first middleware runs first.
+ * Each middleware can:
+ * - Short-circuit by returning a result without calling next()
+ * - Transform context for subsequent middleware
+ * - Wrap the next() call for timing/logging
+ *
+ * @example
+ * ```typescript
+ * const protectedAction = pipeline(
+ *     withAuth,
+ *     withRateLimit,
+ *     withValidation(UserSchema),
+ * )(createUserAction);
+ *
+ * // Now protectedAction has auth, rate-limit, and validation
+ * const result = await protectedAction(userData);
+ * ```
+ */
+declare function pipeline<TInput, TOutput>(...middlewares: ActionMiddleware[]): (action: Action<TInput, TOutput>) => Action<TInput, TOutput>;
+/**
+ * Execute an action with middleware, providing custom context.
+ *
+ * Use this when you need to provide request context (headers, etc.)
+ *
+ * @example
+ * ```typescript
+ * const result = await executeWithMiddleware(
+ *     myAction,
+ *     [arg1, arg2],
+ *     [withAuth, withRateLimit],
+ *     { request: incomingRequest }
+ * );
+ * ```
+ */
+declare function executeWithMiddleware<TInput extends unknown[], TOutput>(action: (...args: TInput) => Promise<ActionResult$1<TOutput>>, args: TInput, middlewares: ActionMiddleware[], options?: {
+    request?: Request;
+    headers?: Headers;
+    signal?: AbortSignal;
+}): Promise<ActionResult$1<TOutput>>;
+/**
+ * Create a timing middleware for observability.
+ *
+ * You provide the reporter - Flight doesn't impose any observability provider.
+ *
+ * @example
+ * ```typescript
+ * const withTiming = createTimingMiddleware((actionId, durationMs) => {
+ *     myMetricsService.histogram('action.duration', durationMs, { actionId });
+ * });
+ * ```
+ */
+declare function createTimingMiddleware(reporter: (actionId: string, durationMs: number, result: ActionResult$1) => void): ActionMiddleware;
+/**
+ * Create a logging middleware.
+ *
+ * You provide the logger - Flight doesn't impose any logging library.
+ *
+ * @example
+ * ```typescript
+ * const withLogging = createLoggingMiddleware({
+ *     onStart: (ctx) => console.log(`[${ctx.actionId}] Starting...`),
+ *     onComplete: (ctx, result, ms) => console.log(`[${ctx.actionId}] ${result.success ? 'OK' : 'FAIL'} in ${ms}ms`),
+ * });
+ * ```
+ */
+declare function createLoggingMiddleware(options: {
+    onStart?: (ctx: ActionContext) => void;
+    onComplete?: (ctx: ActionContext, result: ActionResult$1, durationMs: number) => void;
+    onError?: (ctx: ActionContext, error: Error) => void;
+}): ActionMiddleware;
+/**
+ * Create a retry middleware.
+ *
+ * @example
+ * ```typescript
+ * const withRetry = createRetryMiddleware({
+ *     maxAttempts: 3,
+ *     delay: (attempt) => Math.pow(2, attempt) * 100, // Exponential backoff
+ *     shouldRetry: (result) => result.code === 'TEMPORARY_ERROR',
+ * });
+ * ```
+ */
+declare function createRetryMiddleware(options: {
+    maxAttempts: number;
+    delay?: (attempt: number) => number;
+    shouldRetry?: (result: ActionResult$1) => boolean;
+}): ActionMiddleware;
+
+/**
+ * @flightdev/core - Action Streaming
+ *
+ * Streamable actions using async generators.
+ * Flight provides the PRIMITIVES, you choose the transport.
+ *
+ * @example
+ * ```typescript
+ * // Create a streamable action for long-running operations
+ * const generateReport = createStreamableAction(async function* (params: ReportParams) {
+ *     yield { type: 'progress', message: 'Fetching data...', progress: 0 };
+ *     const data = await fetchData(params);
+ *
+ *     yield { type: 'progress', message: 'Processing...', progress: 33 };
+ *     const processed = await processData(data);
+ *
+ *     yield { type: 'progress', message: 'Generating PDF...', progress: 66 };
+ *     const pdf = await generatePDF(processed);
+ *
+ *     yield { type: 'progress', message: 'Complete!', progress: 100 };
+ *     return { success: true, data: pdf };
+ * });
+ *
+ * // Client consumption
+ * for await (const update of generateReport(params)) {
+ *     if (update.type === 'progress') {
+ *         setProgress(update.progress);
+ *     } else if (update.type === 'result') {
+ *         handleResult(update.data);
+ *     }
+ * }
+ * ```
+ */
+/**
+ * Progress update yielded during streaming
+ */
+interface StreamProgress<TYield = unknown> {
+    type: 'progress';
+    data: TYield;
+}
+/**
+ * Final result of a streaming action
+ */
+interface StreamResult<TReturn = unknown> {
+    type: 'result';
+    success: boolean;
+    data?: TReturn;
+    error?: string;
+}
+/**
+ * Union type for stream items
+ */
+type StreamItem<TYield, TReturn> = StreamProgress<TYield> | StreamResult<TReturn>;
+/**
+ * Streamable action generator function
+ */
+type StreamableGenerator<TInput, TYield, TReturn> = (input: TInput, signal?: AbortSignal) => AsyncGenerator<TYield, TReturn>;
+/**
+ * Options for creating a streamable action
+ */
+interface StreamableActionOptions {
+    /** Name for debugging */
+    name?: string;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Controller for a running stream
+ */
+interface StreamController<TYield, TReturn> {
+    /** Async iterator for consuming the stream */
+    [Symbol.asyncIterator](): AsyncIterator<StreamItem<TYield, TReturn>>;
+    /** Abort the stream */
+    abort(): void;
+    /** Promise that resolves when stream completes */
+    done: Promise<StreamResult<TReturn>>;
+}
+/**
+ * A streamable action function
+ */
+type StreamableAction<TInput, TYield, TReturn> = (input: TInput) => StreamController<TYield, TReturn>;
+/**
+ * Create a streamable action from an async generator.
+ *
+ * Flight provides this PRIMITIVE - you define the generator logic
+ * and choose how to transport the stream (HTTP, WebSocket, etc.)
+ *
+ * @example
+ * ```typescript
+ * // AI streaming response
+ * const streamChat = createStreamableAction(async function* (message: string) {
+ *     const stream = await openai.chat.completions.create({
+ *         model: 'gpt-4',
+ *         messages: [{ role: 'user', content: message }],
+ *         stream: true,
+ *     });
+ *
+ *     let fullResponse = '';
+ *     for await (const chunk of stream) {
+ *         const text = chunk.choices[0]?.delta?.content || '';
+ *         fullResponse += text;
+ *         yield { text, partial: true };
+ *     }
+ *
+ *     return { text: fullResponse, partial: false };
+ * });
+ * ```
+ */
+declare function createStreamableAction<TInput, TYield, TReturn>(generator: StreamableGenerator<TInput, TYield, TReturn>, options?: StreamableActionOptions): StreamableAction<TInput, TYield, TReturn>;
+/**
+ * Convert a streamable action result to an HTTP streaming response.
+ *
+ * This is ONE transport option - you can create others (WebSocket, SSE, etc.)
+ *
+ * @example
+ * ```typescript
+ * // In your API route
+ * export async function POST(request: Request) {
+ *     const body = await request.json();
+ *     const stream = generateReport(body);
+ *     return streamToResponse(stream);
+ * }
+ * ```
+ */
+declare function streamToResponse<TYield, TReturn>(controller: StreamController<TYield, TReturn>, options?: {
+    headers?: Record<string, string>;
+}): Response;
+/**
+ * Parse an HTTP streaming response back to a stream controller (client-side).
+ *
+ * @example
+ * ```typescript
+ * // Client-side consumption
+ * const response = await fetch('/api/generate-report', {
+ *     method: 'POST',
+ *     body: JSON.stringify(params),
+ * });
+ *
+ * const stream = responseToStream<Progress, Report>(response);
+ *
+ * for await (const item of stream) {
+ *     if (item.type === 'progress') {
+ *         setProgress(item.data);
+ *     } else {
+ *         setReport(item.data);
+ *     }
+ * }
+ * ```
+ */
+declare function responseToStream<TYield, TReturn>(response: Response): AsyncGenerator<StreamItem<TYield, TReturn>>;
+/**
+ * Collect all items from a stream into an array.
+ *
+ * Useful for testing or when you want to wait for completion.
+ */
+declare function collectStream<TYield, TReturn>(controller: StreamController<TYield, TReturn>): Promise<{
+    items: StreamItem<TYield, TReturn>[];
+    result: StreamResult<TReturn>;
+}>;
+/**
+ * Create a simple progress reporter for streams.
+ *
+ * @example
+ * ```typescript
+ * const onProgress = createProgressReporter<MyProgress>((data) => {
+ *     console.log(`Progress: ${data.percent}%`);
+ * });
+ *
+ * for await (const item of myStream) {
+ *     onProgress(item);
+ * }
+ * ```
+ */
+declare function createProgressReporter<TYield, TReturn = unknown>(onProgress: (data: TYield) => void, onComplete?: (result: StreamResult<TReturn>) => void): (item: StreamItem<TYield, TReturn>) => void;
+
+/**
+ * @flightdev/core - Action Queue
+ *
+ * Offline-first action queuing with pluggable storage.
+ * Flight provides the PRIMITIVES and INTERFACE, you choose the storage.
+ *
+ * @example
+ * ```typescript
+ * // 1. Use a storage adapter (install separately or create your own)
+ * import { indexedDBAdapter } from '@flightdev/queue-indexeddb';
+ * // OR create your own:
+ * const myAdapter: QueueStorageAdapter = { ... };
+ *
+ * // 2. Create a queued action
+ * const saveNote = createQueuedAction(
+ *     async (note: Note) => {
+ *         await api.saveNote(note);
+ *         return { success: true };
+ *     },
+ *     {
+ *         storage: indexedDBAdapter({ dbName: 'myapp' }),
+ *         retryStrategy: exponentialBackoff({ maxAttempts: 5 }),
+ *         onStatusChange: (status) => console.log('Queue status:', status),
+ *     }
+ * );
+ *
+ * // 3. Use it - works offline!
+ * await saveNote({ title: 'My Note', content: '...' });
+ * // If offline: queued and synced later
+ * // If online: executed immediately
+ * ```
+ */
+/**
+ * A queued action entry
+ */
+interface QueuedActionEntry<TInput = unknown> {
+    /** Unique ID for this entry */
+    id: string;
+    /** Action identifier */
+    actionId: string;
+    /** Action arguments */
+    input: TInput;
+    /** When the action was queued */
+    queuedAt: number;
+    /** Number of execution attempts */
+    attempts: number;
+    /** Last error message if failed */
+    lastError?: string;
+    /** Status */
+    status: 'pending' | 'processing' | 'failed';
+    /** Optional metadata */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Queue storage adapter interface.
+ *
+ * Flight does NOT provide storage implementations - you choose:
+ * - @flightdev/queue-indexeddb (browser)
+ * - @flightdev/queue-sqlite (mobile/desktop)
+ * - @flightdev/queue-memory (testing)
+ * - Your own implementation
+ */
+interface QueueStorageAdapter {
+    /** Add an action to the queue */
+    enqueue<TInput>(entry: QueuedActionEntry<TInput>): Promise<void>;
+    /** Get and remove the next pending action */
+    dequeue(): Promise<QueuedActionEntry | null>;
+    /** Get all pending actions without removing */
+    peek(): Promise<QueuedActionEntry[]>;
+    /** Update an existing entry */
+    update(id: string, updates: Partial<QueuedActionEntry>): Promise<void>;
+    /** Remove an entry by ID */
+    remove(id: string): Promise<void>;
+    /** Clear all entries */
+    clear(): Promise<void>;
+    /** Get queue length */
+    length(): Promise<number>;
+}
+/**
+ * Retry strategy function
+ */
+type RetryStrategy = (entry: QueuedActionEntry, error: Error) => {
+    shouldRetry: boolean;
+    delayMs: number;
+};
+/**
+ * Queue status for observability
+ */
+interface QueueStatus {
+    /** Whether the queue processor is running */
+    isProcessing: boolean;
+    /** Number of pending actions */
+    pendingCount: number;
+    /** Number of failed actions */
+    failedCount: number;
+    /** Whether online */
+    isOnline: boolean;
+}
+/**
+ * Options for creating a queued action
+ */
+interface QueuedActionOptions {
+    /** Storage adapter (required - Flight doesn't provide default) */
+    storage: QueueStorageAdapter;
+    /** Custom action ID */
+    actionId?: string;
+    /** Retry strategy */
+    retryStrategy?: RetryStrategy;
+    /** Check if online (default: navigator.onLine on browser) */
+    isOnline?: () => boolean | Promise<boolean>;
+    /** Called when queue status changes */
+    onStatusChange?: (status: QueueStatus) => void;
+    /** Called when an action is successfully processed */
+    onSuccess?: (entry: QueuedActionEntry, result: unknown) => void;
+    /** Called when an action fails permanently */
+    onFailure?: (entry: QueuedActionEntry, error: Error) => void;
+}
+/**
+ * Action result for queued actions
+ */
+interface QueuedActionResult<TOutput = unknown> {
+    /** Whether immediately executed or queued */
+    queued: boolean;
+    /** Queue entry ID if queued */
+    entryId?: string;
+    /** Result if immediately executed */
+    result?: {
+        success: boolean;
+        data?: TOutput;
+        error?: string;
+    };
+}
+/**
+ * A queued action function
+ */
+type QueuedAction<TInput, TOutput> = (input: TInput) => Promise<QueuedActionResult<TOutput>>;
+/**
+ * Create an offline-capable queued action.
+ *
+ * Flight provides this PRIMITIVE - you provide the storage adapter.
+ *
+ * @example
+ * ```typescript
+ * // Create with your storage adapter
+ * const syncData = createQueuedAction(
+ *     async (data: MyData) => {
+ *         await api.sync(data);
+ *         return { success: true };
+ *     },
+ *     {
+ *         storage: myStorageAdapter,
+ *         retryStrategy: exponentialBackoff(),
+ *     }
+ * );
+ *
+ * // Use it - works offline automatically
+ * const result = await syncData({ items: [...] });
+ *
+ * if (result.queued) {
+ *     console.log('Queued for later sync:', result.entryId);
+ * } else {
+ *     console.log('Synced immediately:', result.result);
+ * }
+ * ```
+ */
+declare function createQueuedAction<TInput, TOutput>(action: (input: TInput) => Promise<{
+    success: boolean;
+    data?: TOutput;
+    error?: string;
+}>, options: QueuedActionOptions): QueuedAction<TInput, TOutput>;
+/**
+ * Default retry strategy: 3 attempts with 1 second delay
+ */
+declare const defaultRetryStrategy: RetryStrategy;
+/**
+ * Create an exponential backoff retry strategy.
+ *
+ * @example
+ * ```typescript
+ * const retry = exponentialBackoff({
+ *     maxAttempts: 5,
+ *     baseDelayMs: 1000,
+ *     maxDelayMs: 30000,
+ * });
+ * ```
+ */
+declare function exponentialBackoff(options?: {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+}): RetryStrategy;
+/**
+ * Create a fixed delay retry strategy.
+ */
+declare function fixedDelay(options?: {
+    maxAttempts?: number;
+    delayMs?: number;
+}): RetryStrategy;
+/**
+ * In-memory queue storage adapter.
+ *
+ * ⚠️ FOR TESTING ONLY - data is lost on page refresh.
+ *
+ * For production, use:
+ * - @flightdev/queue-indexeddb (browser)
+ * - @flightdev/queue-sqlite (native apps)
+ * - Your own implementation
+ */
+declare function createMemoryAdapter(): QueueStorageAdapter;
+/**
+ * Create a queue manager to control multiple queued actions.
+ *
+ * @example
+ * ```typescript
+ * const queueManager = createQueueManager({
+ *     storage: myStorageAdapter,
+ * });
+ *
+ * // Pause all processing
+ * queueManager.pause();
+ *
+ * // Resume
+ * queueManager.resume();
+ *
+ * // Get status
+ * const status = await queueManager.getStatus();
+ * ```
+ */
+declare function createQueueManager(options: {
+    storage: QueueStorageAdapter;
+}): {
+    pause: () => void;
+    resume: () => void;
+    getStatus: () => Promise<QueueStatus>;
+    clearFailed: () => Promise<void>;
+    retryFailed: () => Promise<void>;
+};
+
+/**
+ * @flightdev/core - Server Actions
+ *
+ * Implementation of React 19 style Server Actions.
+ * Functions marked with 'use server' run on the server.
+ */
+/**
+ * Server action metadata
+ */
+interface ServerAction {
+    /** Unique action ID */
+    id: string;
+    /** Original function name */
+    name: string;
+    /** File path where action is defined */
+    filePath: string;
+    /** The actual action function */
+    fn: (...args: unknown[]) => Promise<unknown>;
+}
+/**
+ * Server action result
+ */
+interface ActionResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+/**
+ * Form action data
+ */
+interface FormActionData {
+    actionId: string;
+    formData: FormData;
+}
+/**
+ * Register a server action
+ */
+declare function registerAction(action: ServerAction): void;
+/**
+ * Get a registered action by ID
+ */
+declare function getAction(id: string): ServerAction | undefined;
+/**
+ * Get all registered actions
+ */
+declare function getAllActions(): ServerAction[];
+/**
+ * Clear all registered actions (useful for testing)
+ */
+declare function clearActions(): void;
+/**
+ * Execute a server action
+ */
+declare function executeAction<T = unknown>(actionId: string, args: unknown[]): Promise<ActionResult<T>>;
+/**
+ * Execute a form action
+ */
+declare function executeFormAction<T = unknown>(actionId: string, formData: FormData): Promise<ActionResult<T>>;
+/**
+ * Generate a unique action ID
+ */
+declare function generateActionId(name: string, filePath: string): string;
+/**
+ * Get cookies in server action context
+ */
+declare function cookies(): {
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string, options?: CookieOptions) => void;
+    delete: (name: string) => void;
+};
+interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+/**
+ * Redirect in server action context
+ */
+declare function redirect(url: string): never;
+/**
+ * Special error for redirects
+ */
+declare class RedirectError extends Error {
+    readonly url: string;
+    constructor(url: string);
+}
+/**
+ * Check if error is a redirect
+ */
+declare function isRedirectError(error: unknown): error is RedirectError;
+/**
+ * Parse form data to typed object
+ */
+declare function parseFormData<T extends Record<string, string>>(formData: FormData): T;
+/**
+ * Create action reference for form action attribute
+ */
+declare function createActionReference(actionId: string): string;
+/**
+ * Handle action request from client
+ */
+declare function handleActionRequest(request: Request): Promise<Response>;
+
+export { type Action, type ActionContext, type ActionMiddleware, type ActionMiddlewareHandler, type ActionNext, type ActionResult, type CookieOptions, type CreateMiddlewareOptions, type FormActionData, type QueueStatus, type QueueStorageAdapter, type QueuedAction, type QueuedActionEntry, type QueuedActionOptions, type QueuedActionResult, RedirectError, type RetryStrategy, type ServerAction, type StreamController, type StreamItem, type StreamProgress, type StreamResult, type StreamableAction, type StreamableActionOptions, type StreamableGenerator, clearActions, collectStream, cookies, createActionContext, createActionMiddleware, createActionReference, createLoggingMiddleware, createMemoryAdapter, createProgressReporter, createQueueManager, createQueuedAction, createRetryMiddleware, createStreamableAction, createTimingMiddleware, defaultRetryStrategy, executeAction, executeFormAction, executeWithMiddleware, exponentialBackoff, fixedDelay, generateActionId, getAction, getAllActions, handleActionRequest, isRedirectError, parseFormData, pipeline, redirect, registerAction, responseToStream, streamToResponse };