@uploadista/server 0.0.7 → 0.0.9

package/dist/index.d.mts

@@ -0,0 +1,1343 @@
+import { n as getAuthCredentials, t as AuthCredentialsResponse } from "./index--Lny6VJP.mjs";
+import { Context, Effect, Layer } from "effect";
+import { Flow, FlowProvider, FlowServerShape } from "@uploadista/core/flow";
+import { BaseEventEmitterService, BaseKvStoreService, DataStoreConfig, EventBroadcasterService, UploadFileDataStore, UploadFileDataStores, UploadFileKVStore } from "@uploadista/core/types";
+import { GenerateId } from "@uploadista/core/utils";
+import { UploadServer, UploadServerShape } from "@uploadista/core/upload";
+import { UploadistaError } from "@uploadista/core/errors";
+import { DataStoreCapabilities, Flow as Flow$1, FlowData, FlowJob, FlowServer as FlowServer$1, UploadEvent, UploadFile, UploadServer as UploadServer$1, UploadistaError as UploadistaError$1 } from "@uploadista/core";
+import z$1, { z } from "zod";
+
+//#region src/core/routes.d.ts
+type UploadistaRouteType = "create-upload" | "get-capabilities" | "get-upload" | "upload-chunk" | "get-flow" | "run-flow" | "job-status" | "resume-flow" | "pause-flow" | "cancel-flow" | "not-found" | "bad-request" | "method-not-allowed" | "unsupported-content-type";
+type UploadistaRoute<T extends UploadistaRouteType> = {
+  type: T;
+};
+type UploadistaStandardResponse<T extends UploadistaRouteType, ResponseBody, Status extends number = 200> = UploadistaRoute<T> & {
+  status: Status;
+  headers: {
+    "Content-Type": "application/json";
+  };
+  body: ResponseBody;
+};
+type NotFoundRequest = UploadistaRoute<"not-found">;
+type NotFoundResponse = UploadistaStandardResponse<"not-found", {
+  error: "Not found";
+}, 404>;
+type MethodNotAllowedRequest = UploadistaRoute<"method-not-allowed">;
+type MethodNotAllowedResponse = UploadistaStandardResponse<"method-not-allowed", {
+  error: "Method not allowed";
+}, 405>;
+type BadRequestRequest = UploadistaRoute<"bad-request"> & {
+  message: string;
+};
+type BadRequestResponse = UploadistaStandardResponse<"bad-request", {
+  error: "Bad request";
+  message: string;
+}, 400>;
+type UnsupportedContentTypeRequest = UploadistaRoute<"unsupported-content-type">;
+type UnsupportedContentTypeResponse = UploadistaStandardResponse<"unsupported-content-type", {
+  error: "Unsupported content type";
+}, 415>;
+type CreateUploadRequest = UploadistaRoute<"create-upload"> & {
+  data: unknown;
+};
+type CreateUploadResponse = UploadistaStandardResponse<"create-upload", UploadFile>;
+type GetCapabilitiesRequest = UploadistaRoute<"get-capabilities"> & {
+  storageId: string;
+};
+type GetCapabilitiesResponse = UploadistaStandardResponse<"get-capabilities", {
+  storageId: string;
+  capabilities: DataStoreCapabilities;
+  timestamp: string;
+}>;
+type GetUploadRequest = UploadistaRoute<"get-upload"> & {
+  uploadId: string;
+};
+type GetUploadResponse = UploadistaStandardResponse<"get-upload", UploadFile>;
+type UploadChunkRequest = UploadistaRoute<"upload-chunk"> & {
+  uploadId: string;
+  data: ReadableStream;
+};
+type UploadChunkResponse = UploadistaStandardResponse<"upload-chunk", UploadFile>;
+type GetFlowRequest = UploadistaRoute<"get-flow"> & {
+  flowId: string;
+};
+type GetFlowResponse = UploadistaStandardResponse<"get-flow", FlowData>;
+type RunFlowRequest = UploadistaRoute<"run-flow"> & {
+  flowId: string;
+  storageId: string;
+  inputs: Record<string, unknown>;
+};
+type RunFlowResponse = UploadistaStandardResponse<"run-flow", FlowJob>;
+type GetJobStatusRequest = UploadistaRoute<"job-status"> & {
+  jobId: string;
+};
+type GetJobStatusResponse = UploadistaStandardResponse<"job-status", FlowJob>;
+type ResumeFlowRequest = UploadistaRoute<"resume-flow"> & {
+  jobId: string;
+  nodeId: string;
+  newData: unknown;
+};
+type ResumeFlowResponse = UploadistaStandardResponse<"resume-flow", FlowJob>;
+type PauseFlowRequest = UploadistaRoute<"pause-flow"> & {
+  jobId: string;
+};
+type PauseFlowResponse = UploadistaStandardResponse<"pause-flow", FlowJob>;
+type CancelFlowRequest = UploadistaRoute<"cancel-flow"> & {
+  jobId: string;
+};
+type CancelFlowResponse = UploadistaStandardResponse<"cancel-flow", FlowJob>;
+type UploadistaRequest = CreateUploadRequest | GetCapabilitiesRequest | GetUploadRequest | UploadChunkRequest | GetFlowRequest | RunFlowRequest | GetJobStatusRequest | ResumeFlowRequest | PauseFlowRequest | CancelFlowRequest | NotFoundRequest | BadRequestRequest | MethodNotAllowedRequest | UnsupportedContentTypeRequest;
+type UploadistaResponse = CreateUploadResponse | GetCapabilitiesResponse | GetUploadResponse | UploadChunkResponse | GetFlowResponse | RunFlowResponse | GetJobStatusResponse | ResumeFlowResponse | PauseFlowResponse | CancelFlowResponse | NotFoundResponse | BadRequestResponse | MethodNotAllowedResponse | UnsupportedContentTypeResponse | StandardResponse;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Authentication context containing user identity and authorization metadata.
+ * This context is extracted from authentication middleware and made available
+ * throughout the upload and flow processing pipeline via Effect Layer.
+ */
+type AuthContext = {
+  /**
+   * Unique identifier for the authenticated user.
+   * This is typically extracted from JWT claims (sub), session data, or API key metadata.
+   */
+  clientId: string;
+  /**
+   * Optional metadata for authorization and tracking purposes.
+   * Can include rate limits, quotas, permissions, or custom application data.
+   *
+   * @example
+   * ```typescript
+   * {
+   *   permissions: ['upload:create', 'flow:execute'],
+   *   rateLimit: { requests: 1000, period: 3600 },
+   *   quota: { storage: 10737418240, used: 5368709120 }
+   * }
+   * ```
+   */
+  metadata?: Record<string, unknown>;
+  /**
+   * Optional list of permissions granted to the user.
+   * These can be used for fine-grained access control in the future.
+   */
+  permissions?: string[];
+};
+/**
+ * Result type for authentication middleware.
+ * - AuthContext: Successful authentication with user identity
+ * - null: Authentication failed or not authenticated
+ */
+type AuthResult = AuthContext | null;
+//#endregion
+//#region src/adapter/types.d.ts
+/**
+ * Standard request representation extracted from framework-specific request objects.
+ *
+ * This interface provides a framework-agnostic way to represent HTTP requests,
+ * allowing the core server logic to work uniformly across Hono, Express, Fastify,
+ * and other frameworks.
+ *
+ * @example
+ * ```typescript
+ * const standardRequest: StandardRequest = {
+ *   method: "POST",
+ *   url: new URL("https://example.com/uploadista/api/upload"),
+ *   headers: { "content-type": "application/json" },
+ *   body: { file: "data" }
+ * };
+ * ```
+ */
+interface StandardRequest {
+  /**
+   * HTTP method (GET, POST, PATCH, etc.)
+   */
+  method: string;
+  /**
+   * Full URL of the request including protocol, host, path, and query parameters
+   */
+  url: URL;
+  /**
+   * Request headers as key-value pairs
+   */
+  headers: Record<string, string>;
+  /**
+   * Optional request body (parsed or raw)
+   */
+  body?: unknown;
+}
+/**
+ * Standard response representation to be sent by framework-specific adapters.
+ *
+ * The core server produces StandardResponse objects, which adapters then
+ * translate into framework-specific response formats.
+ *
+ * @example
+ * ```typescript
+ * const standardResponse: StandardResponse = {
+ *   status: 200,
+ *   headers: { "content-type": "application/json" },
+ *   body: { uploadId: "abc123" }
+ * };
+ * ```
+ */
+interface StandardResponse {
+  /**
+   * HTTP status code (200, 404, 500, etc.)
+   */
+  status: number;
+  /**
+   * Optional response headers as key-value pairs
+   */
+  headers?: Record<string, string>;
+  /**
+   * Optional response body (will be JSON-stringified if object)
+   */
+  body?: unknown;
+}
+/**
+ * WebSocket handler interface for framework-agnostic WebSocket management.
+ *
+ * This interface allows the core server to interact with WebSocket connections
+ * without needing to know about framework-specific WebSocket APIs.
+ *
+ * @example
+ * ```typescript
+ * const wsHandler: WebSocketHandler = {
+ *   onMessage: (message) => console.log("Received:", message),
+ *   onClose: () => console.log("Connection closed"),
+ *   onError: (error) => console.error("WebSocket error:", error)
+ * };
+ * ```
+ */
+interface WebSocketHandler {
+  /**
+   * Callback invoked when a message is received from the client
+   *
+   * @param message - The message string received
+   */
+  onMessage: (message: string) => void;
+  /**
+   * Callback invoked when the WebSocket connection is closed
+   */
+  onClose: () => void;
+  /**
+   * Callback invoked when a WebSocket error occurs
+   *
+   * @param error - The error that occurred
+   */
+  onError: (error: Error) => void;
+}
+/**
+ * ServerAdapter interface that framework adapters must implement.
+ *
+ * This interface defines the contract between the core server (framework-agnostic)
+ * and framework-specific adapters (Hono, Express, Fastify, etc.).
+ *
+ * Each adapter translates between framework-specific request/response types
+ * and the standard types used by the core server.
+ *
+ * @template TRequest - Framework-specific request type (e.g., Context for Hono, Request for Express)
+ * @template TResponse - Framework-specific response type (e.g., Context for Hono, Response for Express)
+ * @template TWebSocket - Framework-specific WebSocket type (optional, defaults to unknown)
+ *
+ * @example
+ * ```typescript
+ * // Hono adapter example
+ * const honoAdapter: ServerAdapter<Context, Context, WSEvents> = {
+ *   extractRequest: (c) => Effect.succeed({
+ *     method: c.req.raw.method,
+ *     url: new URL(c.req.raw.url),
+ *     headers: Object.fromEntries(c.req.raw.headers.entries()),
+ *     body: c.req.raw.body
+ *   }),
+ *   sendResponse: (c, response) => Effect.sync(() =>
+ *     new Response(JSON.stringify(response.body), {
+ *       status: response.status,
+ *       headers: response.headers
+ *     })
+ *   ),
+ *   runAuthMiddleware: (c) => Effect.tryPromise(() => authMiddleware(c)),
+ *   createWebSocketHandler: (ws) => ({ ... })
+ * };
+ * ```
+ */
+interface ServerAdapter<TContext, TResponse, TWebSocketHandler = unknown> {
+  /**
+   * Extract standard request details from framework-specific request.
+   *
+   * This method converts the framework's native request object into a
+   * UploadistaRequest that the core server can process uniformly.
+   *
+   * @param req - Framework-specific request object
+   * @returns Effect that produces UploadistaRequest on success
+   */
+  extractRequest(req: TContext, {
+    baseUrl
+  }: {
+    baseUrl: string;
+  }): Effect.Effect<UploadistaRequest, never, never>;
+  /**
+   * Send standard response using framework-specific response object.
+   *
+   * This method converts a UploadistaResponse from the core server into
+   * the format required by the framework (e.g., Web API Response, Express res.json()).
+   *
+   * @param response - Standard response to send
+   * @returns Effect that completes when response is sent
+   */
+  sendResponse(response: UploadistaResponse, context: TContext): Effect.Effect<TResponse, never, never>;
+  /**
+   * Optional: Run framework-specific auth middleware.
+   *
+   * If provided, this method is called before each request is processed.
+   * It should execute the framework's authentication middleware and return
+   * an AuthResult (AuthContext on success, null on failure).
+   *
+   * If not provided, the adapter assumes no authentication is required.
+   *
+   * @param ctx - Framework-specific context object
+   * @param res - Framework-specific response object
+   * @returns Effect that produces AuthResult (AuthContext or null)
+   */
+  runAuthMiddleware?(ctx: TContext): Effect.Effect<AuthResult, never, never>;
+  /**
+   * Optional: Create WebSocket handler for real-time updates.
+   *
+   * Only needed if the framework supports WebSocket connections for
+   * real-time upload progress and flow status updates.
+   *
+   * @param ws - Framework-specific WebSocket object
+   * @param ctx - Framework-specific context object (for initial handshake)
+   * @param context - Server context with baseUrl, uploadServer, and flowServer
+   * @returns WebSocketHandler with callbacks for message, close, and error events
+   */
+  webSocketHandler(context: {
+    baseUrl: string;
+  }): Effect.Effect<TWebSocketHandler, never, UploadServer$1 | FlowServer$1>;
+  /**
+   * Optional: Extract waitUntil callback from the framework context.
+   *
+   * When provided, allows flows to execute beyond the HTTP response lifecycle.
+   * This function is called per-request to extract the waitUntil callback from
+   * the framework-specific context.
+   *
+   * @param ctx - Framework-specific context object
+   * @returns The waitUntil callback or undefined if not available
+   *
+   * @example
+   * ```typescript
+   * // Cloudflare Workers with Hono:
+   * extractWaitUntil: (c) => c.executionCtx.waitUntil.bind(c.executionCtx)
+   * ```
+   */
+  extractWaitUntil?: (ctx: TContext) => ((promise: Promise<unknown>) => void) | undefined;
+}
+//#endregion
+//#region src/cache.d.ts
+/**
+ * Configuration options for the auth cache.
+ */
+type AuthCacheConfig = {
+  /**
+   * Maximum number of entries in the cache.
+   * When exceeded, oldest entries are removed (LRU eviction).
+   * @default 10000
+   */
+  maxSize?: number;
+  /**
+   * Time-to-live for cache entries in milliseconds.
+   * Entries older than this will be automatically evicted.
+   * @default 3600000 (1 hour)
+   */
+  ttl?: number;
+};
+declare const AuthCacheService_base: Context.TagClass<AuthCacheService, "AuthCacheService", {
+  /**
+   * Store an auth context for a job ID.
+   */
+  readonly set: (jobId: string, authContext: AuthContext) => Effect.Effect<void>;
+  /**
+   * Retrieve a cached auth context by job ID.
+   * Returns null if not found or expired.
+   */
+  readonly get: (jobId: string) => Effect.Effect<AuthContext | null>;
+  /**
+   * Delete a cached auth context by job ID.
+   */
+  readonly delete: (jobId: string) => Effect.Effect<void>;
+  /**
+   * Clear all cached auth contexts.
+   */
+  readonly clear: () => Effect.Effect<void>;
+  /**
+   * Get the current number of cached entries.
+   */
+  readonly size: () => Effect.Effect<number>;
+}>;
+/**
+ * Auth Cache Service
+ *
+ * Provides caching of authentication contexts for upload and flow jobs.
+ * This allows subsequent operations (chunk uploads, flow continuations)
+ * to reuse the auth context from the initial request without re-authenticating.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AuthCacheService } from "@uploadista/server";
+ *
+ * const handler = Effect.gen(function* () {
+ *   const authCache = yield* AuthCacheService;
+ *   const authContext = { userId: "user-123" };
+ *
+ *   // Cache auth for upload
+ *   yield* authCache.set("upload-abc", authContext);
+ *
+ *   // Retrieve cached auth later
+ *   const cached = yield* authCache.get("upload-abc");
+ *   console.log(cached?.userId); // "user-123"
+ *
+ *   // Clear when done
+ *   yield* authCache.delete("upload-abc");
+ * });
+ * ```
+ */
+declare class AuthCacheService extends AuthCacheService_base {}
+/**
+ * Creates an AuthCacheService Layer with in-memory storage.
+ *
+ * @param config - Optional configuration for cache behavior
+ * @returns Effect Layer providing AuthCacheService
+ */
+declare const AuthCacheServiceLive: (config?: AuthCacheConfig) => Layer.Layer<AuthCacheService>;
+/**
+ * No-op implementation of AuthCacheService.
+ * Does not cache anything - all operations are no-ops.
+ * Used when caching is disabled or not needed.
+ */
+declare const NoAuthCacheServiceLive: Layer.Layer<AuthCacheService>;
+//#endregion
+//#region src/core/types.d.ts
+/**
+ * Function type for retrieving flows based on flow ID and client ID.
+ *
+ * This function is called by the core server when a flow needs to be executed.
+ * It should return an Effect that resolves to the requested Flow or fails with
+ * an UploadistaError if the flow is not found or not authorized.
+ *
+ * @param flowId - The unique identifier of the flow to retrieve
+ * @param clientId - The authenticated client ID (null if not authenticated)
+ * @returns Effect that produces the Flow or fails with an error
+ *
+ * @example
+ * ```typescript
+ * const flows: FlowsFunction = (flowId, clientId) =>
+ *   Effect.gen(function* () {
+ *     if (flowId === "image-resize") {
+ *       return imageResizeFlow;
+ *     }
+ *     return yield* Effect.fail(
+ *       new UploadistaError({ code: "FLOW_NOT_FOUND", status: 404 })
+ *     );
+ *   });
+ * ```
+ */
+type FlowsFunction = (flowId: string, clientId: string | null) => Effect.Effect<Flow<z.ZodSchema<unknown>, z.ZodSchema<unknown>, unknown>, UploadistaError$1, unknown>;
+/**
+ * Configuration for creating the unified Uploadista server.
+ *
+ * This configuration is framework-agnostic and contains all the business logic
+ * configuration. Framework-specific details are provided via the `adapter` field.
+ *
+ * @template TRequest - Framework-specific request type
+ * @template TResponse - Framework-specific response type
+ * @template TWebSocket - Framework-specific WebSocket type (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaServer, honoAdapter } from "@uploadista/server";
+ *
+ * const config: UploadistaServerConfig<Context, Context, WSEvents> = {
+ *   // Core business logic configuration
+ *   flows: getFlowById,
+ *   dataStore: { type: "s3", config: { bucket: "my-bucket" } },
+ *   kvStore: redisKvStore,
+ *   baseUrl: "/uploadista",
+ *
+ *   // Framework-specific adapter
+ *   adapter: honoAdapter({
+ *     authMiddleware: async (c) => {
+ *       // Hono-specific auth logic
+ *       return { clientId: "user-123" };
+ *     },
+ *   }),
+ * };
+ *
+ * const server = await createUploadistaServer(config);
+ * ```
+ */
+interface UploadistaServerConfig<TRequest, TResponse, TWebSocket = unknown> {
+  /**
+   * Function for retrieving flows by ID.
+   *
+   * This function is called when a flow execution is requested.
+   * It receives the flow ID and client ID (from auth context) and should
+   * return an Effect that resolves to the Flow definition.
+   *
+   * @example
+   * ```typescript
+   * flows: (flowId, clientId) => Effect.succeed(myFlows[flowId])
+   * ```
+   */
+  flows: FlowsFunction;
+  /**
+   * Data store configuration for file storage.
+   *
+   * Specifies where uploaded files should be stored (S3, Azure, GCS, filesystem).
+   * The core server creates the appropriate data store layer from this configuration.
+   *
+   * @example
+   * ```typescript
+   * dataStore: {
+   *   type: "s3",
+   *   config: {
+   *     bucket: "my-uploads",
+   *     region: "us-east-1"
+   *   }
+   * }
+   * ```
+   */
+  dataStore: DataStoreConfig;
+  /**
+   * Key-value store layer for metadata storage.
+   *
+   * Used for storing upload metadata, flow job state, and other persistent data.
+   * Can be Redis, Cloudflare KV, in-memory, or any implementation of BaseKvStoreService.
+   *
+   * @example
+   * ```typescript
+   * import { redisKvStore } from "@uploadista/kv-store-redis";
+   *
+   * kvStore: redisKvStore({ url: "redis://localhost:6379" })
+   * ```
+   */
+  kvStore: Layer.Layer<BaseKvStoreService>;
+  /**
+   * Optional: Plugins to extend functionality.
+   *
+   * Plugins are Effect layers that add additional capabilities to the upload
+   * and flow servers. They are merged into the server layer composition.
+   *
+   * @example
+   * ```typescript
+   * plugins: [imageProcessingPlugin, virusScanPlugin]
+   * ```
+   */
+  plugins?: readonly Layer.Layer<any, never, never>[];
+  /**
+   * Optional: Event emitter layer for progress notifications.
+   *
+   * Used to emit upload progress, flow status updates, and other events.
+   * Defaults to in-memory event emitter if not provided.
+   *
+   * @example
+   * ```typescript
+   * import { webSocketEventEmitter } from "@uploadista/event-emitter-websocket";
+   *
+   * eventEmitter: webSocketEventEmitter()
+   * ```
+   */
+  eventEmitter?: Layer.Layer<BaseEventEmitterService>;
+  /**
+   * Optional: Event broadcaster layer for real-time updates.
+   *
+   * Used to broadcast events to multiple subscribers (e.g., WebSocket connections).
+   * Defaults to in-memory broadcaster if not provided.
+   *
+   * @example
+   * ```typescript
+   * import { memoryEventBroadcaster } from "@uploadista/event-broadcaster-memory";
+   *
+   * eventBroadcaster: memoryEventBroadcaster()
+   * ```
+   */
+  eventBroadcaster?: Layer.Layer<EventBroadcasterService>;
+  /**
+   * Optional: Base URL path for Uploadista endpoints.
+   *
+   * All Uploadista routes will be prefixed with `{baseUrl}/api/`.
+   * For example, with baseUrl="/uploadista", routes become:
+   * - POST /uploadista/api/upload
+   * - POST /uploadista/api/flow/{flowId}/{storageId}
+   *
+   * @default "" (no prefix, routes start with /api/)
+   */
+  baseUrl?: string;
+  /**
+   * Optional: Custom ID generator layer.
+   *
+   * Used for generating upload IDs, job IDs, and other unique identifiers.
+   * Defaults to built-in ID generator if not provided.
+   *
+   * @example
+   * ```typescript
+   * import { nanoidGenerator } from "@uploadista/utils";
+   *
+   * generateId: nanoidGenerator()
+   * ```
+   */
+  generateId?: Layer.Layer<GenerateId>;
+  /**
+   * Optional: Enable distributed tracing with OpenTelemetry.
+   *
+   * When true, Effect programs run with OpenTelemetry tracing enabled,
+   * allowing observability into upload and flow execution.
+   *
+   * @default false
+   */
+  withTracing?: boolean;
+  /**
+   * Optional: Metrics layer for observability.
+   *
+   * Used to collect metrics about upload/flow performance, errors, and usage.
+   * Defaults to NoOp metrics if not provided.
+   *
+   * @example
+   * ```typescript
+   * import { prometheusMetrics } from "@uploadista/observability";
+   *
+   * metricsLayer: prometheusMetrics()
+   * ```
+   */
+  metricsLayer?: Layer.Layer<any, never, never>;
+  /**
+   * Optional: Buffered data store layer for performance optimization.
+   *
+   * Provides in-memory buffering for frequently accessed data,
+   * reducing latency for chunk uploads and reads.
+   *
+   * @example
+   * ```typescript
+   * import { bufferedDataStore } from "@uploadista/core/data-store";
+   *
+   * bufferedDataStore: bufferedDataStore({ maxSize: 1024 * 1024 * 10 })
+   * ```
+   */
+  bufferedDataStore?: Layer.Layer<UploadFileDataStore, never, UploadFileKVStore>;
+  /**
+   * Framework-specific adapter.
+   *
+   * The adapter provides the bridge between framework-specific request/response
+   * types and the standard types used by the core server. Each framework
+   * (Hono, Express, Fastify) has its own adapter implementation.
+   *
+   * @example
+   * ```typescript
+   * import { honoAdapter } from "@uploadista/adapters-hono";
+   *
+   * adapter: honoAdapter({
+   *   authMiddleware: async (c) => ({ clientId: "user-123" })
+   * })
+   * ```
+   */
+  adapter: ServerAdapter<TRequest, TResponse, TWebSocket>;
+  /**
+   * Optional: Configuration for auth context caching.
+   *
+   * Caching allows subsequent requests (chunk uploads, flow continuations) to
+   * reuse the auth context from the initial request without re-authenticating.
+   *
+   * @example
+   * ```typescript
+   * authCacheConfig: {
+   *   maxSize: 10000,
+   *   ttl: 3600000 // 1 hour
+   * }
+   * ```
+   */
+  authCacheConfig?: AuthCacheConfig;
+}
+/**
+ * Return type from createUploadistaServer.
+ *
+ * Contains the handler function and exposed server layers for framework-specific routing.
+ *
+ * @template TRequest - Framework-specific request type
+ * @template TResponse - Framework-specific response type
+ * @template TWebSocket - Framework-specific WebSocket type (optional)
+ */
+interface UploadistaServer<TRequest, TResponse, TWebSocketHandler = unknown> {
+  /**
+   * Main request handler that processes HTTP requests through the adapter.
+   */
+  handler: (req: TRequest) => Promise<TResponse>;
+  /**
+   * Optional WebSocket handler if the adapter supports WebSocket connections.
+   */
+  websocketHandler: TWebSocketHandler;
+  /**
+   * Base URL path for Uploadista endpoints.
+   */
+  baseUrl: string;
+  /**
+   * Dispose function for graceful shutdown.
+   * Cleans up all resources associated with the managed runtime.
+   * Should be called when the server is shutting down.
+   */
+  dispose: () => Promise<void>;
+}
+//#endregion
+//#region src/core/server.d.ts
+/**
+ * Creates the unified Uploadista server with framework-specific adapter.
+ *
+ * This function composes all layers (upload server, flow server, auth, metrics)
+ * and returns a handler that works with any framework via the provided adapter.
+ *
+ * The core server handles:
+ * - Route parsing and matching
+ * - Auth middleware execution with timeout protection
+ * - Layer composition (upload/flow servers, auth cache, metrics)
+ * - Error handling and response formatting
+ * - Effect program execution with optional tracing
+ *
+ * @param config - Server configuration including adapter and business logic
+ * @returns Object with handler function, optional WebSocket handler, and base URL
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaServer, honoAdapter } from "@uploadista/server";
+ *
+ * const server = await createUploadistaServer({
+ *   flows: getFlowById,
+ *   dataStore: { type: "s3", config: { bucket: "uploads" } },
+ *   kvStore: redisKvStore,
+ *   adapter: honoAdapter({
+ *     authMiddleware: async (c) => ({ clientId: "user-123" })
+ *   })
+ * });
+ *
+ * // Use with Hono
+ * app.all("/uploadista/*", server.handler);
+ * ```
+ */
+declare const createUploadistaServer: <TContext, TResponse, TWebSocketHandler = unknown>({
+  flows,
+  dataStore,
+  kvStore,
+  plugins,
+  eventEmitter,
+  eventBroadcaster,
+  withTracing,
+  baseUrl: configBaseUrl,
+  generateId,
+  metricsLayer,
+  bufferedDataStore,
+  adapter,
+  authCacheConfig
+}: UploadistaServerConfig<TContext, TResponse, TWebSocketHandler>) => Promise<UploadistaServer<TContext, TResponse, TWebSocketHandler>>;
+//#endregion
+//#region src/core/websocket-routes.d.ts
+/**
+ * Framework-agnostic WebSocket connection interface
+ * Adapters should wrap their native WebSocket implementations to match this interface
+ */
+type WebSocketConnection = {
+  id: string;
+  send: (data: string) => void;
+  close: (code?: number, reason?: string) => void;
+  readyState: number;
+};
+/**
+ * WebSocket event types for real-time communication
+ */
+type WebSocketEventType = "subscribe-upload" | "subscribe-flow" | "unsubscribe-upload" | "unsubscribe-flow" | "ping" | "connection" | "upload-event" | "flow-event" | "error" | "invalid-path" | "auth-failed";
+/**
+ * Base WebSocket event structure
+ */
+type WebSocketEvent<T extends WebSocketEventType> = {
+  type: T;
+};
+/**
+ * Incoming WebSocket messages (client -> server)
+ */
+type SubscribeUploadEvent = WebSocketEvent<"subscribe-upload"> & {
+  uploadId: string;
+};
+type SubscribeFlowEvent = WebSocketEvent<"subscribe-flow"> & {
+  jobId: string;
+};
+type UnsubscribeUploadEvent = WebSocketEvent<"unsubscribe-upload"> & {
+  uploadId: string;
+};
+type UnsubscribeFlowEvent = WebSocketEvent<"unsubscribe-flow"> & {
+  jobId: string;
+};
+type PingEvent = WebSocketEvent<"ping">;
+type WebSocketIncomingEvent = SubscribeUploadEvent | SubscribeFlowEvent | UnsubscribeUploadEvent | UnsubscribeFlowEvent | PingEvent;
+/**
+ * Outgoing WebSocket messages (server -> client)
+ */
+type ConnectionEvent = WebSocketEvent<"connection"> & {
+  message: string;
+  id?: string;
+  jobId?: string;
+  uploadId?: string;
+  timestamp: string;
+};
+type UploadEventMessage = WebSocketEvent<"upload-event"> & {
+  uploadId: string;
+  event: UploadEvent;
+  timestamp: string;
+};
+type FlowEventMessage = WebSocketEvent<"flow-event"> & {
+  jobId: string;
+  event: unknown;
+  timestamp: string;
+};
+type ErrorEvent = WebSocketEvent<"error"> & {
+  message: string;
+  code?: string;
+};
+type InvalidPathEvent = WebSocketEvent<"invalid-path"> & {
+  message: string;
+  expectedPrefix: string;
+};
+type AuthFailedEvent = WebSocketEvent<"auth-failed"> & {
+  message: string;
+  authMethod: "token" | "cookies";
+};
+type WebSocketOutgoingEvent = ConnectionEvent | UploadEventMessage | FlowEventMessage | ErrorEvent | InvalidPathEvent | AuthFailedEvent;
+/**
+ * WebSocket connection request with routing information
+ * Extracted from the WebSocket URL and query parameters
+ */
+type WebSocketConnectionRequest = {
+  /** Base URL prefix for WebSocket connections */
+  baseUrl: string;
+  /** Full pathname from the URL */
+  pathname: string;
+  /** Parsed route segments after baseUrl/ws/ */
+  routeSegments: string[];
+  /** Whether this is an upload route */
+  isUploadRoute: boolean;
+  /** Whether this is a flow route */
+  isFlowRoute: boolean;
+  /** Job ID (for flows) */
+  jobId?: string;
+  /** Upload ID (for uploads) */
+  uploadId?: string;
+  /** Event ID (jobId or uploadId) */
+  eventId?: string;
+  /** WebSocket connection instance */
+  connection: WebSocketConnection;
+};
+//#endregion
+//#region src/core/websocket-handlers/websocket-handlers.d.ts
+/**
+ * Handles WebSocket connection opening
+ * Subscribes to the appropriate events based on the connection request
+ */
+declare const handleWebSocketOpen: (request: WebSocketConnectionRequest, uploadServer: UploadServerShape, flowServer: FlowServerShape) => Effect.Effect<void, never, unknown>;
+/**
+ * Handles incoming WebSocket messages
+ * Currently supports ping/pong for connection keep-alive
+ */
+declare const handleWebSocketMessage: (message: string, connection: WebSocketConnection) => Effect.Effect<void, never, never>;
+/**
+ * Handles WebSocket connection closing
+ * Unsubscribes from all events and cleans up resources
+ */
+declare const handleWebSocketClose: (request: WebSocketConnectionRequest, uploadServer: UploadServerShape, flowServer: FlowServerShape) => Effect.Effect<void, never, unknown>;
+/**
+ * Handles WebSocket errors
+ */
+declare const handleWebSocketError: (error: unknown, eventId?: string) => Effect.Effect<void, never, never>;
+//#endregion
+//#region src/error-types.d.ts
+/**
+ * Base adapter error class for HTTP adapters.
+ * All adapter-specific errors should extend this class or one of its subclasses.
+ *
+ * @example
+ * ```typescript
+ * throw new AdapterError("Something went wrong", 500, "INTERNAL_ERROR");
+ * ```
+ */
+declare class AdapterError extends Error {
+  readonly statusCode: number;
+  readonly errorCode: string;
+  constructor(message: string, statusCode?: number, errorCode?: string);
+}
+/**
+ * Validation error - indicates invalid request data or parameters.
+ * Returns HTTP 400 Bad Request status.
+ *
+ * @example
+ * ```typescript
+ * if (!isValidUploadId(id)) {
+ *   throw new ValidationError("Invalid upload ID format");
+ * }
+ * ```
+ */
+declare class ValidationError extends AdapterError {
+  constructor(message: string);
+}
+/**
+ * Not found error - indicates a requested resource does not exist.
+ * Returns HTTP 404 Not Found status.
+ *
+ * @example
+ * ```typescript
+ * if (!upload) {
+ *   throw new NotFoundError("Upload");
+ * }
+ * ```
+ */
+declare class NotFoundError extends AdapterError {
+  constructor(resource: string);
+}
+/**
+ * Bad request error - indicates a malformed request.
+ * Returns HTTP 400 Bad Request status.
+ * Similar to ValidationError but for request structure issues.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = JSON.parse(body);
+ * } catch {
+ *   throw new BadRequestError("Invalid JSON body");
+ * }
+ * ```
+ */
+declare class BadRequestError extends AdapterError {
+  constructor(message: string);
+}
+/**
+ * Creates a standardized error response object for AdapterError.
+ * Includes error message, error code, and ISO timestamp.
+ *
+ * @param error - The AdapterError to format
+ * @returns Standardized error response body
+ *
+ * @example
+ * ```typescript
+ * import { createErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createErrorResponseBody(err);
+ *   res.status(err.statusCode).json(errorResponse);
+ * }
+ * ```
+ */
+declare const createErrorResponseBody: (error: AdapterError) => {
+  error: string;
+  code: string;
+  timestamp: string;
+};
+/**
+ * Creates a standardized error response body from UploadistaError.
+ * Formats core library errors for HTTP responses with optional details.
+ *
+ * @param error - The UploadistaError to format
+ * @returns Standardized error response body with error, code, timestamp, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   const result = yield* uploadServer.handleUpload(input);
+ * } catch (err) {
+ *   if (err instanceof UploadistaError) {
+ *     const errorResponse = createUploadistaErrorResponseBody(err);
+ *     res.status(400).json(errorResponse);
+ *   }
+ * }
+ * ```
+ */
+declare const createUploadistaErrorResponseBody: (error: UploadistaError) => {
+  error: string;
+  code: string;
+  timestamp: string;
+  details?: unknown;
+};
+/**
+ * Creates a generic error response body for unknown/unexpected errors.
+ * Used as a fallback when error type cannot be determined.
+ *
+ * @param message - Error message to include in response (defaults to "Internal server error")
+ * @returns Standardized error response body with generic INTERNAL_ERROR code
+ *
+ * @example
+ * ```typescript
+ * import { createGenericErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createGenericErrorResponseBody(
+ *     err instanceof Error ? err.message : "Unknown error"
+ *   );
+ *   res.status(500).json(errorResponse);
+ * }
+ * ```
+ */
+declare const createGenericErrorResponseBody: (message?: string) => {
+  error: string;
+  code: string;
+  timestamp: string;
+};
+//#endregion
+//#region src/http-utils.d.ts
+/**
+ * Shared HTTP utilities for server adapters
+ *
+ * This module provides routing and error handling utilities used across
+ * Hono, Express, and Fastify adapters for request parsing and response formatting.
+ */
+/**
+ * Parses URL segments from a pathname, filtering out empty segments.
+ * Useful for extracting route components from request paths.
+ *
+ * @param pathname - The URL pathname (e.g., "/uploadista/api/upload/abc123")
+ * @returns Array of non-empty path segments
+ *
+ * @example
+ * ```typescript
+ * const segments = parseUrlSegments("/uploadista/api/upload/abc123");
+ * // => ["uploadista", "api", "upload", "abc123"]
+ * ```
+ */
+declare const parseUrlSegments: (pathname: string) => string[];
+/**
+ * Extracts the last segment from a URL pathname.
+ *
+ * @param pathname - The URL pathname to parse
+ * @returns The last non-empty segment, or undefined if none exists
+ *
+ * @example
+ * ```typescript
+ * const id = getLastSegment("/uploadista/api/upload/abc123");
+ * // => "abc123"
+ * ```
+ */
+declare const getLastSegment: (pathname: string) => string | undefined;
+/**
+ * Checks if a pathname includes a specific base path and API prefix.
+ * Used to determine if a request should be handled by the Uploadista adapter.
+ *
+ * @param pathname - The request pathname
+ * @param basePath - The base path configured for the adapter (e.g., "uploadista")
+ * @returns true if the path includes `{basePath}/api/`
+ *
+ * @example
+ * ```typescript
+ * const isUploadistaPath = hasBasePath("/uploadista/api/upload", "uploadista");
+ * // => true
+ * ```
+ */
+declare const hasBasePath: (pathname: string, basePath: string) => boolean;
+/**
+ * Removes the base path prefix and returns clean route segments.
+ * Transforms "/uploadista/api/upload/abc123" → ["upload", "abc123"]
+ *
+ * @param pathname - The full request pathname
+ * @param basePath - The base path to remove (e.g., "uploadista")
+ * @returns Array of route segments without base path prefix
+ *
+ * @example
+ * ```typescript
+ * const route = getRouteSegments("/uploadista/api/upload/abc123", "uploadista");
+ * // => ["upload", "abc123"]
+ * ```
+ */
+declare const getRouteSegments: (pathname: string, basePath: string) => string[];
+/**
+ * Standard error handler for flow and job operations.
+ * Maps application errors to appropriate HTTP status codes and error formats.
+ *
+ * Supports errors with `code`, `message`, `status`, and `details` properties.
+ * Maps error codes to HTTP status codes (e.g., NOT_FOUND → 404, VALIDATION_ERROR → 400).
+ *
+ * @param error - The error object to handle (can be any type)
+ * @returns Standardized error response with status, code, message, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { handleFlowError } from "@uploadista/server";
+ *
+ * const response = handleFlowError({
+ *   code: "FLOW_JOB_NOT_FOUND",
+ *   message: "Job not found",
+ * });
+ * // => { status: 404, code: "FLOW_JOB_NOT_FOUND", message: "Job not found" }
+ * ```
+ */
+declare const handleFlowError: (error: unknown) => {
+  status: number;
+  code: string;
+  message: string;
+  details?: unknown;
+};
+/**
+ * Extracts job ID from URL segments for job status endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/status`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns The job ID if found, or undefined
+ *
+ * @example
+ * ```typescript
+ * const jobId = extractJobIdFromStatus(["jobs", "job-123", "status"]);
+ * // => "job-123"
+ * ```
+ */
+declare const extractJobIdFromStatus: (urlSegments: string[]) => string | undefined;
+/**
+ * Extracts job ID and node ID from URL segments for resume flow endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/resume/:nodeId`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns Object with extracted jobId and nodeId (either can be undefined if not found)
+ *
+ * @example
+ * ```typescript
+ * const { jobId, nodeId } = extractJobAndNodeId([
+ *   "jobs",
+ *   "job-123",
+ *   "resume",
+ *   "node-456",
+ * ]);
+ * // => { jobId: "job-123", nodeId: "node-456" }
+ * ```
+ */
+declare const extractJobAndNodeId: (urlSegments: string[]) => {
+  jobId: string | undefined;
+  nodeId: string | undefined;
+};
+/**
+ * Extracts flow ID and storage ID from URL segments.
+ * Expected URL format: `/uploadista/api/flow/:flowId/:storageId`
+ *
+ * Mutates the input array (removes last 2 elements).
+ *
+ * @param urlSegments - Parsed URL segments (will be mutated)
+ * @returns Object with extracted flowId and storageId
+ *
+ * @example
+ * ```typescript
+ * const segments = ["flow", "flow-123", "storage-456"];
+ * const { flowId, storageId } = extractFlowAndStorageId(segments);
+ * // => { flowId: "flow-123", storageId: "storage-456" }
+ * // segments is now ["flow"]
+ * ```
+ */
+declare const extractFlowAndStorageId: (urlSegments: string[]) => {
+  flowId: string | undefined;
+  storageId: string | undefined;
+};
+//#endregion
+//#region src/layer-utils.d.ts
+/**
+ * Configuration for creating upload server layers.
+ * Specifies all dependencies needed by the upload server Effect Layer.
+ *
+ * @property kvStore - Key-value store for upload metadata
+ * @property eventEmitter - Event emitter for upload progress events
+ * @property dataStore - File data storage implementation
+ * @property bufferedDataStore - Optional buffered storage for performance optimization
+ * @property generateId - Optional custom ID generator (uses default if omitted)
+ *
+ * @example
+ * ```typescript
+ * import { createUploadServerLayer } from "@uploadista/server";
+ *
+ * const uploadLayerConfig: UploadServerLayerConfig = {
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   dataStore: s3DataStore,
+ * };
+ * ```
+ */
+interface UploadServerLayerConfig {
+  kvStore: Layer.Layer<BaseKvStoreService>;
+  eventEmitter: Layer.Layer<BaseEventEmitterService>;
+  dataStore: Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
+  bufferedDataStore?: Layer.Layer<UploadFileDataStore, never, UploadFileKVStore>;
+  generateId?: Layer.Layer<GenerateId>;
+}
+/**
+ * Configuration for creating flow server layers.
+ * Specifies all dependencies needed by the flow processing server.
+ *
+ * @property kvStore - Key-value store for flow job metadata
+ * @property eventEmitter - Event emitter for flow progress events
+ * @property flowProvider - Factory function for creating flows
+ * @property uploadServer - Upload server layer (used by flows for uploads)
+ *
+ * @example
+ * ```typescript
+ * import { createFlowServerLayer } from "@uploadista/server";
+ *
+ * const flowLayerConfig: FlowServerLayerConfig = {
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   flowProvider: createFlowsEffect,
+ *   uploadServer: uploadServerLayer,
+ * };
+ * ```
+ */
+interface FlowServerLayerConfig {
+  kvStore: Layer.Layer<BaseKvStoreService>;
+  eventEmitter: Layer.Layer<BaseEventEmitterService>;
+  flowProvider: Layer.Layer<FlowProvider>;
+  uploadServer: Layer.Layer<UploadServer>;
+}
+/**
+ * Creates the upload server layer with all dependencies composed.
+ * This layer handles file uploads with chunked transfer, resumption, and metadata tracking.
+ *
+ * The created layer includes:
+ * - Upload KV store (metadata tracking)
+ * - Data store (file storage)
+ * - Event emitter (progress notifications)
+ * - Optional buffered data store (performance optimization)
+ * - Optional custom ID generator
+ *
+ * @param config - Upload server layer configuration
+ * @returns Effect Layer providing UploadServer
+ *
+ * @example
+ * ```typescript
+ * import { createUploadServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const uploadServerLayer = createUploadServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   dataStore: s3DataStore,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, uploadServerLayer);
+ * ```
+ */
+declare const createUploadServerLayer: ({
+  kvStore,
+  eventEmitter,
+  dataStore,
+  bufferedDataStore,
+  generateId
+}: UploadServerLayerConfig) => Layer.Layer<unknown, unknown, any>;
+/**
+ * Creates the flow server layer with all dependencies composed.
+ * This layer handles file processing workflows with multi-stage pipelines.
+ *
+ * The created layer includes:
+ * - Flow job KV store (job metadata and state)
+ * - Event emitter (progress notifications)
+ * - Flow provider (flow definitions)
+ * - Upload server (for uploads within flows)
+ *
+ * @param config - Flow server layer configuration
+ * @returns Effect Layer providing FlowServer
+ *
+ * @example
+ * ```typescript
+ * import { createFlowServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const flowServerLayer = createFlowServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   flowProvider: createFlowsEffect,
+ *   uploadServer: uploadServerLayer,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, flowServerLayer);
+ * ```
+ */
+declare const createFlowServerLayer: ({
+  kvStore,
+  eventEmitter,
+  flowProvider,
+  uploadServer
+}: FlowServerLayerConfig) => Layer.Layer<unknown, unknown, any>;
+//#endregion
+//#region src/plugins-typing.d.ts
+type LayerSuccessUnion<Layers extends readonly Layer.Layer<any, never, never>[]> = Layers[number] extends Layer.Layer<infer Success, never, never> ? Success : never;
+type FlowSuccess<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = ReturnType<TFlows> extends Effect.Effect<infer Success, unknown, unknown> ? Success : never;
+type FlowRequirementsOf<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = FlowSuccess<TFlows> extends Flow$1<z$1.ZodSchema<unknown>, z$1.ZodSchema<unknown>, infer R> ? Exclude<R, UploadServer$1> : never;
+type RequiredPluginsOf<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = Exclude<FlowRequirementsOf<TFlows>, UploadServer$1>;
+type PluginAssertion<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>, TPlugins extends readonly Layer.Layer<any, never, never>[]> = Exclude<RequiredPluginsOf<TFlows>, LayerSuccessUnion<TPlugins>> extends never ? unknown : {
+  __missingPlugins: Exclude<RequiredPluginsOf<TFlows>, LayerSuccessUnion<TPlugins>>;
+};
+//#endregion
+//#region src/service.d.ts
+declare const AuthContextService_base: Context.TagClass<AuthContextService, "AuthContextService", {
+  /**
+   * Get the current client ID from auth context.
+   * Returns null if no authentication context is available.
+   */
+  readonly getClientId: () => Effect.Effect<string | null>;
+  /**
+   * Get the current auth metadata.
+   * Returns empty object if no authentication context or no metadata.
+   */
+  readonly getMetadata: () => Effect.Effect<Record<string, unknown>>;
+  /**
+   * Check if the current client has a specific permission.
+   * Returns false if no authentication context or permission not found.
+   */
+  readonly hasPermission: (permission: string) => Effect.Effect<boolean>;
+  /**
+   * Get the full authentication context if available.
+   * Returns null if no authentication context is available.
+   */
+  readonly getAuthContext: () => Effect.Effect<AuthContext | null>;
+}>;
+/**
+ * Authentication Context Service
+ *
+ * Provides access to the current authentication context throughout
+ * the upload and flow processing pipeline. The service is provided
+ * via Effect Layer and can be accessed using Effect.service().
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from "effect";
+ * import { AuthContextService } from "@uploadista/server";
+ *
+ * const uploadHandler = Effect.gen(function* () {
+ *   const authService = yield* AuthContextService;
+ *   const clientId = yield* authService.getClientId();
+ *   if (clientId) {
+ *     console.log(`Processing upload for client: ${clientId}`);
+ *   }
+ * });
+ * ```
+ */
+declare class AuthContextService extends AuthContextService_base {}
+/**
+ * Creates an AuthContextService Layer from an AuthContext.
+ * This is typically called by adapters after successful authentication.
+ *
+ * @param authContext - The authentication context from middleware
+ * @returns Effect Layer providing AuthContextService
+ */
+declare const AuthContextServiceLive: (authContext: AuthContext | null) => Layer.Layer<AuthContextService>;
+/**
+ * No-auth implementation of AuthContextService.
+ * Returns null/empty values for all operations.
+ * Used when no authentication middleware is configured (backward compatibility).
+ */
+declare const NoAuthContextServiceLive: Layer.Layer<AuthContextService>;
+//#endregion
+export { AdapterError, AuthCacheConfig, AuthCacheService, AuthCacheServiceLive, AuthContext, AuthContextService, AuthContextServiceLive, AuthCredentialsResponse, AuthFailedEvent, AuthResult, BadRequestError, BadRequestRequest, BadRequestResponse, CancelFlowRequest, CancelFlowResponse, ConnectionEvent, CreateUploadRequest, CreateUploadResponse, ErrorEvent, FlowEventMessage, FlowRequirementsOf, FlowServerLayerConfig, FlowSuccess, FlowsFunction, GetCapabilitiesRequest, GetCapabilitiesResponse, GetFlowRequest, GetFlowResponse, GetJobStatusRequest, GetJobStatusResponse, GetUploadRequest, GetUploadResponse, InvalidPathEvent, LayerSuccessUnion, MethodNotAllowedRequest, MethodNotAllowedResponse, NoAuthCacheServiceLive, NoAuthContextServiceLive, NotFoundError, NotFoundRequest, NotFoundResponse, PauseFlowRequest, PauseFlowResponse, PingEvent, PluginAssertion, RequiredPluginsOf, ResumeFlowRequest, ResumeFlowResponse, RunFlowRequest, RunFlowResponse, ServerAdapter, StandardRequest, StandardResponse, SubscribeFlowEvent, SubscribeUploadEvent, UnsubscribeFlowEvent, UnsubscribeUploadEvent, UnsupportedContentTypeRequest, UnsupportedContentTypeResponse, UploadChunkRequest, UploadChunkResponse, UploadEventMessage, UploadServerLayerConfig, UploadistaRequest, UploadistaResponse, UploadistaRoute, UploadistaRouteType, UploadistaServer, UploadistaServerConfig, UploadistaStandardResponse, ValidationError, type WebSocketConnection, type WebSocketConnectionRequest, WebSocketEvent, WebSocketEventType, WebSocketHandler, WebSocketIncomingEvent, WebSocketOutgoingEvent, createErrorResponseBody, createFlowServerLayer, createGenericErrorResponseBody, createUploadServerLayer, createUploadistaErrorResponseBody, createUploadistaServer, extractFlowAndStorageId, extractJobAndNodeId, extractJobIdFromStatus, getAuthCredentials, getLastSegment, getRouteSegments, handleFlowError, handleWebSocketClose, handleWebSocketError, handleWebSocketMessage, handleWebSocketOpen, hasBasePath, parseUrlSegments };
+//# sourceMappingURL=index.d.mts.map