@zap-js/client 0.0.2 → 0.0.4

package/dist/runtime/error-boundary.js

@@ -0,0 +1,287 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ZapJS Error Boundary
+ *
+ * TanStack Router style error boundary with explicit errorComponent prop.
+ * Provides structured error handling with server error correlation.
+ */
+import { Component, createContext } from 'react';
+/**
+ * Context for accessing error state in error components
+ */
+export const RouteErrorContext = createContext(null);
+/**
+ * Error Boundary with TanStack Router style errorComponent prop
+ *
+ * @example
+ * ```tsx
+ * // Route file: routes/users.$id.tsx
+ * export default function UserPage() {
+ *   // ... component
+ * }
+ *
+ * export function errorComponent({ error, reset }: ErrorComponentProps) {
+ *   return (
+ *     <div>
+ *       <h1>Failed to load user</h1>
+ *       <p>{error.message}</p>
+ *       {error.digest && <small>Error ID: {error.digest}</small>}
+ *       <button onClick={reset}>Try Again</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export class ErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        /**
+         * Reset the error boundary state
+         */
+        this.reset = () => {
+            this.setState({ hasError: false, error: null });
+        };
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        // Convert Error to ZapRouteError
+        const zapError = normalizeError(error);
+        return { hasError: true, error: zapError };
+    }
+    componentDidCatch(error, errorInfo) {
+        const zapError = normalizeError(error);
+        // Call onError callback if provided
+        if (this.props.onError) {
+            this.props.onError(zapError, errorInfo);
+        }
+        // Log error in development
+        if (process.env.NODE_ENV !== 'production') {
+            console.error('[ErrorBoundary] Caught error:', error);
+            console.error('[ErrorBoundary] Component stack:', errorInfo.componentStack);
+        }
+    }
+    componentDidUpdate(prevProps) {
+        // Reset error state when resetKeys change
+        if (this.state.hasError && this.props.resetKeys) {
+            const prevKeys = prevProps.resetKeys || [];
+            const currentKeys = this.props.resetKeys;
+            const hasChanged = currentKeys.some((key, index) => key !== prevKeys[index]);
+            if (hasChanged) {
+                this.reset();
+            }
+        }
+    }
+    render() {
+        if (this.state.hasError && this.state.error) {
+            const { errorComponent: CustomErrorComponent, fallback } = this.props;
+            const contextValue = {
+                error: this.state.error,
+                reset: this.reset,
+            };
+            // Use custom error component if provided (TanStack style)
+            if (CustomErrorComponent) {
+                return (_jsx(RouteErrorContext.Provider, { value: contextValue, children: _jsx(CustomErrorComponent, { error: this.state.error, reset: this.reset }) }));
+            }
+            // Use fallback if provided
+            if (fallback) {
+                return (_jsx(RouteErrorContext.Provider, { value: contextValue, children: fallback }));
+            }
+            // Use default error component
+            return (_jsx(RouteErrorContext.Provider, { value: contextValue, children: _jsx(DefaultErrorComponent, { error: this.state.error, reset: this.reset }) }));
+        }
+        return this.props.children;
+    }
+}
+// ============================================================================
+// Default Error Component
+// ============================================================================
+/**
+ * Default error fallback UI
+ *
+ * Shows:
+ * - Error message
+ * - Error code (if available)
+ * - Error digest (for server errors)
+ * - Stack trace (development only)
+ * - "Try Again" button
+ */
+export function DefaultErrorComponent({ error, reset }) {
+    const isDev = process.env.NODE_ENV !== 'production';
+    return (_jsx("div", { style: styles.container, children: _jsxs("div", { style: styles.content, children: [_jsx("div", { style: styles.icon, children: _jsxs("svg", { width: "48", height: "48", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [_jsx("circle", { cx: "12", cy: "12", r: "10" }), _jsx("line", { x1: "12", y1: "8", x2: "12", y2: "12" }), _jsx("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })] }) }), _jsx("h1", { style: styles.title, children: "Something went wrong" }), _jsx("p", { style: styles.message, children: error.message }), _jsxs("div", { style: styles.metadata, children: [error.code && (_jsx("span", { style: styles.badge, children: error.code })), error.status && (_jsx("span", { style: styles.badge, children: error.status }))] }), error.digest && (_jsxs("p", { style: styles.digest, children: ["Error ID: ", _jsx("code", { style: styles.code, children: error.digest })] })), isDev && error.stack && (_jsxs("details", { style: styles.details, children: [_jsx("summary", { style: styles.summary, children: "Stack Trace" }), _jsx("pre", { style: styles.stackTrace, children: error.stack })] })), _jsx("button", { onClick: reset, style: styles.button, children: "Try Again" })] }) }));
+}
+// ============================================================================
+// Styles
+// ============================================================================
+const styles = {
+    container: {
+        display: 'flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        minHeight: '100vh',
+        padding: '20px',
+        fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        backgroundColor: '#fafafa',
+        color: '#1a1a1a',
+    },
+    content: {
+        maxWidth: '500px',
+        width: '100%',
+        textAlign: 'center',
+        padding: '40px',
+        backgroundColor: 'white',
+        borderRadius: '12px',
+        boxShadow: '0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)',
+    },
+    icon: {
+        marginBottom: '24px',
+        color: '#ef4444',
+    },
+    title: {
+        margin: '0 0 12px 0',
+        fontSize: '24px',
+        fontWeight: 600,
+    },
+    message: {
+        margin: '0 0 16px 0',
+        fontSize: '16px',
+        color: '#666',
+        lineHeight: 1.5,
+    },
+    metadata: {
+        display: 'flex',
+        gap: '8px',
+        justifyContent: 'center',
+        marginBottom: '16px',
+    },
+    badge: {
+        display: 'inline-block',
+        padding: '4px 8px',
+        fontSize: '12px',
+        fontWeight: 500,
+        backgroundColor: '#f3f4f6',
+        borderRadius: '4px',
+        color: '#4b5563',
+    },
+    digest: {
+        margin: '0 0 20px 0',
+        fontSize: '13px',
+        color: '#888',
+    },
+    code: {
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace',
+        backgroundColor: '#f3f4f6',
+        padding: '2px 6px',
+        borderRadius: '4px',
+        fontSize: '12px',
+    },
+    details: {
+        textAlign: 'left',
+        marginBottom: '20px',
+    },
+    summary: {
+        cursor: 'pointer',
+        fontSize: '14px',
+        color: '#666',
+        marginBottom: '8px',
+    },
+    stackTrace: {
+        fontSize: '12px',
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace',
+        backgroundColor: '#1a1a1a',
+        color: '#f5f5f5',
+        padding: '16px',
+        borderRadius: '8px',
+        overflow: 'auto',
+        maxHeight: '200px',
+        margin: 0,
+        whiteSpace: 'pre-wrap',
+        wordBreak: 'break-word',
+    },
+    button: {
+        padding: '12px 24px',
+        fontSize: '14px',
+        fontWeight: 500,
+        color: 'white',
+        backgroundColor: '#3b82f6',
+        border: 'none',
+        borderRadius: '8px',
+        cursor: 'pointer',
+        transition: 'background-color 0.2s',
+    },
+};
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Normalize any error to ZapRouteError format
+ */
+function normalizeError(error) {
+    // Already a ZapRouteError
+    if (isZapRouteError(error)) {
+        return error;
+    }
+    // Standard Error
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack,
+            // Check for extended properties from server errors
+            code: error.code,
+            status: error.status,
+            digest: error.digest,
+            details: error.details,
+        };
+    }
+    // String error
+    if (typeof error === 'string') {
+        return { message: error };
+    }
+    // Unknown error type
+    return { message: 'An unknown error occurred' };
+}
+/**
+ * Type guard for ZapRouteError
+ */
+function isZapRouteError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+/**
+ * Create a ZapRouteError from server error response
+ */
+export function createRouteError(options) {
+    return {
+        message: options.message,
+        code: options.code,
+        status: options.status,
+        digest: options.digest,
+        details: options.details,
+    };
+}
+/**
+ * Wrap an Error with ZapRouteError metadata
+ */
+export class ZapError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = 'ZapError';
+        this.code = options?.code;
+        this.status = options?.status;
+        this.digest = options?.digest;
+        this.details = options?.details;
+        // Maintain proper prototype chain
+        Object.setPrototypeOf(this, ZapError.prototype);
+    }
+    toRouteError() {
+        return {
+            message: this.message,
+            stack: this.stack,
+            code: this.code,
+            status: this.status,
+            digest: this.digest,
+            details: this.details,
+        };
+    }
+}

package/dist/runtime/hooks.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ZapJS React Hooks
+ *
+ * Custom hooks for error handling and route state management.
+ * TanStack Router style API.
+ */
+import { type ZapRouteError } from './error-boundary.js';
+/**
+ * Access the current route error state
+ *
+ * Must be used within an errorComponent rendered by ErrorBoundary.
+ * TanStack Router style hook for error component access.
+ *
+ * @throws Error if used outside of errorComponent context
+ *
+ * @example
+ * ```tsx
+ * // In your errorComponent
+ * export function errorComponent() {
+ *   const { error, reset } = useRouteError();
+ *
+ *   return (
+ *     <div>
+ *       <h1>Error: {error.message}</h1>
+ *       {error.code && <p>Code: {error.code}</p>}
+ *       {error.digest && <p>ID: {error.digest}</p>}
+ *       <button onClick={reset}>Retry</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useRouteError(): {
+    error: ZapRouteError;
+    reset: () => void;
+};
+/**
+ * Check if currently in an error state
+ *
+ * Safe to use anywhere - returns false if not in error context.
+ * Useful for conditional rendering based on error state.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const isError = useIsErrorState();
+ *
+ *   if (isError) {
+ *     return <div>We're showing an error</div>;
+ *   }
+ *
+ *   return <div>Normal content</div>;
+ * }
+ * ```
+ */
+export declare function useIsErrorState(): boolean;
+/**
+ * Get error state if available, otherwise null
+ *
+ * Safe version of useRouteError that doesn't throw.
+ * Useful when you want to optionally access error state.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const errorState = useErrorState();
+ *
+ *   return (
+ *     <div>
+ *       {errorState && (
+ *         <Banner type="error">{errorState.error.message}</Banner>
+ *       )}
+ *       <MainContent />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useErrorState(): {
+    error: ZapRouteError;
+    reset: () => void;
+} | null;
+export type { ZapRouteError, ErrorComponentProps, ErrorComponent } from './error-boundary.js';

package/dist/runtime/hooks.js

@@ -0,0 +1,96 @@
+/**
+ * ZapJS React Hooks
+ *
+ * Custom hooks for error handling and route state management.
+ * TanStack Router style API.
+ */
+import { useContext } from 'react';
+import { RouteErrorContext } from './error-boundary.js';
+// ============================================================================
+// Error Handling Hooks
+// ============================================================================
+/**
+ * Access the current route error state
+ *
+ * Must be used within an errorComponent rendered by ErrorBoundary.
+ * TanStack Router style hook for error component access.
+ *
+ * @throws Error if used outside of errorComponent context
+ *
+ * @example
+ * ```tsx
+ * // In your errorComponent
+ * export function errorComponent() {
+ *   const { error, reset } = useRouteError();
+ *
+ *   return (
+ *     <div>
+ *       <h1>Error: {error.message}</h1>
+ *       {error.code && <p>Code: {error.code}</p>}
+ *       {error.digest && <p>ID: {error.digest}</p>}
+ *       <button onClick={reset}>Retry</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useRouteError() {
+    const context = useContext(RouteErrorContext);
+    if (!context || !context.error) {
+        throw new Error('useRouteError must be used within an errorComponent. ' +
+            'Make sure you are using this hook inside a component passed to ErrorBoundary as errorComponent prop.');
+    }
+    return { error: context.error, reset: context.reset };
+}
+/**
+ * Check if currently in an error state
+ *
+ * Safe to use anywhere - returns false if not in error context.
+ * Useful for conditional rendering based on error state.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const isError = useIsErrorState();
+ *
+ *   if (isError) {
+ *     return <div>We're showing an error</div>;
+ *   }
+ *
+ *   return <div>Normal content</div>;
+ * }
+ * ```
+ */
+export function useIsErrorState() {
+    const context = useContext(RouteErrorContext);
+    return context !== null && context.error !== null;
+}
+/**
+ * Get error state if available, otherwise null
+ *
+ * Safe version of useRouteError that doesn't throw.
+ * Useful when you want to optionally access error state.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const errorState = useErrorState();
+ *
+ *   return (
+ *     <div>
+ *       {errorState && (
+ *         <Banner type="error">{errorState.error.message}</Banner>
+ *       )}
+ *       <MainContent />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useErrorState() {
+    const context = useContext(RouteErrorContext);
+    if (!context || !context.error) {
+        return null;
+    }
+    return { error: context.error, reset: context.reset };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,229 @@
+import type { Handler, FileRouteConfig, ZapOptions } from "./types.js";
+export type { Handler, ZapRequest, ZapHandlerResponse, ZapConfig, RouteConfig, MiddlewareConfig, StaticFileConfig, StaticFileOptions, FileRouteConfig, ZapOptions, IpcMessage, InvokeHandlerMessage, HandlerResponseMessage, ErrorMessage, HealthCheckMessage, HealthCheckResponseMessage, HttpMethod, InternalHandlerFunction, RpcMessage, RpcCallMessage, RpcResponseMessage, RpcErrorMessage, PendingRequest, SecurityConfig, SecurityHeadersConfig, HstsConfig, RateLimitConfig, CorsConfig, ObservabilityConfig, StreamChunk, StreamingHandler, AnyHandler, StreamStartMessage, StreamChunkMessage, StreamEndMessage, StreamMessage, WsConnection, WsHandler, WsConnectMessage, WsMessageMessage, WsCloseMessage, WsSendMessage, WsMessage, } from "./types.js";
+export { isInvokeHandlerMessage, isHandlerResponseMessage, isErrorMessage, isHealthCheckMessage, isHealthCheckResponseMessage, isRpcResponseMessage, isRpcErrorMessage, isAsyncIterable, } from "./types.js";
+export { ProcessManager } from "./process-manager.js";
+export { IpcServer, IpcClient } from "./ipc-client.js";
+export { ErrorBoundary, DefaultErrorComponent, RouteErrorContext, createRouteError, ZapError, type ZapRouteError, type ErrorComponentProps, type ErrorComponent, } from "./error-boundary.js";
+export { useRouteError, useIsErrorState, useErrorState, } from "./hooks.js";
+export { Logger, logger, type LogContext, type LogLevel, type ChildLogger } from "./logger.js";
+export { RouterProvider, useRouter, useParams, usePathname, useSearchParams, useRouteMatch, useIsPending, Link, NavLink, Outlet, Redirect, type Router, type RouteDefinition, type RouteMatch, type RouterState, type NavigateOptions, type LinkProps, } from "./router.js";
+export { getCsrfToken, useCsrfToken, createCsrfFetch, CsrfTokenInput, CsrfForm, addCsrfToFormData, getCsrfHeaders, type CsrfConfig, type CsrfTokenInputProps, type CsrfFormProps, } from "./csrf.js";
+export { rpcCall, } from "./rpc-client.js";
+/**
+ * Zap - Ultra-fast HTTP server for Node.js and Bun
+ *
+ * This is the main API entry point. It manages:
+ * 1. Route registration from TypeScript
+ * 2. Spawning and managing the Rust binary process
+ * 3. IPC communication between TypeScript handlers and Rust server
+ *
+ * Usage:
+ * ```
+ * const app = new Zap({ port: 3000 });
+ * app.get('/', () => ({ message: 'Hello!' }));
+ * app.post('/api/data', (req) => ({ received: req.body }));
+ * await app.listen();
+ * ```
+ */
+export declare class Zap {
+    private processManager;
+    private ipcServer;
+    private handlers;
+    private routes;
+    private staticFiles;
+    private port;
+    private hostname;
+    private logLevel;
+    private healthCheckPath;
+    private metricsPath;
+    private enableCors;
+    private enableLogging;
+    private enableCompression;
+    private fileRoutingEnabled;
+    private fileRoutingConfig;
+    constructor(options?: ZapOptions);
+    /**
+     * Set the server port
+     */
+    setPort(port: number): this;
+    /**
+     * Set the server hostname
+     */
+    setHostname(hostname: string): this;
+    /**
+     * Enable CORS middleware
+     */
+    cors(): this;
+    /**
+     * Enable request logging middleware
+     */
+    logging(): this;
+    /**
+     * Enable response compression middleware
+     */
+    compression(): this;
+    /**
+     * Set custom health check path
+     */
+    healthCheck(path: string): this;
+    /**
+     * Set metrics endpoint path
+     */
+    metrics(path: string): this;
+    /**
+     * Enable file-based routing (TanStack style)
+     *
+     * Automatically registers routes from the routes/ directory
+     * using the generated route manifest from @zapjs/router
+     */
+    useFileRouting(config?: FileRouteConfig): this;
+    /**
+     * Register a GET route
+     */
+    get<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register a POST route
+     */
+    post<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register a PUT route
+     */
+    put<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register a DELETE route
+     */
+    delete<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register a PATCH route
+     */
+    patch<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register a HEAD route
+     */
+    head<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Convenience method for GET routes that return JSON
+     */
+    getJson<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Convenience method for POST routes that return JSON
+     */
+    postJson<TParams extends Record<string, string> = Record<string, string>>(path: string, handler: Handler<TParams>): this;
+    /**
+     * Register static file serving
+     */
+    static(prefix: string, directory: string): this;
+    /**
+     * Register a route with a handler (internal)
+     */
+    private registerRoute;
+    /**
+     * Start the server
+     */
+    listen(port?: number): Promise<void>;
+    /**
+     * Close the server gracefully
+     */
+    close(): Promise<void>;
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+    /**
+     * Load routes from generated route manifest
+     */
+    private loadFileRoutes;
+}
+/**
+ * Router namespace - all routing functionality
+ * Usage: import { router } from '@zap-js/client'
+ */
+import { RouterProvider, useRouter as useRouterFn, useParams as useParamsFn, usePathname as usePathnameFn, useSearchParams as useSearchParamsFn, useRouteMatch as useRouteMatchFn, useIsPending as useIsPendingFn, Link, NavLink, Outlet, Redirect } from "./router.js";
+export declare const router: {
+    RouterProvider: typeof RouterProvider;
+    useRouter: typeof useRouterFn;
+    useParams: typeof useParamsFn;
+    usePathname: typeof usePathnameFn;
+    useSearchParams: typeof useSearchParamsFn;
+    useRouteMatch: typeof useRouteMatchFn;
+    useIsPending: typeof useIsPendingFn;
+    Link: typeof Link;
+    NavLink: typeof NavLink;
+    Outlet: typeof Outlet;
+    Redirect: typeof Redirect;
+};
+/**
+ * Errors namespace - error handling and boundaries
+ * Usage: import { errors } from '@zap-js/client'
+ */
+import { ErrorBoundary, DefaultErrorComponent, createRouteError, ZapError } from "./error-boundary.js";
+import { useRouteError, useIsErrorState, useErrorState } from "./hooks.js";
+export declare const errors: {
+    readonly ErrorBoundary: typeof ErrorBoundary;
+    readonly DefaultErrorComponent: typeof DefaultErrorComponent;
+    readonly createRouteError: typeof createRouteError;
+    readonly ZapError: typeof ZapError;
+    readonly useRouteError: typeof useRouteError;
+    readonly useIsErrorState: typeof useIsErrorState;
+    readonly useErrorState: typeof useErrorState;
+};
+/**
+ * Middleware namespace - route middleware utilities
+ * Usage: import { middleware } from '@zap-js/client'
+ */
+import { composeMiddleware, requireAuth, requireRole, routeLogger, preloadData } from "./middleware.js";
+export declare const middleware: {
+    readonly compose: typeof composeMiddleware;
+    readonly requireAuth: typeof requireAuth;
+    readonly requireRole: typeof requireRole;
+    readonly logger: typeof routeLogger;
+    readonly preloadData: typeof preloadData;
+};
+/**
+ * Types namespace - type definitions and guards
+ * Usage: import { types } from '@zap-js/client'
+ */
+import * as TypeGuards from "./types.js";
+export declare const types: {
+    isInvokeHandlerMessage: typeof TypeGuards.isInvokeHandlerMessage;
+    isHandlerResponseMessage: typeof TypeGuards.isHandlerResponseMessage;
+    isErrorMessage: typeof TypeGuards.isErrorMessage;
+    isHealthCheckMessage: typeof TypeGuards.isHealthCheckMessage;
+    isHealthCheckResponseMessage: typeof TypeGuards.isHealthCheckResponseMessage;
+    isRpcResponseMessage: typeof TypeGuards.isRpcResponseMessage;
+    isRpcErrorMessage: typeof TypeGuards.isRpcErrorMessage;
+    isAsyncIterable: typeof TypeGuards.isAsyncIterable;
+};
+/**
+ * WebSockets namespace - WebSocket utilities and helpers
+ * Usage: import { websockets } from '@zap-js/client'
+ */
+import * as WebSocketUtils from "./websockets-utils.js";
+export declare const websockets: {
+    readonly isWsMessage: typeof WebSocketUtils.isWsMessage;
+    readonly broadcast: typeof WebSocketUtils.broadcast;
+    readonly broadcastExcept: typeof WebSocketUtils.broadcastExcept;
+    readonly sendJson: typeof WebSocketUtils.sendJson;
+    readonly parseMessage: typeof WebSocketUtils.parseMessage;
+    readonly createErrorMessage: typeof WebSocketUtils.createErrorMessage;
+    readonly createSuccessMessage: typeof WebSocketUtils.createSuccessMessage;
+};
+/**
+ * Streaming namespace - Streaming response utilities
+ * Usage: import { streaming } from '@zap-js/client'
+ */
+import * as StreamingUtils from "./streaming-utils.js";
+export declare const streaming: {
+    readonly isAsyncIterable: typeof TypeGuards.isAsyncIterable;
+    readonly createChunk: typeof StreamingUtils.createChunk;
+    readonly createStream: typeof StreamingUtils.createStream;
+    readonly streamJson: typeof StreamingUtils.streamJson;
+    readonly streamSSE: typeof StreamingUtils.streamSSE;
+    readonly mapStream: typeof StreamingUtils.mapStream;
+    readonly filterStream: typeof StreamingUtils.filterStream;
+    readonly batchStream: typeof StreamingUtils.batchStream;
+    readonly delayStream: typeof StreamingUtils.delayStream;
+    readonly fromReadableStream: typeof StreamingUtils.fromReadableStream;
+    readonly intervalStream: typeof StreamingUtils.intervalStream;
+};
+export default Zap;