@uploadista/core 0.2.0 → 1.0.0-beta.3

package/dist/resolve-upload-metadata-CYl2PHIs.d.mts

@@ -0,0 +1,4542 @@
+import { n as UploadistaError } from "./uploadista-error-LtiZn-R_.mjs";
+import { $ as BaseKvStoreService, Bt as TypedOutput, Dn as NodeType, Dt as FlowCircuitBreakerConfig, G as StreamingConfig, In as DeadLetterCleanupOptions, Ln as DeadLetterCleanupResult, Lt as NodeExecutionResult, Mt as FlowNode, Nt as FlowNodeData, O as WebSocketConnection, Pt as NamingContext, Q as BaseKvStore, Qt as RetryPolicy, S as FlowEventEmitter, Tt as FileNamingConfig, Un as DeadLetterQueueStats, Vn as DeadLetterListOptions, Xn as CircuitBreakerStoreService, Yn as CircuitBreakerStore, et as DeadLetterQueueKVStore, ft as FlowQueueConfig, gt as FlowJob, ht as FlowQueueStats, in as FlowEvent, jn as UploadFile, jt as FlowEdge$1, kt as FlowConfig, mt as FlowQueueItemStatus, nt as FlowQueueKVStore, pt as FlowQueueItem, q as UploadFileDataStores, qn as CircuitBreakerStateValue, rt as KvStore, tt as FlowJobKVStore, zn as DeadLetterItem, zt as TypeCompatibilityChecker } from "./middleware-CYizzAhP.mjs";
+import { i as UploadEngine } from "./upload-strategy-negotiator-CEnlfVgJ.mjs";
+import { Context, Effect, Layer, Option, Stream } from "effect";
+import * as zod from "zod";
+import { z } from "zod";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/flow/circuit-breaker.d.ts
+/**
+ * Circuit breaker state machine states.
+ *
+ * - `closed`: Normal operation, tracking failures in sliding window
+ * - `open`: Rejecting all requests immediately, waiting for reset timeout
+ * - `half-open`: Allowing limited test requests to probe service health
+ */
+type CircuitBreakerState = "closed" | "open" | "half-open";
+/**
+ * Configuration for a circuit breaker.
+ *
+ * @property enabled - Whether circuit breaker is active (default: false for backward compatibility)
+ * @property failureThreshold - Number of failures within window to trip circuit (default: 5)
+ * @property resetTimeout - Milliseconds to wait in open state before half-open (default: 30000)
+ * @property halfOpenRequests - Number of successful requests in half-open to close (default: 3)
+ * @property windowDuration - Sliding window duration in milliseconds (default: 60000)
+ * @property fallback - Behavior when circuit is open
+ */
+interface CircuitBreakerConfig {
+  /** Whether circuit breaker is active (default: false) */
+  enabled?: boolean;
+  /** Number of failures within window to trip circuit (default: 5) */
+  failureThreshold?: number;
+  /** Milliseconds to wait in open state before half-open (default: 30000) */
+  resetTimeout?: number;
+  /** Number of successful requests in half-open to close (default: 3) */
+  halfOpenRequests?: number;
+  /** Sliding window duration in milliseconds (default: 60000) */
+  windowDuration?: number;
+  /** Behavior when circuit is open */
+  fallback?: CircuitBreakerFallback;
+}
+/**
+ * Fallback behavior when circuit is open.
+ *
+ * - `fail`: Fail immediately with CIRCUIT_BREAKER_OPEN error (default)
+ * - `skip`: Skip node, pass input through as output
+ * - `default`: Return a configured default value
+ */
+type CircuitBreakerFallback = {
+  type: "fail";
+} | {
+  type: "skip";
+  passThrough: true;
+} | {
+  type: "default";
+  value: unknown;
+};
+/**
+ * Event emitted when circuit state changes.
+ */
+interface CircuitBreakerEvent {
+  nodeType: string;
+  previousState: CircuitBreakerState;
+  newState: CircuitBreakerState;
+  timestamp: number;
+  failureCount?: number;
+}
+/**
+ * Callback type for circuit state change events.
+ */
+type CircuitBreakerEventHandler = (event: CircuitBreakerEvent) => Effect.Effect<void, never, never>;
+/**
+ * Default circuit breaker configuration values.
+ */
+declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: Required<Omit<CircuitBreakerConfig, "fallback">> & {
+  fallback: CircuitBreakerFallback;
+};
+//#endregion
+//#region src/flow/circuit-breaker-store.d.ts
+/**
+ * Creates a CircuitBreakerStore backed by any BaseKvStore.
+ *
+ * This adapter wraps a generic KV store to provide circuit breaker state
+ * storage. It handles:
+ * - JSON serialization of state data
+ * - Sliding window expiry (checked on read/increment)
+ * - Read-modify-write for increment operations
+ *
+ * Note: This implementation uses read-modify-write for increments, which
+ * may have race conditions under high concurrency. This is acceptable for
+ * circuit breakers as they tolerate eventual consistency.
+ *
+ * @param baseStore - The underlying KV store
+ * @returns A CircuitBreakerStore implementation
+ *
+ * @example
+ * ```typescript
+ * const baseStore = makeRedisBaseKvStore({ redis: redisClient });
+ * const cbStore = makeKvCircuitBreakerStore(baseStore);
+ *
+ * // Use the store
+ * yield* cbStore.incrementFailures("describe-image", 60000);
+ * ```
+ */
+declare function makeKvCircuitBreakerStore(baseStore: BaseKvStore): CircuitBreakerStore;
+/**
+ * Creates an in-memory CircuitBreakerStore.
+ *
+ * This implementation keeps all state in memory and is suitable for:
+ * - Single-instance deployments
+ * - Development and testing
+ * - Serverless functions (where state is ephemeral anyway)
+ *
+ * @returns A CircuitBreakerStore backed by in-memory Map
+ *
+ * @example
+ * ```typescript
+ * const cbStore = makeMemoryCircuitBreakerStore();
+ *
+ * // Use for testing
+ * yield* cbStore.incrementFailures("test-node", 60000);
+ * const state = yield* cbStore.getState("test-node");
+ * ```
+ */
+declare function makeMemoryCircuitBreakerStore(): CircuitBreakerStore;
+/**
+ * Effect Layer that provides a CircuitBreakerStore backed by the BaseKvStore.
+ *
+ * Use this layer when you want circuit breaker state to be distributed
+ * across multiple instances (e.g., in a cluster).
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const cbStore = yield* CircuitBreakerStoreService;
+ *   // ...
+ * }).pipe(
+ *   Effect.provide(kvCircuitBreakerStoreLayer),
+ *   Effect.provide(redisKvStore({ redis: redisClient }))
+ * );
+ * ```
+ */
+declare const kvCircuitBreakerStoreLayer: Layer.Layer<CircuitBreakerStoreService, never, BaseKvStoreService>;
+/**
+ * Effect Layer that provides an in-memory CircuitBreakerStore.
+ *
+ * Use this layer for single-instance deployments, development, or testing.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const cbStore = yield* CircuitBreakerStoreService;
+ *   // ...
+ * }).pipe(
+ *   Effect.provide(memoryCircuitBreakerStoreLayer)
+ * );
+ * ```
+ */
+declare const memoryCircuitBreakerStoreLayer: Layer.Layer<CircuitBreakerStoreService, never, never>;
+//#endregion
+//#region src/flow/distributed-circuit-breaker.d.ts
+/**
+ * Result of checking if a request is allowed.
+ */
+interface AllowRequestResult {
+  allowed: boolean;
+  state: CircuitBreakerStateValue;
+  failureCount: number;
+}
+/**
+ * Distributed circuit breaker that uses a store for state persistence.
+ *
+ * Unlike the in-memory CircuitBreaker, this implementation stores all state
+ * in a CircuitBreakerStore, allowing multiple instances to share circuit state.
+ *
+ * All operations are Effect-based since they may involve I/O.
+ *
+ * @example
+ * ```typescript
+ * const breaker = new DistributedCircuitBreaker(
+ *   "describe-image",
+ *   { enabled: true, failureThreshold: 5 },
+ *   store
+ * );
+ *
+ * // Check if request is allowed
+ * const { allowed, state } = yield* breaker.allowRequest();
+ * if (!allowed) {
+ *   // Handle circuit open
+ * }
+ *
+ * // Record result
+ * try {
+ *   const result = yield* executeNode();
+ *   yield* breaker.recordSuccess();
+ *   return result;
+ * } catch (error) {
+ *   yield* breaker.recordFailure(error.message);
+ *   throw error;
+ * }
+ * ```
+ */
+declare class DistributedCircuitBreaker {
+  private eventHandler?;
+  readonly nodeType: string;
+  readonly config: Required<Omit<CircuitBreakerConfig, "fallback">> & {
+    fallback: CircuitBreakerFallback;
+  };
+  readonly store: CircuitBreakerStore;
+  constructor(nodeType: string, config: CircuitBreakerConfig, store: CircuitBreakerStore);
+  /**
+   * Sets the event handler for state change notifications.
+   */
+  setEventHandler(handler: CircuitBreakerEventHandler): void;
+  /**
+   * Checks if a request is allowed through the circuit.
+   *
+   * This method reads state from the store, checks for time-based transitions,
+   * and returns whether the request should proceed.
+   */
+  allowRequest(): Effect.Effect<AllowRequestResult, UploadistaError>;
+  /**
+   * Gets the current circuit state from the store.
+   */
+  getState(): Effect.Effect<CircuitBreakerStateValue, UploadistaError>;
+  /**
+   * Gets the current failure count from the store.
+   */
+  getFailureCount(): Effect.Effect<number, UploadistaError>;
+  /**
+   * Records a successful execution.
+   *
+   * In half-open state, tracks successes toward closing the circuit.
+   * In closed state, resets the failure count.
+   */
+  recordSuccess(): Effect.Effect<void, UploadistaError>;
+  /**
+   * Records a failed execution.
+   *
+   * In closed state, increments failure count and may trip the circuit.
+   * In half-open state, immediately reopens the circuit.
+   */
+  recordFailure(_errorMessage: string): Effect.Effect<void, UploadistaError>;
+  /**
+   * Gets the fallback configuration.
+   */
+  getFallback(): CircuitBreakerFallback;
+  /**
+   * Resets the circuit breaker to closed state.
+   */
+  reset(): Effect.Effect<void, UploadistaError>;
+  /**
+   * Transitions to a new state.
+   */
+  private transitionTo;
+  /**
+   * Emits a state change event if handler is set.
+   */
+  private emitEvent;
+}
+/**
+ * Registry for managing distributed circuit breakers.
+ *
+ * Unlike the in-memory CircuitBreakerRegistry, this registry creates
+ * DistributedCircuitBreaker instances that share state via a store.
+ *
+ * @example
+ * ```typescript
+ * const store = makeKvCircuitBreakerStore(baseKvStore);
+ * const registry = new DistributedCircuitBreakerRegistry(store);
+ *
+ * const breaker = registry.getOrCreate("describe-image", {
+ *   enabled: true,
+ *   failureThreshold: 5
+ * });
+ * ```
+ */
+declare class DistributedCircuitBreakerRegistry {
+  readonly store: CircuitBreakerStore;
+  private breakers;
+  private eventHandler?;
+  constructor(store: CircuitBreakerStore);
+  /**
+   * Sets a global event handler for all circuit breakers.
+   */
+  setEventHandler(handler: CircuitBreakerEventHandler): void;
+  /**
+   * Gets an existing circuit breaker or creates a new one.
+   */
+  getOrCreate(nodeType: string, config: CircuitBreakerConfig): DistributedCircuitBreaker;
+  /**
+   * Gets an existing circuit breaker if it exists.
+   */
+  get(nodeType: string): DistributedCircuitBreaker | undefined;
+  /**
+   * Gets statistics for all circuit breakers from the store.
+   */
+  getAllStats(): Effect.Effect<Map<string, {
+    state: CircuitBreakerStateValue;
+    failureCount: number;
+  }>, UploadistaError>;
+  /**
+   * Resets all circuit breakers.
+   */
+  resetAll(): Effect.Effect<void, UploadistaError>;
+  /**
+   * Clears all circuit breakers from the local cache.
+   * Note: This does not clear state from the store.
+   */
+  clear(): void;
+}
+//#endregion
+//#region src/flow/edge.d.ts
+/**
+ * Represents a connection between two nodes in a flow, defining the data flow direction.
+ *
+ * Edges connect the output of a source node to the input of a target node,
+ * enabling data to flow through the processing pipeline in a directed acyclic graph (DAG).
+ */
+type FlowEdge = FlowEdge$1;
+/**
+ * Creates a flow edge connecting two nodes in a processing pipeline.
+ *
+ * Edges define how data flows between nodes. The data output from the source node
+ * becomes the input for the target node. For nodes with multiple inputs/outputs,
+ * ports can be specified to route data to specific connections.
+ *
+ * @param config - Edge configuration
+ * @param config.source - ID of the source node (data originates here)
+ * @param config.target - ID of the target node (data flows to here)
+ * @param config.sourcePort - Optional port name on the source node for multi-output nodes
+ * @param config.targetPort - Optional port name on the target node for multi-input nodes
+ *
+ * @returns A FlowEdge object representing the connection
+ *
+ * @example
+ * ```typescript
+ * // Simple edge connecting two nodes
+ * const edge = createFlowEdge({
+ *   source: "input-1",
+ *   target: "process-1"
+ * });
+ *
+ * // Edge with ports for multi-input/output nodes
+ * const portEdge = createFlowEdge({
+ *   source: "multiplex-1",
+ *   target: "merge-1",
+ *   sourcePort: "out-a",
+ *   targetPort: "in-1"
+ * });
+ * ```
+ */
+declare function createFlowEdge({
+  source,
+  target,
+  sourcePort,
+  targetPort
+}: {
+  source: string;
+  target: string;
+  sourcePort?: string;
+  targetPort?: string;
+}): FlowEdge;
+//#endregion
+//#region src/flow/flow.d.ts
+/**
+ * Serialized flow data for storage and transport.
+ * Contains the minimal information needed to reconstruct a flow.
+ *
+ * @property id - Unique flow identifier
+ * @property name - Human-readable flow name
+ * @property nodes - Array of node data (without execution logic)
+ * @property edges - Connections between nodes defining data flow
+ */
+type FlowData = {
+  id: string;
+  name: string;
+  nodes: FlowNodeData[];
+  edges: FlowEdge[];
+};
+/**
+ * Extracts serializable flow data from a Flow instance.
+ * Useful for storing flow definitions or sending them over the network.
+ *
+ * @template TRequirements - Effect requirements for the flow
+ * @param flow - Flow instance to extract data from
+ * @returns Serializable flow data without execution logic
+ *
+ * @example
+ * ```typescript
+ * const flowData = getFlowData(myFlow);
+ * // Store in database or send to client
+ * await db.flows.save(flowData);
+ * ```
+ */
+declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
+/**
+ * Result of a flow execution - either completed or paused.
+ *
+ * @template TOutput - Type of the flow's output data
+ *
+ * @remarks
+ * Flows can pause when a node needs additional data (e.g., waiting for user input
+ * or external service). The execution state allows resuming from where it paused.
+ *
+ * @example
+ * ```typescript
+ * const result = await Effect.runPromise(flow.run({ inputs, storageId, jobId }));
+ *
+ * if (result.type === "completed") {
+ *   console.log("Flow completed:", result.result);
+ * } else {
+ *   console.log("Flow paused at node:", result.nodeId);
+ *   // Can resume later with: flow.resume({ jobId, executionState: result.executionState, ... })
+ * }
+ * ```
+ */
+type FlowExecutionResult<TOutput> = {
+  type: "completed";
+  result: TOutput;
+  outputs?: TypedOutput[];
+} | {
+  type: "paused";
+  nodeId: string;
+  executionState: {
+    executionOrder: string[];
+    currentIndex: number;
+    inputs: Record<string, unknown>;
+  };
+};
+/**
+ * A Flow represents a directed acyclic graph (DAG) of processing nodes.
+ *
+ * Flows execute nodes in topological order, passing data between nodes through edges.
+ * They support conditional execution, retry logic, pausable nodes, and event emission.
+ *
+ * @template TFlowInputSchema - Zod schema defining the shape of input data
+ * @template TFlowOutputSchema - Zod schema defining the shape of output data
+ * @template TRequirements - Effect requirements (services/contexts) needed by nodes
+ *
+ * @property id - Unique flow identifier
+ * @property name - Human-readable flow name
+ * @property nodes - Array of nodes in the flow
+ * @property edges - Connections between nodes
+ * @property inputSchema - Zod schema for validating flow inputs
+ * @property outputSchema - Zod schema for validating flow outputs
+ * @property onEvent - Optional callback for flow execution events
+ * @property run - Executes the flow from the beginning
+ * @property resume - Resumes a paused flow execution
+ * @property validateTypes - Validates node type compatibility
+ * @property validateInputs - Validates input data against schema
+ * @property validateOutputs - Validates output data against schema
+ *
+ * @remarks
+ * Flows are created using {@link createFlowWithSchema}. The Effect-based design
+ * allows for composable error handling, resource management, and dependency injection.
+ *
+ * @example
+ * ```typescript
+ * const flow = yield* createFlowWithSchema({
+ *   flowId: "image-pipeline",
+ *   name: "Image Processing Pipeline",
+ *   nodes: [inputNode, resizeNode, optimizeNode, storageNode],
+ *   edges: [
+ *     { source: "input", target: "resize" },
+ *     { source: "resize", target: "optimize" },
+ *     { source: "optimize", target: "storage" }
+ *   ],
+ *   inputSchema: z.object({ file: z.instanceof(File) }),
+ *   outputSchema: uploadFileSchema
+ * });
+ *
+ * const result = yield* flow.run({
+ *   inputs: { input: { file: myFile } },
+ *   storageId: "storage-1",
+ *   jobId: "job-123"
+ * });
+ * ```
+ */
+type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
+  id: string;
+  name: string;
+  nodes: FlowNode<any, any, UploadistaError>[];
+  edges: FlowEdge[];
+  inputSchema: TFlowInputSchema;
+  outputSchema: TFlowOutputSchema;
+  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["onEvent"];
+  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["checkJobStatus"];
+  hooks?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["hooks"];
+  run: (args: {
+    inputs?: Record<string, z.infer<TFlowInputSchema>>;
+    storageId: string;
+    jobId: string;
+    clientId: string | null;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements | UploadFileDataStores>;
+  resume: (args: {
+    jobId: string;
+    storageId: string;
+    nodeResults: Record<string, unknown>;
+    executionState: {
+      executionOrder: string[];
+      currentIndex: number;
+      inputs: Record<string, z.infer<TFlowInputSchema>>;
+    };
+    clientId: string | null;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError, TRequirements | UploadFileDataStores>;
+  validateTypes: () => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateInputs: (inputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
+  validateOutputs: (outputs: unknown) => {
+    isValid: boolean;
+    errors: string[];
+  };
+};
+/**
+ * Creates a new Flow with Zod schema-based type validation.
+ *
+ * This is the primary way to create flows in Uploadista. It constructs a Flow
+ * instance that validates inputs/outputs, executes nodes in topological order,
+ * handles errors with retries, and emits events during execution.
+ *
+ * @template TFlowInputSchema - Zod schema for flow input validation
+ * @template TFlowOutputSchema - Zod schema for flow output validation
+ * @template TRequirements - Effect requirements/services needed by the flow
+ * @template TNodeError - Union of possible errors from nodes
+ * @template TNodeRequirements - Union of requirements from nodes
+ *
+ * @param config - Flow configuration object
+ * @param config.flowId - Unique identifier for the flow
+ * @param config.name - Human-readable flow name
+ * @param config.nodes - Array of nodes (can be plain nodes or Effects resolving to nodes)
+ * @param config.edges - Array of edges connecting nodes
+ * @param config.inputSchema - Zod schema for validating inputs
+ * @param config.outputSchema - Zod schema for validating outputs
+ * @param config.typeChecker - Optional custom type compatibility checker
+ * @param config.onEvent - Optional event callback for monitoring execution
+ *
+ * @returns Effect that resolves to a Flow instance
+ *
+ * @throws {UploadistaError} FLOW_CYCLE_ERROR if the graph contains cycles
+ * @throws {UploadistaError} FLOW_NODE_NOT_FOUND if a node is referenced but missing
+ * @throws {UploadistaError} FLOW_NODE_ERROR if node execution fails
+ * @throws {UploadistaError} FLOW_OUTPUT_VALIDATION_ERROR if outputs don't match schema
+ *
+ * @remarks
+ * - Nodes can be provided as plain objects or as Effects that resolve to nodes
+ * - The flow performs topological sorting to determine execution order
+ * - Conditional nodes are evaluated before execution
+ * - Nodes can specify retry configuration with exponential backoff
+ * - Pausable nodes can halt execution and resume later
+ *
+ * @example
+ * ```typescript
+ * const flow = yield* createFlowWithSchema({
+ *   flowId: "image-upload",
+ *   name: "Image Upload with Processing",
+ *   nodes: [
+ *     inputNode,
+ *     yield* createResizeNode({ width: 1920, height: 1080 }),
+ *     optimizeNode,
+ *     storageNode
+ *   ],
+ *   edges: [
+ *     { source: "input", target: "resize" },
+ *     { source: "resize", target: "optimize" },
+ *     { source: "optimize", target: "storage" }
+ *   ],
+ *   inputSchema: z.object({
+ *     file: z.instanceof(File),
+ *     metadata: z.record(z.string(), z.any()).optional()
+ *   }),
+ *   outputSchema: uploadFileSchema,
+ *   onEvent: (event) => Effect.gen(function* () {
+ *     console.log("Flow event:", event);
+ *     return { eventId: event.jobId };
+ *   })
+ * });
+ * ```
+ *
+ * @see {@link Flow} for the returned flow type
+ * @see {@link FlowConfig} for configuration options
+ */
+declare function createFlowWithSchema<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements = never, TNodeError = never, TNodeRequirements = never>(config: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TNodeError, TNodeRequirements>): Effect.Effect<Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements>, TNodeError, TNodeRequirements>;
+//#endregion
+//#region src/flow/input-type-registry.d.ts
+/**
+ * Defines a registered input type with its schema and metadata.
+ *
+ * Input type definitions describe how external clients interact with input nodes.
+ * Unlike output types, input types define the external interface (e.g., init/finalize
+ * operations for streaming uploads).
+ *
+ * @template TSchema - The Zod schema type for this input's data
+ *
+ * @property id - Unique identifier (e.g., "streaming-input-v1")
+ * @property schema - Zod schema for validating input data from clients
+ * @property version - Semantic version (e.g., "1.0.0") for tracking type evolution
+ * @property description - Human-readable explanation of what this input type does
+ */
+interface InputTypeDefinition<TSchema = unknown> {
+  id: string;
+  schema: z.ZodSchema<TSchema>;
+  version: string;
+  description: string;
+}
+/**
+ * Result type for input validation operations.
+ *
+ * @template T - The expected type on successful validation
+ */
+type InputValidationResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: UploadistaError;
+};
+/**
+ * Registry for input node type definitions.
+ *
+ * The InputTypeRegistry maintains a global registry of input types with their schemas
+ * and metadata. Input types describe how data enters the flow from external sources.
+ *
+ * @remarks
+ * - Use the exported `inputTypeRegistry` singleton instance
+ * - Types cannot be unregistered or modified after registration
+ * - Duplicate type IDs are rejected
+ *
+ * @example
+ * ```typescript
+ * // Register a new input type
+ * inputTypeRegistry.register({
+ *   id: "form-input-v1",
+ *   schema: formInputSchema,
+ *   version: "1.0.0",
+ *   description: "Form-based file input",
+ * });
+ *
+ * // Check if type exists
+ * if (inputTypeRegistry.has("streaming-input-v1")) {
+ *   const def = inputTypeRegistry.get("streaming-input-v1");
+ * }
+ * ```
+ */
+declare class InputTypeRegistry {
+  private readonly types;
+  constructor();
+  /**
+   * Register a new input type in the registry.
+   *
+   * @template T - The TypeScript type inferred from the Zod schema
+   * @param definition - The complete type definition including schema and metadata
+   * @throws {UploadistaError} If a type with the same ID is already registered
+   */
+  register<T>(definition: InputTypeDefinition<T>): void;
+  /**
+   * Retrieve a registered type definition by its ID.
+   *
+   * @param id - The unique type identifier (e.g., "streaming-input-v1")
+   * @returns The type definition if found, undefined otherwise
+   */
+  get(id: string): InputTypeDefinition<unknown> | undefined;
+  /**
+   * List all registered input types.
+   *
+   * @returns Array of all input type definitions
+   */
+  list(): InputTypeDefinition<unknown>[];
+  /**
+   * Validate data against a registered type's schema.
+   *
+   * @template T - The expected TypeScript type after validation
+   * @param typeId - The ID of the registered type to validate against
+   * @param data - The data to validate
+   * @returns A result object with either the validated data or an error
+   */
+  validate<T>(typeId: string, data: unknown): InputValidationResult<T>;
+  /**
+   * Check if a type is registered.
+   *
+   * @param id - The unique type identifier to check
+   * @returns True if the type is registered, false otherwise
+   */
+  has(id: string): boolean;
+  /**
+   * Get the total number of registered types.
+   *
+   * @returns The count of registered types
+   */
+  size(): number;
+}
+/**
+ * Global singleton instance of the input type registry.
+ *
+ * Use this instance to register and access input node type definitions.
+ * Input types describe how data enters the flow from external sources.
+ *
+ * @example
+ * ```typescript
+ * import { inputTypeRegistry } from "@uploadista/core/flow";
+ *
+ * // Register a type
+ * inputTypeRegistry.register({
+ *   id: "my-input-v1",
+ *   schema: myInputSchema,
+ *   version: "1.0.0",
+ *   description: "My custom input type",
+ * });
+ *
+ * // Validate data
+ * const result = inputTypeRegistry.validate("my-input-v1", data);
+ * ```
+ */
+declare const inputTypeRegistry: InputTypeRegistry;
+/**
+ * Validates flow input data against a registered input type.
+ *
+ * @param typeId - The registered type ID (e.g., "streaming-input-v1")
+ * @param data - The input data to validate
+ * @returns A validation result with either the typed data or an error
+ */
+declare function validateFlowInput<T = unknown>(typeId: string, data: unknown): InputValidationResult<T>;
+//#endregion
+//#region src/flow/output-type-registry.d.ts
+/**
+ * Defines a registered output type with its schema and metadata.
+ *
+ * Output type definitions describe the data shapes produced by nodes. This enables
+ * type-safe result consumption where clients can narrow types based on the
+ * `nodeType` field in results.
+ *
+ * @template TSchema - The Zod schema type for this output's data
+ *
+ * @property id - Unique identifier (e.g., "storage-output-v1", "ocr-output-v1")
+ * @property schema - Zod schema for validating output data
+ * @property version - Semantic version (e.g., "1.0.0") for tracking type evolution
+ * @property description - Human-readable explanation of what this output type contains
+ */
+interface OutputTypeDefinition<TSchema = unknown> {
+  id: string;
+  schema: z.ZodSchema<TSchema>;
+  version: string;
+  description: string;
+}
+/**
+ * Result type for output validation operations.
+ *
+ * @template T - The expected type on successful validation
+ */
+type OutputValidationResult<T> = {
+  success: true;
+  data: T;
+} | {
+  success: false;
+  error: UploadistaError;
+};
+/**
+ * Registry for output node type definitions.
+ *
+ * The OutputTypeRegistry maintains a global registry of output types with their schemas
+ * and metadata. Output types describe the data shapes that flow through the system
+ * and appear in results.
+ *
+ * @remarks
+ * - Use the exported `outputTypeRegistry` singleton instance
+ * - Types cannot be unregistered or modified after registration
+ * - Duplicate type IDs are rejected
+ *
+ * @example
+ * ```typescript
+ * // Register a new output type
+ * outputTypeRegistry.register({
+ *   id: "metadata-output-v1",
+ *   schema: metadataSchema,
+ *   version: "1.0.0",
+ *   description: "File metadata extraction output",
+ * });
+ *
+ * // Validate result data
+ * const result = outputTypeRegistry.validate("storage-output-v1", data);
+ * if (result.success) {
+ *   console.log(result.data.url);
+ * }
+ * ```
+ */
+declare class OutputTypeRegistry {
+  private readonly types;
+  constructor();
+  /**
+   * Register a new output type in the registry.
+   *
+   * @template T - The TypeScript type inferred from the Zod schema
+   * @param definition - The complete type definition including schema and metadata
+   * @throws {UploadistaError} If a type with the same ID is already registered
+   */
+  register<T>(definition: OutputTypeDefinition<T>): void;
+  /**
+   * Retrieve a registered type definition by its ID.
+   *
+   * @param id - The unique type identifier (e.g., "storage-output-v1")
+   * @returns The type definition if found, undefined otherwise
+   */
+  get(id: string): OutputTypeDefinition<unknown> | undefined;
+  /**
+   * List all registered output types.
+   *
+   * @returns Array of all output type definitions
+   */
+  list(): OutputTypeDefinition<unknown>[];
+  /**
+   * Validate data against a registered type's schema.
+   *
+   * @template T - The expected TypeScript type after validation
+   * @param typeId - The ID of the registered type to validate against
+   * @param data - The data to validate
+   * @returns A result object with either the validated data or an error
+   */
+  validate<T>(typeId: string, data: unknown): OutputValidationResult<T>;
+  /**
+   * Check if a type is registered.
+   *
+   * @param id - The unique type identifier to check
+   * @returns True if the type is registered, false otherwise
+   */
+  has(id: string): boolean;
+  /**
+   * Get the total number of registered types.
+   *
+   * @returns The count of registered types
+   */
+  size(): number;
+}
+/**
+ * Global singleton instance of the output type registry.
+ *
+ * Use this instance to register and access output node type definitions.
+ * Output types describe the data shapes produced by nodes and used in results.
+ *
+ * @example
+ * ```typescript
+ * import { outputTypeRegistry } from "@uploadista/core/flow";
+ *
+ * // Register a type
+ * outputTypeRegistry.register({
+ *   id: "my-output-v1",
+ *   schema: myOutputSchema,
+ *   version: "1.0.0",
+ *   description: "My custom output type",
+ * });
+ *
+ * // Validate result data
+ * const result = outputTypeRegistry.validate("my-output-v1", data);
+ * ```
+ */
+declare const outputTypeRegistry: OutputTypeRegistry;
+/**
+ * Validates flow output data against a registered output type.
+ *
+ * @param typeId - The registered type ID (e.g., "storage-output-v1")
+ * @param data - The output data to validate
+ * @returns A validation result with either the typed data or an error
+ */
+declare function validateFlowOutput<T = unknown>(typeId: string, data: unknown): OutputValidationResult<T>;
+//#endregion
+//#region src/flow/node-types/index.d.ts
+/**
+ * Type ID constants for built-in node types.
+ *
+ * Use these constants when creating nodes with type information to ensure
+ * consistency and avoid typos.
+ *
+ * @example
+ * ```typescript
+ * import { STREAMING_INPUT_TYPE_ID, STORAGE_OUTPUT_TYPE_ID } from "@uploadista/core/flow";
+ *
+ * const inputNode = createFlowNode({
+ *   // ... other config
+ *   inputTypeId: STREAMING_INPUT_TYPE_ID,
+ *   outputTypeId: STORAGE_OUTPUT_TYPE_ID,
+ * });
+ * ```
+ */
+declare const STORAGE_OUTPUT_TYPE_ID = "storage-output-v1";
+declare const OCR_OUTPUT_TYPE_ID = "ocr-output-v1";
+declare const IMAGE_DESCRIPTION_OUTPUT_TYPE_ID = "image-description-output-v1";
+declare const STREAMING_INPUT_TYPE_ID = "streaming-input-v1";
+/**
+ * OCR output schema - structured text extraction result.
+ *
+ * @property extractedText - The text extracted from the document
+ * @property format - Output format (text, markdown, or JSON)
+ * @property taskType - Type of OCR task performed
+ * @property confidence - Optional confidence score (0-1)
+ */
+declare const ocrOutputSchema: z.ZodObject<{
+  extractedText: z.ZodString;
+  format: z.ZodEnum<{
+    markdown: "markdown";
+    plain: "plain";
+    structured: "structured";
+  }>;
+  taskType: z.ZodEnum<{
+    convertToMarkdown: "convertToMarkdown";
+    freeOcr: "freeOcr";
+    parseFigure: "parseFigure";
+    locateObject: "locateObject";
+  }>;
+  confidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type OcrOutput = z.infer<typeof ocrOutputSchema>;
+/**
+ * Image description output schema - AI-generated image analysis result.
+ *
+ * @property description - Human-readable description of the image
+ * @property confidence - Confidence score for the description (0-1)
+ * @property metadata - Additional metadata about the description
+ */
+declare const imageDescriptionOutputSchema: z.ZodObject<{
+  description: z.ZodString;
+  confidence: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ImageDescriptionOutput = z.infer<typeof imageDescriptionOutputSchema>;
+//#endregion
+//#region src/flow/dead-letter-queue.d.ts
+/**
+ * Shape of the Dead Letter Queue service.
+ *
+ * Provides all operations for managing failed flow jobs including
+ * adding items, querying, retrying, and cleanup.
+ */
+interface DeadLetterQueueServiceShape {
+  /**
+   * Add a failed job to the DLQ with full failure context.
+   *
+   * @param job - The failed flow job
+   * @param error - The error that caused the failure
+   * @param retryPolicy - Optional retry policy (uses default if not provided)
+   * @returns The created DLQ item
+   */
+  add(job: FlowJob, error: UploadistaError, retryPolicy?: RetryPolicy): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Get a specific DLQ item by ID.
+   *
+   * @param itemId - The DLQ item ID
+   * @returns The DLQ item
+   */
+  get(itemId: string): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Get a DLQ item by ID, returning None if not found.
+   *
+   * @param itemId - The DLQ item ID
+   * @returns Option of the DLQ item
+   */
+  getOption(itemId: string): Effect.Effect<Option.Option<DeadLetterItem>, UploadistaError>;
+  /**
+   * Delete a DLQ item.
+   *
+   * @param itemId - The DLQ item ID to delete
+   */
+  delete(itemId: string): Effect.Effect<void, UploadistaError>;
+  /**
+   * List DLQ items with optional filtering and pagination.
+   *
+   * @param options - Filter and pagination options
+   * @returns List of items and total count
+   */
+  list(options?: DeadLetterListOptions): Effect.Effect<{
+    items: DeadLetterItem[];
+    total: number;
+  }, UploadistaError>;
+  /**
+   * Update a DLQ item.
+   *
+   * @param itemId - The DLQ item ID
+   * @param updates - Partial updates to apply
+   * @returns The updated item
+   */
+  update(itemId: string, updates: Partial<DeadLetterItem>): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Mark a DLQ item as being retried.
+   *
+   * @param itemId - The DLQ item ID
+   * @returns The updated item with status "retrying"
+   */
+  markRetrying(itemId: string): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Record a failed retry attempt.
+   *
+   * @param itemId - The DLQ item ID
+   * @param error - Error message from the failed retry
+   * @param durationMs - Duration of the retry attempt
+   * @returns The updated item
+   */
+  recordRetryFailure(itemId: string, error: string, durationMs: number): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Mark a DLQ item as resolved (successfully retried or manually resolved).
+   *
+   * @param itemId - The DLQ item ID
+   * @returns The updated item with status "resolved"
+   */
+  markResolved(itemId: string): Effect.Effect<DeadLetterItem, UploadistaError>;
+  /**
+   * Get items that are due for scheduled retry.
+   *
+   * @param limit - Maximum number of items to return
+   * @returns List of items ready for retry
+   */
+  getScheduledRetries(limit?: number): Effect.Effect<DeadLetterItem[], UploadistaError>;
+  /**
+   * Cleanup old DLQ items based on options.
+   *
+   * @param options - Cleanup criteria
+   * @returns Number of items deleted
+   */
+  cleanup(options?: DeadLetterCleanupOptions): Effect.Effect<DeadLetterCleanupResult, UploadistaError>;
+  /**
+   * Get DLQ statistics.
+   *
+   * @returns Aggregate statistics about the DLQ
+   */
+  getStats(): Effect.Effect<DeadLetterQueueStats, UploadistaError>;
+}
+declare const DeadLetterQueueService_base: Context.TagClass<DeadLetterQueueService, "DeadLetterQueueService", DeadLetterQueueServiceShape>;
+/**
+ * Effect-TS context tag for the Dead Letter Queue service.
+ *
+ * @example
+ * ```typescript
+ * const effect = Effect.gen(function* () {
+ *   const dlq = yield* DeadLetterQueueService;
+ *   const stats = yield* dlq.getStats();
+ *   console.log(`DLQ has ${stats.totalItems} items`);
+ * });
+ * ```
+ */
+declare class DeadLetterQueueService extends DeadLetterQueueService_base {
+  /**
+   * Access the DLQ service optionally (for integration in FlowServer).
+   * Returns Option.none if the service is not provided.
+   */
+  static optional: Effect.Effect<Option.Option<DeadLetterQueueServiceShape>, never, never>;
+}
+/**
+ * Creates the Dead Letter Queue service implementation.
+ *
+ * @returns Effect that creates the DLQ service
+ */
+declare function createDeadLetterQueueService(): Effect.Effect<DeadLetterQueueServiceShape, never, DeadLetterQueueKVStore>;
+/**
+ * Effect Layer that creates the DeadLetterQueueService.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const dlq = yield* DeadLetterQueueService;
+ *   const stats = yield* dlq.getStats();
+ *   return stats;
+ * }).pipe(
+ *   Effect.provide(deadLetterQueueService),
+ *   Effect.provide(deadLetterQueueKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
+ */
+declare const deadLetterQueueService: Layer.Layer<DeadLetterQueueService, never, DeadLetterQueueKVStore>;
+//#endregion
+//#region src/flow/flow-queue-store.d.ts
+/**
+ * Adapter interface for flow queue item persistence.
+ *
+ * Implementations must provide CRUD operations for FlowQueueItems and an
+ * efficient status-based listing. Redis implementations use sorted sets and
+ * sets for O(log n) lookups; the memory implementation uses a plain Map.
+ *
+ * @example
+ * ```typescript
+ * // Provide a custom store via the Effect layer
+ * const customStore: FlowQueueStore = { ... };
+ * ```
+ */
+interface FlowQueueStore {
+  /**
+   * Persist a new queue item.
+   *
+   * @param item - The fully-constructed FlowQueueItem to store
+   * @returns The stored item
+   */
+  createItem(item: FlowQueueItem): Effect.Effect<FlowQueueItem, UploadistaError>;
+  /**
+   * Retrieve a queue item by ID.
+   *
+   * @param id - The queue item ID
+   * @returns The item, or null if not found
+   */
+  getItem(id: string): Effect.Effect<FlowQueueItem | null, UploadistaError>;
+  /**
+   * Apply partial updates to an existing queue item.
+   *
+   * The implementation must atomically update the item and any status-based
+   * indexes (e.g., Redis sorted sets) when status changes.
+   *
+   * @param id - The queue item ID
+   * @param updates - Fields to update (merged over the existing item)
+   * @returns The fully-updated item
+   */
+  updateItem(id: string, updates: Partial<FlowQueueItem>): Effect.Effect<FlowQueueItem, UploadistaError>;
+  /**
+   * List all items with a specific status.
+   *
+   * For "pending" items, results SHOULD be returned in FIFO order (oldest first)
+   * so that the worker loop dispatches items in enqueuedAt order.
+   *
+   * @param status - The status to filter by
+   * @returns Array of matching items
+   */
+  listByStatus(status: FlowQueueItemStatus): Effect.Effect<FlowQueueItem[], UploadistaError>;
+  /**
+   * Remove a queue item from the store.
+   *
+   * @param id - The queue item ID to remove
+   */
+  deleteItem(id: string): Effect.Effect<void, UploadistaError>;
+}
+/**
+ * In-memory implementation of FlowQueueStore.
+ *
+ * Uses a plain Map for storage. Items are not persisted across process restarts.
+ * Suitable for single-process deployments or development/testing.
+ *
+ * For durability across restarts, use RedisFlowQueueStore or IoRedisFlowQueueStore.
+ *
+ * @example
+ * ```typescript
+ * const store = new MemoryFlowQueueStore();
+ * // Pass to FlowQueueService.make(config, store)
+ * ```
+ */
+declare class MemoryFlowQueueStore implements FlowQueueStore {
+  private readonly items;
+  createItem(item: FlowQueueItem): Effect.Effect<FlowQueueItem, UploadistaError>;
+  getItem(id: string): Effect.Effect<FlowQueueItem | null, UploadistaError>;
+  updateItem(id: string, updates: Partial<FlowQueueItem>): Effect.Effect<FlowQueueItem, UploadistaError>;
+  listByStatus(status: FlowQueueItemStatus): Effect.Effect<FlowQueueItem[], UploadistaError>;
+  deleteItem(id: string): Effect.Effect<void, UploadistaError>;
+}
+//#endregion
+//#region src/flow/flow-engine.d.ts
+/**
+ * WaitUntil callback type for keeping background tasks alive.
+ * Used in serverless environments like Cloudflare Workers to prevent
+ * premature termination of background operations.
+ *
+ * @param promise - Promise representing the background task to keep alive
+ */
+type WaitUntilCallback = (promise: Promise<unknown>) => void;
+declare const FlowWaitUntil_base: Context.TagClass<FlowWaitUntil, "FlowWaitUntil", WaitUntilCallback>;
+/**
+ * Optional WaitUntil service for background task management.
+ * When provided, allows flows to execute beyond the HTTP response lifecycle.
+ *
+ * In Cloudflare Workers, use `ctx.executionCtx.waitUntil()`.
+ * In other environments, this can be undefined (flows execute normally with Effect.fork).
+ *
+ * This service uses Effect's optional service pattern. Access it via:
+ * ```typescript
+ * const waitUntil = yield* FlowWaitUntil.optional;
+ * if (Option.isSome(waitUntil)) {
+ *   // Use waitUntil.value
+ * }
+ * ```
+ *
+ * @see https://effect.website/docs/requirements-management/services/#optional-services
+ */
+declare class FlowWaitUntil extends FlowWaitUntil_base {
+  static optional: Effect.Effect<Option.Option<WaitUntilCallback>, never, never>;
+}
+declare const FlowLifecycleHook_base: Context.TagClass<FlowLifecycleHook, "FlowLifecycleHook", {
+  readonly onComplete: (ctx: {
+    jobId: string;
+    flowId: string;
+    clientId: string | null;
+    status: "completed" | "failed";
+  }) => Effect.Effect<void>;
+}>;
+/**
+ * Optional lifecycle hook for flow execution events.
+ * Called when a flow completes or fails, enabling usage tracking,
+ * billing, and other post-processing directly in the execution pipeline.
+ *
+ * This follows the same optional service pattern as {@link DeadLetterQueueService}.
+ * When provided, the hook fires reliably from the flow daemon — not from
+ * polling endpoints — ensuring it always runs exactly once per flow execution.
+ */
+declare class FlowLifecycleHook extends FlowLifecycleHook_base {
+  static optional: Effect.Effect<Option.Option<{
+    readonly onComplete: (ctx: {
+      jobId: string;
+      flowId: string;
+      clientId: string | null;
+      status: "completed" | "failed";
+    }) => Effect.Effect<void>;
+  }>, never, never>;
+}
+/**
+ * Flow provider interface that applications must implement.
+ *
+ * This interface defines how the FlowEngine retrieves flow definitions.
+ * Applications provide their own implementation to load flows from a database,
+ * configuration files, or any other source.
+ *
+ * @template TRequirements - Additional Effect requirements for flow execution
+ *
+ * @property getFlow - Retrieves a flow definition by ID with authorization check
+ *
+ * @example
+ * ```typescript
+ * // Implement a flow provider from database
+ * const dbFlowProvider: FlowProviderShape = {
+ *   getFlow: (flowId, clientId) => Effect.gen(function* () {
+ *     // Load flow from database
+ *     const flowData = yield* db.getFlow(flowId);
+ *
+ *     // Check authorization
+ *     if (flowData.ownerId !== clientId) {
+ *       return yield* Effect.fail(
+ *         UploadistaError.fromCode("FLOW_NOT_AUTHORIZED")
+ *       );
+ *     }
+ *
+ *     // Create flow instance
+ *     return createFlow(flowData);
+ *   })
+ * };
+ *
+ * // Provide to FlowEngine
+ * const flowProviderLayer = Layer.succeed(FlowProvider, dbFlowProvider);
+ * ```
+ */
+type FlowProviderShape<TRequirements = any> = {
+  getFlow: (flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError>;
+};
+declare const FlowProvider_base: Context.TagClass<FlowProvider, "FlowProvider", FlowProviderShape<any>>;
+/**
+ * Effect-TS context tag for the FlowProvider service.
+ *
+ * Applications must provide an implementation of FlowProviderShape
+ * to enable the FlowEngine to retrieve flow definitions.
+ *
+ * @example
+ * ```typescript
+ * // Access FlowProvider in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const provider = yield* FlowProvider;
+ *   const flow = yield* provider.getFlow("flow123", "client456");
+ *   return flow;
+ * });
+ * ```
+ */
+declare class FlowProvider extends FlowProvider_base {}
+/**
+ * FlowServer service interface.
+ *
+ * This is the core flow processing service that executes DAG-based file processing pipelines.
+ * It manages flow execution, job tracking, node processing, pause/resume functionality,
+ * and real-time event broadcasting.
+ *
+ * All operations return Effect types for composable, type-safe error handling.
+ *
+ * @property getFlow - Retrieves a flow definition by ID
+ * @property getFlowData - Retrieves flow metadata (nodes, edges) without full flow instance
+ * @property runFlow - Starts a new flow execution and returns immediately with job ID
+ * @property resumeFlow - Resumes a paused flow with new data for a specific node
+ * @property pauseFlow - Pauses a running flow (user-initiated pause)
+ * @property cancelFlow - Cancels a running or paused flow and cleans up resources
+ * @property getJobStatus - Retrieves current status and results of a flow job
+ * @property subscribeToFlowEvents - Subscribes WebSocket to flow execution events
+ * @property unsubscribeFromFlowEvents - Unsubscribes from flow events
+ *
+ * @example
+ * ```typescript
+ * // Execute a flow
+ * const program = Effect.gen(function* () {
+ *   const server = yield* FlowEngine;
+ *
+ *   // Start flow execution (returns immediately)
+ *   const job = yield* server.runFlow({
+ *     flowId: "resize-optimize",
+ *     storageId: "s3-production",
+ *     clientId: "client123",
+ *     inputs: {
+ *       input_1: { uploadId: "upload_abc123" }
+ *     }
+ *   });
+ *
+ *   // Subscribe to events
+ *   yield* server.subscribeToFlowEvents(job.id, websocket);
+ *
+ *   // Poll for status
+ *   const status = yield* server.getJobStatus(job.id);
+ *   console.log(status.status); // "running", "paused", "completed", "failed", or "cancelled"
+ *
+ *   // User can pause the flow
+ *   yield* server.pauseFlow(job.id, "client123");
+ *
+ *   return job;
+ * });
+ *
+ * // Resume a paused flow
+ * const resume = Effect.gen(function* () {
+ *   const server = yield* FlowEngine;
+ *
+ *   // Flow paused waiting for user input at node "approval_1"
+ *   const job = yield* server.resumeFlow({
+ *     jobId: "job123",
+ *     nodeId: "approval_1",
+ *     newData: { approved: true },
+ *     clientId: "client123"
+ *   });
+ *
+ *   return job;
+ * });
+ *
+ * // Cancel a flow
+ * const cancel = Effect.gen(function* () {
+ *   const server = yield* FlowEngine;
+ *
+ *   // Cancel flow and cleanup intermediate files
+ *   const job = yield* server.cancelFlow("job123", "client123");
+ *
+ *   return job;
+ * });
+ *
+ * // Check flow structure before execution
+ * const inspect = Effect.gen(function* () {
+ *   const server = yield* FlowEngine;
+ *
+ *   const flowData = yield* server.getFlowData("resize-optimize", "client123");
+ *   console.log("Nodes:", flowData.nodes);
+ *   console.log("Edges:", flowData.edges);
+ *
+ *   return flowData;
+ * });
+ * ```
+ */
+type FlowEngineShape = {
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError>;
+  getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError>;
+  runFlow: <TRequirements>({
+    flowId,
+    storageId,
+    clientId,
+    inputs,
+    jobId
+  }: {
+    flowId: string;
+    storageId: string;
+    clientId: string | null;
+    inputs: any; /** Optional job ID to use instead of generating a new UUID. Used by the queue worker to keep the queue item ID and flow job ID in sync. */
+    jobId?: string;
+  }) => Effect.Effect<FlowJob, UploadistaError, TRequirements>;
+  resumeFlow: <TRequirements>({
+    jobId,
+    nodeId,
+    newData,
+    clientId
+  }: {
+    jobId: string;
+    nodeId: string;
+    newData: unknown;
+    clientId: string | null;
+  }) => Effect.Effect<FlowJob, UploadistaError, TRequirements>;
+  pauseFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError>;
+  cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError>;
+  getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError>;
+  subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError>;
+  unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError>;
+};
+declare const FlowEngine_base: Context.TagClass<FlowEngine, "FlowEngine", FlowEngineShape>;
+/**
+ * Effect-TS context tag for the FlowEngine service.
+ *
+ * Use this tag to access the FlowEngine in an Effect context.
+ * The server must be provided via a Layer or dependency injection.
+ *
+ * @example
+ * ```typescript
+ * // Access FlowEngine in an Effect
+ * const flowEffect = Effect.gen(function* () {
+ *   const server = yield* FlowEngine;
+ *   const job = yield* server.runFlow({
+ *     flowId: "my-flow",
+ *     storageId: "s3",
+ *     clientId: null,
+ *     inputs: {}
+ *   });
+ *   return job;
+ * });
+ *
+ * // Provide FlowEngine layer
+ * const program = flowEffect.pipe(
+ *   Effect.provide(flowServer),
+ *   Effect.provide(flowProviderLayer),
+ *   Effect.provide(flowJobKvStore)
+ * );
+ * ```
+ */
+declare class FlowEngine extends FlowEngine_base {}
+/**
+ * Legacy configuration options for FlowEngine.
+ *
+ * @deprecated Use Effect Layers and FlowProvider instead.
+ * This type is kept for backward compatibility.
+ *
+ * @property getFlow - Function to retrieve flow definitions
+ * @property kvStore - KV store for flow job metadata
+ */
+type FlowEngineOptions = {
+  getFlow: <TRequirements>({
+    flowId,
+    storageId
+  }: {
+    flowId: string;
+    storageId: string;
+  }) => Promise<Flow<any, any, TRequirements>>;
+  kvStore: KvStore<FlowJob>;
+};
+declare function createFlowEngine(): Effect.Effect<{
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, any>, UploadistaError, never>;
+  getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError, never>;
+  runFlow: ({
+    flowId,
+    storageId,
+    clientId,
+    inputs,
+    jobId: providedJobId
+  }: {
+    flowId: string;
+    storageId: string;
+    clientId: string | null;
+    inputs: unknown;
+    jobId?: string;
+  }) => Effect.Effect<FlowJob | {
+    id: string;
+    flowId: string;
+    storageId: string;
+    clientId: string | null;
+    status: "pending";
+    tasks: never[];
+    createdAt: Date;
+    updatedAt: Date;
+  }, UploadistaError, never>;
+  getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError, never>;
+  resumeFlow: ({
+    jobId,
+    nodeId,
+    newData,
+    clientId
+  }: {
+    jobId: string;
+    nodeId: string;
+    newData: unknown;
+    clientId: string | null;
+  }) => Effect.Effect<FlowJob, UploadistaError, never>;
+  pauseFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError, never>;
+  cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError, never>;
+  subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError, never>;
+  unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError, never>;
+}, never, FlowEventEmitter | FlowJobKVStore | FlowProvider | UploadEngine>;
+declare const flowEngine: Layer.Layer<FlowEngine, never, FlowEventEmitter | FlowJobKVStore | FlowProvider | UploadEngine>;
+type FlowEngineLayer = typeof flowEngine;
+//#endregion
+//#region src/flow/flow-queue.d.ts
+declare const FlowQueueDispatchMarker_base: Context.TagClass<FlowQueueDispatchMarker, "FlowQueueDispatchMarker", true>;
+/**
+ * Context marker that signals the current Effect is running inside the
+ * FlowQueueService worker dispatch loop.
+ *
+ * When this marker is present in the Effect context, FlowEngine.runFlow()
+ * skips the FlowQueueService delegation and executes directly via forkDaemon.
+ * This prevents infinite re-enqueue cycles when the worker calls runFlow.
+ *
+ * @internal
+ */
+declare class FlowQueueDispatchMarker extends FlowQueueDispatchMarker_base {}
+/**
+ * Shape of the FlowQueueService.
+ *
+ * All operations return Effect types for composable, type-safe error handling.
+ */
+interface FlowQueueServiceShape {
+  /**
+   * Enqueue a flow for execution.
+   *
+   * Returns immediately with a FlowQueueItem in "pending" state.
+   * The worker loop will dispatch the flow when a concurrency slot is available.
+   *
+   * @param params - Flow execution parameters
+   * @returns The created queue item with status "pending"
+   */
+  enqueue(params: {
+    flowId: string;
+    storageId: string;
+    input: unknown;
+    clientId: string | null;
+    dlqItemId?: string;
+  }): Effect.Effect<FlowQueueItem, UploadistaError>;
+  /**
+   * Retrieve the current status of a queue item by ID.
+   *
+   * @param itemId - The queue item ID
+   * @returns The queue item
+   * @throws QUEUE_ITEM_NOT_FOUND if the ID is unknown
+   */
+  getStatus(itemId: string): Effect.Effect<FlowQueueItem, UploadistaError>;
+  /**
+   * Cancel a pending queue item before it starts executing.
+   *
+   * @param itemId - The queue item ID
+   * @throws QUEUE_ITEM_ALREADY_RUNNING if the item is already running
+   */
+  cancel(itemId: string): Effect.Effect<void, UploadistaError>;
+  /**
+   * List queue items, optionally filtered by status.
+   *
+   * @param options - Optional filter options
+   * @returns Array of matching queue items
+   */
+  list(options?: {
+    status?: FlowQueueItem["status"];
+  }): Effect.Effect<FlowQueueItem[], UploadistaError>;
+  /**
+   * Get aggregate queue statistics for monitoring.
+   *
+   * @returns Current queue stats including counts and concurrency info
+   */
+  getStats(): Effect.Effect<FlowQueueStats, UploadistaError>;
+}
+declare const FlowQueueService_base: Context.TagClass<FlowQueueService, "FlowQueueService", FlowQueueServiceShape>;
+/**
+ * Effect-TS context tag for the FlowQueueService.
+ *
+ * Use `FlowQueueService.optional` to resolve it optionally — this is the
+ * pattern used in FlowEngine to preserve backward compatibility.
+ *
+ * @example
+ * ```typescript
+ * // In FlowEngine.runFlow()
+ * const queueOption = yield* FlowQueueService.optional;
+ * if (Option.isSome(queueOption)) {
+ *   return yield* queueOption.value.enqueue({ flowId, storageId, input, clientId });
+ * }
+ * // ... existing fork path
+ *
+ * // From application code
+ * const queue = yield* FlowQueueService;
+ * const item = yield* queue.enqueue({ flowId: "my-flow", storageId: "s3", input: {}, clientId: null });
+ * ```
+ */
+declare class FlowQueueService extends FlowQueueService_base {
+  /**
+   * Access the FlowQueueService optionally.
+   * Returns Option.none() if the service is not present in the layer.
+   *
+   * Use this in FlowEngine to remain backward-compatible.
+   */
+  static readonly optional: Effect.Effect<Option.Option<FlowQueueServiceShape>, never, never>;
+  /**
+   * Create a FlowQueueService Layer using the default in-memory store.
+   *
+   * @param config - Optional configuration overrides
+   * @returns A Layer providing FlowQueueService
+   */
+  static Default(config?: FlowQueueConfig): Layer.Layer<FlowQueueService, never, FlowEngine>;
+  /**
+   * Create a FlowQueueService Layer with a custom store.
+   *
+   * @param config - Configuration (maxConcurrency, dlqRetryIntervalMs, dlqRetryBatchSize)
+   * @param store - The FlowQueueStore implementation to use
+   * @returns A Layer providing FlowQueueService
+   */
+  static make(config: FlowQueueConfig, store: FlowQueueStore): Layer.Layer<FlowQueueService, never, FlowEngine>;
+  /**
+   * Create a FlowQueueService Layer backed by the application's BaseKvStoreService.
+   *
+   * Items are persisted under the "uploadista:queue-item:" key prefix, using the
+   * same KV store already configured for the server (Redis, Cloudflare KV, etc.).
+   * This is the recommended factory for most deployments — no separate store
+   * dependency is needed beyond the kvStore already wired at server level.
+   *
+   * @param config - Optional queue configuration (maxConcurrency, retry intervals…)
+   * @returns A Layer providing FlowQueueService, requiring FlowEngine and BaseKvStoreService
+   *
+   * @example
+   * ```typescript
+   * // In createUploadistaServer — flowQueue: true uses this automatically
+   * FlowQueueService.fromKvStore({ maxConcurrency: 8 })
+   *   .pipe(Layer.provide(flowEngineLayer), Layer.provide(kvStore))
+   * ```
+   */
+  static fromKvStore(config?: FlowQueueConfig): Layer.Layer<FlowQueueService, never, FlowEngine | FlowQueueKVStore>;
+  /**
+   * Shorthand for fromKvStore — creates the full layer including the KV store
+   * sub-layer, requiring only FlowEngine and BaseKvStoreService.
+   */
+  static fromBaseKvStore(config?: FlowQueueConfig): Layer.Layer<FlowQueueService, never, FlowEngine | BaseKvStoreService>;
+}
+//#endregion
+//#region src/flow/nodes/input-node.d.ts
+/**
+ * Union schema for all input operations.
+ * Defines the possible input data structures for the input node.
+ */
+declare const inputDataSchema: z.ZodUnion<readonly [z.ZodObject<{
+  operation: z.ZodLiteral<"init">;
+  storageId: z.ZodString;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>, z.ZodObject<{
+  operation: z.ZodLiteral<"finalize">;
+  uploadId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  operation: z.ZodLiteral<"url">;
+  url: z.ZodString;
+  storageId: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>]>;
+/**
+ * Type representing the input data for the input node.
+ * Can be one of three operation types: init, finalize, or url.
+ */
+type InputData = z.infer<typeof inputDataSchema>;
+/**
+ * Schema for input node filtering parameters.
+ * Defines validation rules for incoming files.
+ */
+declare const inputNodeParamsSchema: z.ZodObject<{
+  allowedMimeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  minSize: z.ZodOptional<z.ZodNumber>;
+  maxSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Parameters for configuring input node validation.
+ * Controls which files are accepted based on type and size constraints.
+ */
+type InputNodeParams = z.infer<typeof inputNodeParamsSchema>;
+/**
+ * Creates an input node for handling file input through multiple methods.
+ *
+ * The input node supports three operation types:
+ * - `init`: Initialize a streaming upload session
+ * - `finalize`: Complete a streaming upload after all chunks are uploaded
+ * - `url`: Fetch a file directly from a URL
+ *
+ * @param id - Unique identifier for the node
+ * @param params - Optional validation parameters for filtering incoming files
+ * @returns An Effect that creates a flow node configured for file input
+ *
+ * @example
+ * ```typescript
+ * // Create input node with validation
+ * const inputNode = yield* createInputNode("file-input", {
+ *   allowedMimeTypes: ["image/*", "application/pdf"],
+ *   maxSize: 10 * 1024 * 1024, // 10MB
+ * });
+ *
+ * // Create input node without validation
+ * const openInputNode = yield* createInputNode("open-input");
+ * ```
+ */
+declare function createInputNode(id: string, params?: InputNodeParams, options?: {
+  keepOutput?: boolean;
+}): Effect.Effect<FlowNodeData & {
+  inputSchema: z.ZodType<{
+    operation: "init";
+    storageId: string;
+    metadata?: Record<string, any> | undefined;
+  } | {
+    operation: "finalize";
+    uploadId: string;
+  } | {
+    operation: "url";
+    url: string;
+    storageId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+  }, unknown, z.core.$ZodTypeInternals<{
+    operation: "init";
+    storageId: string;
+    metadata?: Record<string, any> | undefined;
+  } | {
+    operation: "finalize";
+    uploadId: string;
+  } | {
+    operation: "url";
+    url: string;
+    storageId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+  }, unknown>>;
+  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: {
+      operation: "init";
+      storageId: string;
+      metadata?: Record<string, any> | undefined;
+    } | {
+      operation: "finalize";
+      uploadId: string;
+    } | {
+      operation: "url";
+      url: string;
+      storageId?: string | undefined;
+      metadata?: Record<string, any> | undefined;
+    };
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+  circuitBreaker?: FlowCircuitBreakerConfig;
+} & {
+  type: NodeType.input;
+}, UploadistaError, UploadEngine>;
+//#endregion
+//#region src/flow/types/flow-file.d.ts
+/**
+ * Conditional execution rules for flow nodes.
+ *
+ * Conditions allow nodes to execute conditionally based on file properties or metadata.
+ * They are evaluated before node execution and can skip nodes that don't match.
+ *
+ * @module flow/types/flow-file
+ * @see {@link FlowNode} for how conditions are used in nodes
+ *
+ * @example
+ * ```typescript
+ * // Only process images larger than 1MB
+ * const condition: FlowCondition = {
+ *   field: "size",
+ *   operator: "greaterThan",
+ *   value: 1024 * 1024
+ * };
+ *
+ * // Only process JPEG images
+ * const jpegCondition: FlowCondition = {
+ *   field: "mimeType",
+ *   operator: "startsWith",
+ *   value: "image/jpeg"
+ * };
+ * ```
+ */
+/**
+ * Represents a conditional rule for node execution.
+ *
+ * @property field - The file property to check
+ * @property operator - The comparison operator to apply
+ * @property value - The value to compare against
+ *
+ * @remarks
+ * - Fields can check file metadata (mimeType, size) or image properties (width, height)
+ * - String operators (contains, startsWith) work with string values
+ * - Numeric operators (greaterThan, lessThan) work with numeric values
+ * - The extension field checks the file extension without the dot
+ */
+type FlowCondition = {
+  field: "mimeType" | "size" | "width" | "height" | "extension";
+  operator: "equals" | "notEquals" | "greaterThan" | "lessThan" | "contains" | "startsWith";
+  value: string | number;
+};
+//#endregion
+//#region src/flow/types/type-utils.d.ts
+/**
+ * Extracts the service type from an Effect Layer.
+ *
+ * Given a Layer that provides a service, this type utility extracts
+ * the service type from the Layer's type signature.
+ *
+ * @template T - The Layer type to extract from
+ * @returns The service type provided by the layer, or never if T is not a Layer
+ *
+ * @example
+ * ```typescript
+ * type MyLayer = Layer.Layer<ServiceA, never, never>;
+ * type Service = ExtractLayerService<MyLayer>;
+ * // Service = ServiceA
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePluginLayer } from '@uploadista/core';
+ *
+ * type ImageService = ExtractLayerService<ImagePluginLayer>;
+ * // ImageService = ImagePlugin
+ * ```
+ */
+type ExtractLayerService<T, TError = never, TRequirements = never> = T extends Layer.Layer<infer S, TError, TRequirements> ? S : never;
+/**
+ * Extracts all service types from a tuple of layers and returns them as a union.
+ *
+ * This type recursively processes a tuple of Layer types and extracts all
+ * the services they provide, combining them into a single union type.
+ *
+ * @template T - A readonly tuple of Layer types
+ * @returns A union of all service types provided by the layers, or never for empty tuples
+ *
+ * @example
+ * ```typescript
+ * type Layers = [
+ *   Layer.Layer<ServiceA, never, never>,
+ *   Layer.Layer<ServiceB, never, never>,
+ *   Layer.Layer<ServiceC, never, never>
+ * ];
+ * type Services = ExtractLayerServices<Layers>;
+ * // Services = ServiceA | ServiceB | ServiceC
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePluginLayer, ZipPluginLayer } from '@uploadista/core';
+ *
+ * type PluginLayers = [ImagePluginLayer, ZipPluginLayer];
+ * type AllServices = ExtractLayerServices<PluginLayers>;
+ * // AllServices = ImagePlugin | ZipPlugin
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type EmptyLayers = [];
+ * type NoServices = ExtractLayerServices<EmptyLayers>;
+ * // NoServices = never
+ * ```
+ */
+type ExtractLayerServices<T extends readonly Layer.Layer<any, any, any>[]> = T extends readonly [] ? never : { [K in keyof T]: T[K] extends Layer.Layer<infer S, any, any> ? S : never }[number];
+/**
+ * Unwraps an Effect type to extract its success value type.
+ *
+ * If the input type is an Effect, this extracts the success type (first type parameter).
+ * If the input is not an Effect, it returns the type unchanged.
+ *
+ * @template T - The type to resolve, potentially an Effect
+ * @returns The success type if T is an Effect, otherwise T
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, Error, never>;
+ * type Result = ResolveEffect<MyEffect>;
+ * // Result = string
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type NonEffect = { data: string };
+ * type Result = ResolveEffect<NonEffect>;
+ * // Result = { data: string }
+ * ```
+ */
+type ResolveEffect<T> = T extends Effect.Effect<infer S, any, any> ? S : T;
+/**
+ * Extracts the error type from an Effect.
+ *
+ * Given an Effect type, this utility extracts the error type
+ * (second type parameter) from the Effect's type signature.
+ *
+ * @template T - The Effect type to extract from
+ * @returns The error type of the Effect, or never if T is not an Effect
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, ValidationError, never>;
+ * type ErrorType = ExtractEffectError<MyEffect>;
+ * // ErrorType = ValidationError
+ * ```
+ *
+ * @example
+ * ```typescript
+ * type SafeEffect = Effect.Effect<number, never, SomeService>;
+ * type ErrorType = ExtractEffectError<SafeEffect>;
+ * // ErrorType = never (no errors possible)
+ * ```
+ */
+type ExtractEffectError<T> = T extends Effect.Effect<any, infer E, any> ? E : never;
+/**
+ * Extracts the requirements (context) type from an Effect.
+ *
+ * Given an Effect type, this utility extracts the requirements type
+ * (third type parameter) from the Effect's type signature. This represents
+ * the services that must be provided for the Effect to run.
+ *
+ * @template T - The Effect type to extract from
+ * @returns The requirements type of the Effect, or never if T is not an Effect
+ *
+ * @example
+ * ```typescript
+ * type MyEffect = Effect.Effect<string, Error, Database | Logger>;
+ * type Requirements = ExtractEffectRequirements<MyEffect>;
+ * // Requirements = Database | Logger
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { ImagePlugin, ZipPlugin } from '@uploadista/core';
+ *
+ * type ProcessEffect = Effect.Effect<
+ *   ProcessedImage,
+ *   ProcessError,
+ *   ImagePlugin | ZipPlugin
+ * >;
+ * type Needed = ExtractEffectRequirements<ProcessEffect>;
+ * // Needed = ImagePlugin | ZipPlugin
+ * ```
+ */
+type ExtractEffectRequirements<T> = T extends Effect.Effect<any, any, infer R> ? R : never;
+//#endregion
+//#region src/flow/nodes/transform-node.d.ts
+/**
+ * Transform mode for controlling how file data is processed.
+ *
+ * - `buffered`: Always load entire file into memory before transforming (default, backward compatible)
+ * - `streaming`: Process file as a stream of chunks for memory efficiency
+ * - `auto`: Automatically select mode based on file size and DataStore capabilities
+ */
+type TransformMode = "buffered" | "streaming" | "auto";
+/**
+ * Result type for streaming transforms.
+ * Can return just the transformed stream, or include metadata changes.
+ */
+type StreamingTransformResult = Stream.Stream<Uint8Array, UploadistaError> | {
+  stream: Stream.Stream<Uint8Array, UploadistaError>;
+  type?: string;
+  fileName?: string; /** Estimated output size in bytes (for progress tracking) */
+  estimatedSize?: number;
+};
+/**
+ * Function type for streaming transforms.
+ * Receives an input stream and file metadata, returns a transformed stream.
+ */
+type StreamingTransformFn = (stream: Stream.Stream<Uint8Array, UploadistaError>, file: UploadFile) => Effect.Effect<StreamingTransformResult, UploadistaError>;
+/**
+ * Configuration object for creating a transform node.
+ */
+interface TransformNodeConfig {
+  /** Unique identifier for the node */
+  id: string;
+  /** Human-readable name for the node */
+  name: string;
+  /** Description of what the node does */
+  description: string;
+  /** Optional output type ID from outputTypeRegistry for result type registration */
+  outputTypeId?: string;
+  /**
+   * Whether to keep this node's output as a flow result even if it has outgoing edges.
+   * When true, the node's output will be included in the final flow outputs alongside topology sinks.
+   * Defaults to false.
+   */
+  keepOutput?: boolean;
+  /**
+   * Optional file naming configuration.
+   * - undefined: Preserve original filename (backward compatible)
+   * - mode: 'auto': Generate smart suffix based on node type
+   * - mode: 'custom': Use template pattern or rename function
+   */
+  naming?: FileNamingConfig;
+  /**
+   * Node type identifier used for auto-naming context.
+   * Defaults to "transform" if not specified.
+   */
+  nodeType?: string;
+  /**
+   * Stable node type identifier for circuit breaker configuration.
+   * Used to share circuit breaker state across nodes of the same type
+   * and for nodeTypeOverrides in flow config.
+   * Example: "describe-image", "remove-background", "scan-virus"
+   */
+  nodeTypeId?: string;
+  /**
+   * Additional variables to include in the naming context.
+   * These are merged with the base context (flowId, jobId, etc.)
+   * and can be used in templates.
+   */
+  namingVars?: Record<string, string | number | undefined>;
+  /**
+   * Circuit breaker configuration for resilience against external service failures.
+   * Overrides flow-level circuit breaker defaults for this node.
+   */
+  circuitBreaker?: FlowCircuitBreakerConfig;
+  /**
+   * Transform mode controlling how file data is processed.
+   * - `buffered`: Always load entire file into memory
+   * - `streaming`: Process file as a stream of chunks
+   * - `auto`: Select mode based on file size and DataStore capabilities (default)
+   *
+   * @default "auto"
+   */
+  mode?: TransformMode;
+  /**
+   * Configuration for streaming mode (file size threshold, chunk size).
+   * Only used when mode is "streaming" or "auto".
+   */
+  streamingConfig?: StreamingConfig;
+  /**
+   * Function that transforms file bytes (buffered mode).
+   * Required unless streamingTransform is provided and mode is "streaming".
+   */
+  transform?: (bytes: Uint8Array, file: UploadFile) => Effect.Effect<Uint8Array | {
+    bytes: Uint8Array;
+    type?: string;
+    fileName?: string;
+    metadata?: Record<string, unknown>;
+  }, UploadistaError>;
+  /**
+   * Function that transforms file as a stream (streaming mode).
+   * For memory-efficient processing of large files.
+   * Used when mode is "streaming" or when "auto" selects streaming.
+   */
+  streamingTransform?: StreamingTransformFn;
+}
+/**
+ * Creates a transform node that handles the common pattern of:
+ * 1. Reading bytes from an UploadFile
+ * 2. Transforming the bytes
+ * 3. Uploading the result as a new UploadFile
+ *
+ * This simplifies nodes that just need to transform file bytes without
+ * worrying about upload server interactions.
+ *
+ * Supports both buffered and streaming modes:
+ * - **Buffered mode**: Loads entire file into memory, transforms, uploads
+ * - **Streaming mode**: Processes file as chunks for memory efficiency with large files
+ * - **Auto mode** (default): Selects mode based on file size and DataStore capabilities
+ *
+ * @param config - Configuration object for the transform node
+ * @returns An Effect that creates a flow node configured for file transformation
+ *
+ * @example
+ * ```typescript
+ * // Create a transform node with auto mode (default) - uses streaming for large files
+ * const resizeNode = yield* createTransformNode({
+ *   id: "resize-image",
+ *   name: "Resize Image",
+ *   description: "Resizes images to specified dimensions",
+ *   transform: (bytes, file) => {
+ *     // Your transformation logic here
+ *     return Effect.succeed(transformedBytes);
+ *   },
+ *   streamingTransform: (stream, file) => {
+ *     const transformed = Stream.map(stream, (chunk) => processChunk(chunk));
+ *     return Effect.succeed(transformed);
+ *   }
+ * });
+ *
+ * // Force buffered mode for specific use cases
+ * const bufferedNode = yield* createTransformNode({
+ *   id: "optimize-small",
+ *   name: "Optimize Small Files",
+ *   description: "Optimizes small files with buffered mode",
+ *   mode: "buffered",
+ *   transform: (bytes, file) => Effect.succeed(transformBytes(bytes)),
+ * });
+ *
+ * // Force streaming mode for memory efficiency
+ * const streamingNode = yield* createTransformNode({
+ *   id: "optimize-large",
+ *   name: "Optimize Large Files",
+ *   description: "Optimizes large files with streaming",
+ *   mode: "streaming",
+ *   streamingTransform: (stream, file) => {
+ *     const transformed = Stream.map(stream, (chunk) => processChunk(chunk));
+ *     return Effect.succeed(transformed);
+ *   }
+ * });
+ * ```
+ */
+declare function createTransformNode({
+  id,
+  name,
+  description,
+  outputTypeId,
+  keepOutput,
+  naming,
+  nodeType: namingNodeType,
+  nodeTypeId,
+  namingVars,
+  circuitBreaker,
+  mode,
+  streamingConfig,
+  transform,
+  streamingTransform
+}: TransformNodeConfig): Effect.Effect<FlowNodeData & {
+  inputSchema: zod.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  outputSchema: zod.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: UploadFile;
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+  circuitBreaker?: FlowCircuitBreakerConfig;
+} & {
+  type: NodeType;
+}, UploadistaError, UploadEngine>;
+//#endregion
+//#region src/flow/parallel-scheduler.d.ts
+/**
+ * Represents a level in the execution hierarchy where all nodes can run in parallel.
+ *
+ * @property level - The execution level (0 = first to execute, higher = later)
+ * @property nodes - Array of node IDs that can execute in parallel at this level
+ *
+ * @example
+ * ```
+ * Level 0: [input_node]           (no dependencies)
+ * Level 1: [resize, optimize]     (all depend on level 0)
+ * Level 2: [storage]              (depends on level 1)
+ * ```
+ */
+interface ExecutionLevel {
+  level: number;
+  nodes: string[];
+}
+/**
+ * Configuration options for the ParallelScheduler.
+ *
+ * @property maxConcurrency - Maximum number of nodes to execute in parallel (default: 4)
+ *                           Controls how many nodes run simultaneously within a level
+ *
+ * @example
+ * ```typescript
+ * const scheduler = new ParallelScheduler({ maxConcurrency: 8 });
+ * ```
+ */
+interface ParallelSchedulerConfig {
+  maxConcurrency?: number;
+}
+/**
+ * Scheduler for executing flow nodes in parallel while respecting dependencies.
+ *
+ * The scheduler performs topological sorting to identify nodes that can run
+ * concurrently, groups them into execution levels, and provides methods to
+ * execute them with controlled concurrency using Effect.
+ *
+ * Key responsibilities:
+ * - Analyze flow dependencies and detect cycles
+ * - Group nodes into parallel execution levels
+ * - Execute levels in parallel with concurrency limits
+ * - Provide utilities to check parallel execution feasibility
+ */
+declare class ParallelScheduler {
+  private maxConcurrency;
+  /**
+   * Creates a new ParallelScheduler instance.
+   *
+   * @param config - Configuration for the scheduler
+   * @example
+   * ```typescript
+   * const scheduler = new ParallelScheduler({ maxConcurrency: 4 });
+   * ```
+   */
+  constructor(config?: ParallelSchedulerConfig);
+  /**
+   * Groups nodes into execution levels where nodes in the same level can run in parallel.
+   *
+   * Uses Kahn's algorithm to perform topological sorting with level identification.
+   * Nodes are grouped by their distance from source nodes (input nodes with no dependencies).
+   *
+   * @param nodes - Array of flow nodes to analyze
+   * @param edges - Array of edges defining dependencies between nodes
+   * @returns Array of execution levels, ordered from 0 (no dependencies) onwards
+   * @throws Error if a cycle is detected in the flow graph
+   *
+   * @example
+   * ```typescript
+   * const levels = scheduler.groupNodesByExecutionLevel(nodes, edges);
+   * // levels = [
+   * //   { level: 0, nodes: ['input_1'] },
+   * //   { level: 1, nodes: ['resize_1', 'optimize_1'] },
+   * //   { level: 2, nodes: ['output_1'] }
+   * // ]
+   * ```
+   */
+  groupNodesByExecutionLevel(nodes: FlowNode<unknown, unknown>[], edges: Array<{
+    source: string;
+    target: string;
+  }>): ExecutionLevel[];
+  /**
+   * Executes a batch of Effect-based node executors in parallel with concurrency control.
+   *
+   * All executors are run in parallel, but the number of concurrent executions is limited
+   * by maxConcurrency. This prevents resource exhaustion while maximizing parallelism.
+   *
+   * @template T - The return type of each executor
+   * @template E - The error type of the Effects
+   * @template R - The requirements type of the Effects
+   *
+   * @param nodeExecutors - Array of Effect-returning functions to execute in parallel
+   * @returns Effect that resolves to array of results in the same order as input
+   *
+   * @example
+   * ```typescript
+   * const results = yield* scheduler.executeNodesInParallel([
+   *   () => executeNode("node1"),
+   *   () => executeNode("node2"),
+   *   () => executeNode("node3")
+   * ]);
+   * // results will be in order: [result1, result2, result3]
+   * ```
+   */
+  executeNodesInParallel<T, E, R>(nodeExecutors: Array<() => Effect.Effect<T, E, R>>): Effect.Effect<T[], E, R>;
+  /**
+   * Determines if a set of nodes can be safely executed in parallel.
+   *
+   * Nodes can execute in parallel if all their dependencies have been completed.
+   * This is typically called to verify that nodes in an execution level are ready
+   * to run given the current node results.
+   *
+   * @param nodeIds - Array of node IDs to check
+   * @param nodeResults - Map of completed node IDs to their results
+   * @param reverseGraph - Dependency graph mapping node IDs to their incoming dependencies
+   * @returns true if all dependencies for all nodes are in nodeResults, false otherwise
+   *
+   * @example
+   * ```typescript
+   * const canRun = scheduler.canExecuteInParallel(
+   *   ['resize_1', 'optimize_1'],
+   *   nodeResults,
+   *   reverseGraph
+   * );
+   * ```
+   */
+  canExecuteInParallel(nodeIds: string[], nodeResults: Map<string, unknown>, reverseGraph: Record<string, string[]>): boolean;
+  /**
+   * Gets execution statistics for monitoring and debugging.
+   *
+   * @returns Object containing current scheduler configuration
+   *
+   * @example
+   * ```typescript
+   * const stats = scheduler.getStats();
+   * console.log(`Max concurrency: ${stats.maxConcurrency}`);
+   * ```
+   */
+  getStats(): {
+    maxConcurrency: number;
+  };
+}
+//#endregion
+//#region src/flow/plugins/credential-provider.d.ts
+/**
+ * Shape definition for the Credential Provider interface.
+ * Defines the contract for retrieving credentials for various services.
+ */
+interface CredentialProviderShape {
+  /**
+   * Retrieves credentials for a specific service and client.
+   *
+   * @param params - Parameters for credential retrieval
+   * @param params.clientId - Unique identifier for the client, or null if not available
+   * @param params.serviceType - Optional service type to get specific credentials for
+   * @returns An Effect that resolves to a record of credential key-value pairs
+   * @throws {UploadistaError} When credential retrieval fails
+   */
+  getCredential: (params: {
+    clientId: string | null;
+    serviceType?: string;
+  }) => Effect.Effect<Record<string, unknown>, UploadistaError>;
+}
+declare const CredentialProvider_base: Context.TagClass<CredentialProvider, "CredentialProvider", CredentialProviderShape>;
+/**
+ * Context tag for the Credential Provider.
+ *
+ * This tag provides a type-safe way to access credential functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { CredentialProvider } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const credentialProvider = yield* CredentialProvider;
+ *   const credentials = yield* credentialProvider.getCredential({
+ *     clientId: "user123",
+ *     serviceType: "replicate"
+ *   });
+ *   return credentials;
+ * });
+ * ```
+ */
+declare class CredentialProvider extends CredentialProvider_base {}
+type CredentialProviderLayer = Layer.Layer<CredentialProvider, never, never>;
+//#endregion
+//#region src/flow/plugins/document-ai-plugin.d.ts
+/**
+ * Context information for AI document processing operations.
+ * Contains client identification and credentials for tracking and billing purposes.
+ */
+type DocumentAiContext = {
+  /** Unique identifier for the client making the request, or null if not available */clientId: string | null; /** Credential ID for accessing the AI service (e.g., Replicate API key) */
+  credentialId?: string;
+};
+/**
+ * Task types supported by OCR operations.
+ */
+type OcrTaskType = "convertToMarkdown" | "freeOcr" | "parseFigure" | "locateObject";
+/**
+ * Resolution options for OCR processing.
+ * Higher resolutions provide better accuracy but slower processing.
+ */
+type OcrResolution = "tiny" | "small" | "base" | "gundam" | "large";
+/**
+ * Parameters for OCR operations.
+ */
+type OcrParams = {
+  /**
+   * Type of OCR task to perform.
+   * - "convertToMarkdown": Convert document to structured Markdown
+   * - "freeOcr": Extract all visible text without structure
+   * - "parseFigure": Analyze charts and diagrams
+   * - "locateObject": Find specific content using reference text
+   */
+  taskType: OcrTaskType;
+  /**
+   * Resolution size for processing.
+   * Affects speed/accuracy tradeoff.
+   * Default: "gundam" (recommended)
+   */
+  resolution?: OcrResolution;
+  /**
+   * Reference text for object location tasks.
+   * Only used when taskType is "locateObject".
+   */
+  referenceText?: string;
+};
+/**
+ * Result of an OCR operation.
+ */
+type OcrResult = {
+  /**
+   * The extracted text content.
+   */
+  extractedText: string;
+  /**
+   * Format of the extracted text.
+   * - "markdown": Structured markdown format
+   * - "plain": Unstructured plain text
+   * - "structured": Structured analysis (for figures)
+   */
+  format: "markdown" | "plain" | "structured";
+  /**
+   * Confidence score (0-1) if provided by the service.
+   */
+  confidence?: number;
+};
+/**
+ * Shape definition for the Document AI Plugin interface.
+ * Defines the contract that all document AI implementations must follow.
+ */
+type DocumentAiPluginShape = {
+  /**
+   * Performs OCR on a document image or scanned PDF using AI.
+   *
+   * @param inputUrl - The URL of the input document/image to process
+   * @param params - OCR parameters including task type and resolution
+   * @param context - Context information including client ID for tracking
+   * @returns An Effect that resolves to OcrResult with extracted text
+   * @throws {UploadistaError} When OCR operation fails
+   */
+  performOCR: (inputUrl: string, params: OcrParams, context: DocumentAiContext) => Effect.Effect<OcrResult, UploadistaError>;
+};
+declare const DocumentAiPlugin_base: Context.TagClass<DocumentAiPlugin, "DocumentAiPlugin", DocumentAiPluginShape>;
+/**
+ * Context tag for the Document AI Plugin.
+ *
+ * This tag provides a type-safe way to access document AI functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { DocumentAiPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const documentAi = yield* DocumentAiPlugin;
+ *   const result = yield* documentAi.performOCR(
+ *     documentUrl,
+ *     { taskType: "convertToMarkdown", resolution: "gundam" },
+ *     { clientId: "user123" }
+ *   );
+ *   return result.extractedText;
+ * });
+ * ```
+ */
+declare class DocumentAiPlugin extends DocumentAiPlugin_base {}
+type DocumentAiPluginLayer = Layer.Layer<DocumentAiPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/document-plugin.d.ts
+/**
+ * Parameters for splitting a PDF document.
+ */
+type SplitPdfParams = {
+  /**
+   * Mode of split operation.
+   * - "range": Extract a contiguous range of pages
+   * - "individual": Split into individual single-page PDFs
+   */
+  mode: "range" | "individual";
+  /**
+   * Starting page number (1-indexed).
+   * Only used in "range" mode.
+   */
+  startPage?: number;
+  /**
+   * Ending page number (1-indexed, inclusive).
+   * Only used in "range" mode.
+   */
+  endPage?: number;
+};
+/**
+ * Result of a split PDF operation.
+ * In "range" mode, returns a single PDF.
+ * In "individual" mode, returns an array of single-page PDFs.
+ */
+type SplitPdfResult = {
+  mode: "range";
+  pdf: Uint8Array;
+} | {
+  mode: "individual";
+  pdfs: Uint8Array[];
+};
+/**
+ * Parameters for merging multiple PDF documents.
+ */
+type MergePdfParams = {
+  /**
+   * Array of PDF documents to merge (in order).
+   */
+  pdfs: Uint8Array[];
+};
+/**
+ * Metadata extracted from a PDF document.
+ */
+type DocumentMetadata = {
+  /**
+   * Total number of pages in the document.
+   */
+  pageCount: number;
+  /**
+   * Document format (e.g., "pdf").
+   */
+  format: string;
+  /**
+   * Author of the document (if available).
+   */
+  author: string | null;
+  /**
+   * Title of the document (if available).
+   */
+  title: string | null;
+  /**
+   * Subject of the document (if available).
+   */
+  subject: string | null;
+  /**
+   * Creator application (if available).
+   */
+  creator: string | null;
+  /**
+   * Creation date in ISO 8601 format (if available).
+   */
+  creationDate: string | null;
+  /**
+   * Last modification date in ISO 8601 format (if available).
+   */
+  modifiedDate: string | null;
+  /**
+   * File size in bytes.
+   */
+  fileSize: number;
+};
+/**
+ * Shape definition for the Document Plugin interface.
+ * Defines the contract that all document processing implementations must follow.
+ */
+type DocumentPluginShape = {
+  /**
+   * Extracts plain text from a searchable PDF document.
+   *
+   * @param input - The input PDF as a Uint8Array
+   * @returns An Effect that resolves to the extracted text as a string
+   * @throws {UploadistaError} When text extraction fails (e.g., PDF_ENCRYPTED, PDF_CORRUPTED)
+   */
+  extractText: (input: Uint8Array) => Effect.Effect<string, UploadistaError>;
+  /**
+   * Splits a PDF document by page range or into individual pages.
+   *
+   * @param input - The input PDF as a Uint8Array
+   * @param options - Split parameters including mode and page range
+   * @returns An Effect that resolves to either a single PDF or array of PDFs
+   * @throws {UploadistaError} When splitting fails (e.g., PAGE_RANGE_INVALID)
+   */
+  splitPdf: (input: Uint8Array, options: SplitPdfParams) => Effect.Effect<SplitPdfResult, UploadistaError>;
+  /**
+   * Merges multiple PDF documents into a single document.
+   *
+   * @param options - Merge parameters including array of PDFs to merge
+   * @returns An Effect that resolves to the merged PDF as a Uint8Array
+   * @throws {UploadistaError} When merging fails
+   */
+  mergePdfs: (options: MergePdfParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Extracts metadata from a PDF document.
+   *
+   * @param input - The input PDF as a Uint8Array
+   * @returns An Effect that resolves to DocumentMetadata with comprehensive document information
+   * @throws {UploadistaError} When metadata extraction fails
+   */
+  getMetadata: (input: Uint8Array) => Effect.Effect<DocumentMetadata, UploadistaError>;
+};
+declare const DocumentPlugin_base: Context.TagClass<DocumentPlugin, "DocumentPlugin", DocumentPluginShape>;
+/**
+ * Context tag for the Document Plugin.
+ *
+ * This tag provides a type-safe way to access document processing functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { DocumentPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const documentPlugin = yield* DocumentPlugin;
+ *   const text = yield* documentPlugin.extractText(pdfData);
+ *   const metadata = yield* documentPlugin.getMetadata(pdfData);
+ *   return { text, metadata };
+ * });
+ * ```
+ */
+declare class DocumentPlugin extends DocumentPlugin_base {}
+type DocumentPluginLayer = Layer.Layer<DocumentPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/image-ai-plugin.d.ts
+/**
+ * Context information for AI image processing operations.
+ * Contains client identification for tracking and billing purposes.
+ */
+type ImageAiContext = {
+  /** Unique identifier for the client making the request, or null if not available */clientId: string | null;
+};
+/**
+ * Shape definition for the Image AI Plugin interface.
+ * Defines the contract that all image AI implementations must follow.
+ */
+type ImageAiPluginShape = {
+  /**
+   * Removes the background from an image using AI processing.
+   *
+   * @param inputUrl - The URL of the input image to process
+   * @param context - Context information including client ID for tracking
+   * @returns An Effect that resolves to an object containing the output image URL
+   * @throws {UploadistaError} When the background removal fails
+   */
+  removeBackground: (inputUrl: string, context: ImageAiContext) => Effect.Effect<{
+    outputUrl: string;
+  }, UploadistaError>;
+  /**
+   * Generates a textual description of an image using AI analysis.
+   *
+   * @param inputUrl - The URL of the input image to analyze
+   * @param context - Context information including client ID for tracking
+   * @returns An Effect that resolves to an object containing the image description
+   * @throws {UploadistaError} When the image analysis fails
+   */
+  describeImage: (inputUrl: string, context: ImageAiContext) => Effect.Effect<{
+    description: string;
+  }, UploadistaError>;
+};
+declare const ImageAiPlugin_base: Context.TagClass<ImageAiPlugin, "ImageAiPlugin", ImageAiPluginShape>;
+/**
+ * Context tag for the Image AI Plugin.
+ *
+ * This tag provides a type-safe way to access image AI functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { ImageAiPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const imageAi = yield* ImageAiPlugin;
+ *   const result = yield* imageAi.removeBackground(imageUrl, { clientId: "user123" });
+ *   return result.outputUrl;
+ * });
+ * ```
+ */
+declare class ImageAiPlugin extends ImageAiPlugin_base {}
+type ImageAiPluginLayer = Layer.Layer<ImageAiPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/types/optimize-node.d.ts
+/**
+ * Zod schema for validating image optimization parameters.
+ * Defines the structure and validation rules for image optimization requests.
+ */
+declare const optimizeParamsSchema: z.ZodObject<{
+  quality: z.ZodNumber;
+  format: z.ZodEnum<{
+    webp: "webp";
+    jpeg: "jpeg";
+    png: "png";
+    avif: "avif";
+  }>;
+}, z.core.$strip>;
+/**
+ * Parameters for the image optimization node.
+ * Controls quality and format settings for image optimization.
+ */
+type OptimizeParams = z.infer<typeof optimizeParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/resize-node.d.ts
+/**
+ * Zod schema for validating image resize parameters.
+ * Defines the structure and validation rules for image resizing requests.
+ * Requires at least one dimension (width or height) to be specified.
+ */
+declare const resizeParamsSchema: z.ZodObject<{
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>;
+/**
+ * Parameters for the image resize node.
+ * Controls the target dimensions and fitting behavior for image resizing.
+ */
+type ResizeParams = z.infer<typeof resizeParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/transform-image-node.d.ts
+/**
+ * Type of transformation to apply to an image.
+ */
+type TransformationType = "resize" | "blur" | "rotate" | "flip" | "grayscale" | "sepia" | "brightness" | "contrast" | "sharpen" | "watermark" | "logo" | "text";
+/**
+ * Resize transformation parameters.
+ * Resizes the image to the specified dimensions with the given fit mode.
+ */
+declare const resizeTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"resize">;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>;
+type ResizeTransform = z.infer<typeof resizeTransformSchema>;
+/**
+ * Blur transformation parameters.
+ * Applies Gaussian blur to the image.
+ */
+declare const blurTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"blur">;
+  sigma: z.ZodNumber;
+}, z.core.$strip>;
+type BlurTransform = z.infer<typeof blurTransformSchema>;
+/**
+ * Rotate transformation parameters.
+ * Rotates the image by the specified angle.
+ */
+declare const rotateTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"rotate">;
+  angle: z.ZodNumber;
+  background: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RotateTransform = z.infer<typeof rotateTransformSchema>;
+/**
+ * Flip transformation parameters.
+ * Flips the image horizontally or vertically.
+ */
+declare const flipTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"flip">;
+  direction: z.ZodEnum<{
+    horizontal: "horizontal";
+    vertical: "vertical";
+  }>;
+}, z.core.$strip>;
+type FlipTransform = z.infer<typeof flipTransformSchema>;
+/**
+ * Grayscale transformation parameters.
+ * Converts the image to grayscale.
+ */
+declare const grayscaleTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"grayscale">;
+}, z.core.$strip>;
+type GrayscaleTransform = z.infer<typeof grayscaleTransformSchema>;
+/**
+ * Sepia transformation parameters.
+ * Applies a sepia tone effect to the image.
+ */
+declare const sepiaTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sepia">;
+}, z.core.$strip>;
+type SepiaTransform = z.infer<typeof sepiaTransformSchema>;
+/**
+ * Brightness transformation parameters.
+ * Adjusts the brightness of the image.
+ */
+declare const brightnessTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"brightness">;
+  value: z.ZodNumber;
+}, z.core.$strip>;
+type BrightnessTransform = z.infer<typeof brightnessTransformSchema>;
+/**
+ * Contrast transformation parameters.
+ * Adjusts the contrast of the image.
+ */
+declare const contrastTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"contrast">;
+  value: z.ZodNumber;
+}, z.core.$strip>;
+type ContrastTransform = z.infer<typeof contrastTransformSchema>;
+/**
+ * Sharpen transformation parameters.
+ * Applies sharpening to the image.
+ */
+declare const sharpenTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"sharpen">;
+  sigma: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SharpenTransform = z.infer<typeof sharpenTransformSchema>;
+/**
+ * Position for overlays (watermarks, logos, text).
+ */
+type OverlayPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right" | "center";
+/**
+ * Watermark transformation parameters.
+ * Overlays a watermark image on the main image.
+ */
+declare const watermarkTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"watermark">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  opacity: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type WatermarkTransform = z.infer<typeof watermarkTransformSchema>;
+/**
+ * Logo transformation parameters.
+ * Overlays a logo image on the main image with scaling.
+ */
+declare const logoTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"logo">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  scale: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type LogoTransform = z.infer<typeof logoTransformSchema>;
+/**
+ * Text transformation parameters.
+ * Overlays text on the image.
+ */
+declare const textTransformSchema: z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  fontSize: z.ZodNumber;
+  color: z.ZodString;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type TextTransform = z.infer<typeof textTransformSchema>;
+/**
+ * Schema for validating any transformation type.
+ * This is a discriminated union of all transformation schemas.
+ */
+declare const transformationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"resize">;
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  fit: z.ZodEnum<{
+    fill: "fill";
+    contain: "contain";
+    cover: "cover";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"blur">;
+  sigma: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"rotate">;
+  angle: z.ZodNumber;
+  background: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"flip">;
+  direction: z.ZodEnum<{
+    horizontal: "horizontal";
+    vertical: "vertical";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"grayscale">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sepia">;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"brightness">;
+  value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"contrast">;
+  value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"sharpen">;
+  sigma: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"watermark">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  opacity: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"logo">;
+  imagePath: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  scale: z.ZodNumber;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"text">;
+  text: z.ZodString;
+  position: z.ZodEnum<{
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+    center: "center";
+  }>;
+  fontSize: z.ZodNumber;
+  color: z.ZodString;
+  fontFamily: z.ZodOptional<z.ZodString>;
+  offsetX: z.ZodOptional<z.ZodNumber>;
+  offsetY: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>], "type">;
+/**
+ * A single image transformation operation.
+ * This is a discriminated union type that can represent any transformation.
+ */
+type Transformation = z.infer<typeof transformationSchema>;
+/**
+ * Parameters for the transform image node.
+ * Contains an ordered array of transformations to apply sequentially.
+ */
+declare const transformImageParamsSchema: z.ZodObject<{
+  transformations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    fit: z.ZodEnum<{
+      fill: "fill";
+      contain: "contain";
+      cover: "cover";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"blur">;
+    sigma: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"rotate">;
+    angle: z.ZodNumber;
+    background: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"flip">;
+    direction: z.ZodEnum<{
+      horizontal: "horizontal";
+      vertical: "vertical";
+    }>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"grayscale">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sepia">;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"brightness">;
+    value: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"contrast">;
+    value: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sharpen">;
+    sigma: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"watermark">;
+    imagePath: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    opacity: z.ZodNumber;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"logo">;
+    imagePath: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    scale: z.ZodNumber;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+    position: z.ZodEnum<{
+      "top-left": "top-left";
+      "top-right": "top-right";
+      "bottom-left": "bottom-left";
+      "bottom-right": "bottom-right";
+      center: "center";
+    }>;
+    fontSize: z.ZodNumber;
+    color: z.ZodString;
+    fontFamily: z.ZodOptional<z.ZodString>;
+    offsetX: z.ZodOptional<z.ZodNumber>;
+    offsetY: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/**
+ * Parameters for the transform image node.
+ */
+type TransformImageParams = z.infer<typeof transformImageParamsSchema>;
+//#endregion
+//#region src/flow/plugins/image-plugin.d.ts
+/**
+ * Shape definition for the Image Plugin interface.
+ * Defines the contract that all image processing implementations must follow.
+ */
+type ImagePluginShape = {
+  /**
+   * Optimizes an image by adjusting quality and format.
+   *
+   * @param input - The input image as a Uint8Array
+   * @param options - Optimization parameters including quality and format
+   * @returns An Effect that resolves to the optimized image as a Uint8Array
+   * @throws {UploadistaError} When image optimization fails
+   */
+  optimize: (input: Uint8Array, options: OptimizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Resizes an image to specified dimensions.
+   *
+   * @param input - The input image as a Uint8Array
+   * @param options - Resize parameters including width, height, and fit mode
+   * @returns An Effect that resolves to the resized image as a Uint8Array
+   * @throws {UploadistaError} When image resizing fails
+   */
+  resize: (input: Uint8Array, options: ResizeParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Applies a single transformation to an image.
+   *
+   * This method is used by the transform image node to apply individual transformations
+   * in a chain. Each transformation receives the output of the previous transformation.
+   *
+   * @param input - The input image as a Uint8Array
+   * @param transformation - The transformation to apply (discriminated union)
+   * @returns An Effect that resolves to the transformed image as a Uint8Array
+   * @throws {UploadistaError} When transformation fails or is unsupported by the plugin
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const imagePlugin = yield* ImagePlugin;
+   *
+   *   // Apply a single transformation
+   *   const blurred = yield* imagePlugin.transform(imageData, {
+   *     type: 'blur',
+   *     sigma: 5.0
+   *   });
+   *
+   *   // Chain multiple transformations
+   *   const resized = yield* imagePlugin.transform(blurred, {
+   *     type: 'resize',
+   *     width: 800,
+   *     height: 600,
+   *     fit: 'cover'
+   *   });
+   *
+   *   return resized;
+   * });
+   * ```
+   */
+  transform: (input: Uint8Array, transformation: Transformation) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Optimizes an image using streaming for memory-efficient processing of large files.
+   *
+   * This method processes image data as a stream, which is beneficial for large images
+   * where loading the entire file into memory would be problematic.
+   *
+   * Note: Image processing inherently requires decoding the full image, so memory
+   * savings are primarily from avoiding double-buffering. The streaming interface
+   * allows better pipeline integration with DataStore streaming reads.
+   *
+   * @param input - The input image as an Effect Stream of Uint8Array chunks
+   * @param options - Optimization parameters including quality and format
+   * @returns An Effect that resolves to a Stream of the optimized image bytes
+   * @throws {UploadistaError} When image optimization fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const imagePlugin = yield* ImagePlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* imagePlugin.optimizeStream(inputStream, {
+   *     quality: 80,
+   *     format: "webp"
+   *   });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  optimizeStream?: (input: Stream.Stream<Uint8Array, UploadistaError>, options: OptimizeParams) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Resizes an image using streaming for memory-efficient processing of large files.
+   *
+   * This method processes image data as a stream. Like other image operations,
+   * the full image must be decoded before processing, but the streaming interface
+   * avoids double-buffering when combined with streaming DataStore reads and writes.
+   *
+   * @param input - The input image as an Effect Stream of Uint8Array chunks
+   * @param options - Resize parameters including width, height, and fit mode
+   * @returns An Effect that resolves to a Stream of the resized image bytes
+   * @throws {UploadistaError} When image resizing fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const imagePlugin = yield* ImagePlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* imagePlugin.resizeStream(inputStream, {
+   *     width: 800,
+   *     height: 600,
+   *     fit: "cover"
+   *   });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  resizeStream?: (input: Stream.Stream<Uint8Array, UploadistaError>, options: ResizeParams) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Applies a single transformation using streaming for memory-efficient processing.
+   *
+   * This method processes image data as a stream. The streaming interface
+   * allows better pipeline integration with DataStore streaming reads and writes,
+   * reducing peak memory usage for large files.
+   *
+   * @param input - The input image as an Effect Stream of Uint8Array chunks
+   * @param transformation - The transformation to apply
+   * @returns An Effect that resolves to a Stream of the transformed image bytes
+   * @throws {UploadistaError} When transformation fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const imagePlugin = yield* ImagePlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* imagePlugin.transformStream(inputStream, {
+   *     type: 'blur',
+   *     sigma: 5.0
+   *   });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  transformStream?: (input: Stream.Stream<Uint8Array, UploadistaError>, transformation: Transformation) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Indicates whether this plugin supports streaming operations.
+   * Returns true if streaming methods (optimizeStream, resizeStream, transformStream) are available.
+   */
+  supportsStreaming?: boolean;
+};
+declare const ImagePlugin_base: Context.TagClass<ImagePlugin, "ImagePlugin", ImagePluginShape>;
+/**
+ * Context tag for the Image Plugin.
+ *
+ * This tag provides a type-safe way to access image processing functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { ImagePlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const imagePlugin = yield* ImagePlugin;
+ *   const optimized = yield* imagePlugin.optimize(imageData, { quality: 80, format: "webp" });
+ *   const resized = yield* imagePlugin.resize(optimized, { width: 800, height: 600, fit: "cover" });
+ *   return resized;
+ * });
+ * ```
+ */
+declare class ImagePlugin extends ImagePlugin_base {}
+type ImagePluginLayer = Layer.Layer<ImagePlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/types/describe-video-node.d.ts
+/**
+ * Zod schema for video metadata extracted by the describe operation.
+ * Defines the structure and validation rules for video metadata.
+ */
+declare const describeVideoMetadataSchema: z.ZodObject<{
+  duration: z.ZodNumber;
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+  codec: z.ZodString;
+  format: z.ZodString;
+  bitrate: z.ZodNumber;
+  frameRate: z.ZodNumber;
+  aspectRatio: z.ZodString;
+  hasAudio: z.ZodBoolean;
+  audioCodec: z.ZodOptional<z.ZodString>;
+  audioBitrate: z.ZodOptional<z.ZodNumber>;
+  size: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Video metadata extracted by the describe operation.
+ * Contains comprehensive information about video properties, codecs, and audio.
+ */
+type DescribeVideoMetadata = z.infer<typeof describeVideoMetadataSchema>;
+//#endregion
+//#region src/flow/plugins/types/extract-frame-video-node.d.ts
+/**
+ * Zod schema for validating video frame extraction parameters.
+ * Defines the structure and validation rules for extracting a single frame from video.
+ */
+declare const extractFrameVideoParamsSchema: z.ZodObject<{
+  timestamp: z.ZodNumber;
+  format: z.ZodOptional<z.ZodEnum<{
+    jpeg: "jpeg";
+    png: "png";
+  }>>;
+  quality: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Parameters for the video frame extraction node.
+ * Controls the timestamp and output format for extracting a single frame from video.
+ */
+type ExtractFrameVideoParams = z.infer<typeof extractFrameVideoParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/resize-video-node.d.ts
+/**
+ * Zod schema for validating video resize parameters.
+ * Defines the structure and validation rules for video resolution changes.
+ * Requires at least one dimension (width or height) to be specified.
+ */
+declare const resizeVideoParamsSchema: z.ZodObject<{
+  width: z.ZodOptional<z.ZodNumber>;
+  height: z.ZodOptional<z.ZodNumber>;
+  aspectRatio: z.ZodOptional<z.ZodEnum<{
+    keep: "keep";
+    ignore: "ignore";
+  }>>;
+  scaling: z.ZodOptional<z.ZodEnum<{
+    bicubic: "bicubic";
+    bilinear: "bilinear";
+    lanczos: "lanczos";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the video resize node.
+ * Controls the target dimensions and aspect ratio handling for video resizing.
+ */
+type ResizeVideoParams = z.infer<typeof resizeVideoParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/transcode-video-node.d.ts
+/**
+ * Zod schema for validating video transcode parameters.
+ * Defines the structure and validation rules for video format and codec conversion.
+ */
+declare const transcodeVideoParamsSchema: z.ZodObject<{
+  format: z.ZodEnum<{
+    mp4: "mp4";
+    webm: "webm";
+    mov: "mov";
+    avi: "avi";
+  }>;
+  codec: z.ZodOptional<z.ZodEnum<{
+    h264: "h264";
+    h265: "h265";
+    vp9: "vp9";
+    av1: "av1";
+  }>>;
+  videoBitrate: z.ZodOptional<z.ZodString>;
+  audioBitrate: z.ZodOptional<z.ZodString>;
+  audioCodec: z.ZodOptional<z.ZodEnum<{
+    aac: "aac";
+    mp3: "mp3";
+    opus: "opus";
+    vorbis: "vorbis";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the video transcode node.
+ * Controls output format, codecs, and quality settings for video transcoding.
+ */
+type TranscodeVideoParams = z.infer<typeof transcodeVideoParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/trim-video-node.d.ts
+/**
+ * Zod schema for validating video trim parameters.
+ * Defines the structure and validation rules for extracting video segments.
+ */
+declare const trimVideoParamsSchema: z.ZodObject<{
+  startTime: z.ZodNumber;
+  endTime: z.ZodOptional<z.ZodNumber>;
+  duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Parameters for the video trim node.
+ * Controls the time range for extracting video segments.
+ */
+type TrimVideoParams = z.infer<typeof trimVideoParamsSchema>;
+//#endregion
+//#region src/flow/plugins/video-plugin.d.ts
+/**
+ * Input type for streaming video operations.
+ * Accepts either buffered input (Uint8Array) or streaming input (Effect Stream).
+ * Streaming input is only supported for specific formats like MPEG-TS.
+ */
+type VideoStreamInput = Uint8Array | Stream.Stream<Uint8Array, UploadistaError>;
+/**
+ * Options for streaming video operations.
+ */
+type VideoStreamOptions = {
+  /**
+   * Hint for input format to help determine if streaming input is possible.
+   * MPEG-TS format supports true streaming input; other formats require buffering.
+   */
+  inputFormat?: string;
+};
+/**
+ * Shape definition for the Video Plugin interface.
+ * Defines the contract that all video processing implementations must follow.
+ */
+type VideoPluginShape = {
+  /**
+   * Transcodes a video to a different format/codec.
+   *
+   * @param input - The input video as a Uint8Array
+   * @param options - Transcode parameters including format, codec, and bitrates
+   * @returns An Effect that resolves to the transcoded video as a Uint8Array
+   * @throws {UploadistaError} When video transcoding fails
+   */
+  transcode: (input: Uint8Array, options: TranscodeVideoParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Resizes a video to specified dimensions.
+   *
+   * @param input - The input video as a Uint8Array
+   * @param options - Resize parameters including width, height, and aspect ratio handling
+   * @returns An Effect that resolves to the resized video as a Uint8Array
+   * @throws {UploadistaError} When video resizing fails
+   */
+  resize: (input: Uint8Array, options: ResizeVideoParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Trims a video to extract a segment by time range.
+   *
+   * @param input - The input video as a Uint8Array
+   * @param options - Trim parameters including start time and end time/duration
+   * @returns An Effect that resolves to the trimmed video as a Uint8Array
+   * @throws {UploadistaError} When video trimming fails
+   */
+  trim: (input: Uint8Array, options: TrimVideoParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Extracts a single frame from the video at a specific timestamp.
+   *
+   * @param input - The input video as a Uint8Array
+   * @param options - Frame extraction parameters including timestamp and format
+   * @returns An Effect that resolves to the extracted frame as a Uint8Array (image)
+   * @throws {UploadistaError} When frame extraction fails
+   */
+  extractFrame: (input: Uint8Array, options: ExtractFrameVideoParams) => Effect.Effect<Uint8Array, UploadistaError>;
+  /**
+   * Extracts metadata from a video file.
+   *
+   * @param input - The input video as a Uint8Array
+   * @returns An Effect that resolves to VideoMetadata with comprehensive video information
+   * @throws {UploadistaError} When metadata extraction fails
+   */
+  describe: (input: Uint8Array) => Effect.Effect<DescribeVideoMetadata, UploadistaError>;
+  /**
+   * Transcodes a video using streaming for memory-efficient processing of large files.
+   *
+   * This method outputs the transcoded video as a stream, reducing peak memory usage.
+   * For input, it accepts either a buffered Uint8Array or a Stream. Streaming input
+   * is only supported for MPEG-TS format; other formats will be buffered internally.
+   *
+   * @param input - The input video as Uint8Array or Stream (MPEG-TS only for streaming)
+   * @param options - Transcode parameters including format, codec, and bitrates
+   * @param streamOptions - Optional streaming configuration including input format hint
+   * @returns An Effect that resolves to a Stream of the transcoded video bytes
+   * @throws {UploadistaError} When video transcoding fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const videoPlugin = yield* VideoPlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* videoPlugin.transcodeStream(inputStream, {
+   *     format: "mp4",
+   *     codec: "h264"
+   *   }, { inputFormat: "video/mp2t" });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  transcodeStream?: (input: VideoStreamInput, options: TranscodeVideoParams, streamOptions?: VideoStreamOptions) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Resizes a video using streaming for memory-efficient processing of large files.
+   *
+   * This method outputs the resized video as a stream, reducing peak memory usage.
+   * For input, it accepts either a buffered Uint8Array or a Stream. Streaming input
+   * is only supported for MPEG-TS format; other formats will be buffered internally.
+   *
+   * @param input - The input video as Uint8Array or Stream (MPEG-TS only for streaming)
+   * @param options - Resize parameters including width, height, and aspect ratio
+   * @param streamOptions - Optional streaming configuration including input format hint
+   * @returns An Effect that resolves to a Stream of the resized video bytes
+   * @throws {UploadistaError} When video resizing fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const videoPlugin = yield* VideoPlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* videoPlugin.resizeStream(inputStream, {
+   *     width: 1280,
+   *     height: 720,
+   *     aspectRatio: "keep"
+   *   });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  resizeStream?: (input: VideoStreamInput, options: ResizeVideoParams, streamOptions?: VideoStreamOptions) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Trims a video using streaming for memory-efficient processing of large files.
+   *
+   * This method outputs the trimmed video as a stream, reducing peak memory usage.
+   * For input, it accepts either a buffered Uint8Array or a Stream. Streaming input
+   * is only supported for MPEG-TS format; other formats will be buffered internally.
+   *
+   * @param input - The input video as Uint8Array or Stream (MPEG-TS only for streaming)
+   * @param options - Trim parameters including start time and end time/duration
+   * @param streamOptions - Optional streaming configuration including input format hint
+   * @returns An Effect that resolves to a Stream of the trimmed video bytes
+   * @throws {UploadistaError} When video trimming fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const videoPlugin = yield* VideoPlugin;
+   *   const inputStream = yield* dataStore.readStream(fileId);
+   *   const outputStream = yield* videoPlugin.trimStream(inputStream, {
+   *     startTime: 10,
+   *     endTime: 30
+   *   });
+   *   return outputStream;
+   * });
+   * ```
+   */
+  trimStream?: (input: VideoStreamInput, options: TrimVideoParams, streamOptions?: VideoStreamOptions) => Effect.Effect<Stream.Stream<Uint8Array, UploadistaError>, UploadistaError>;
+  /**
+   * Indicates whether this plugin supports streaming operations.
+   * Returns true if streaming methods are available and functional.
+   */
+  supportsStreaming?: boolean;
+};
+declare const VideoPlugin_base: Context.TagClass<VideoPlugin, "VideoPlugin", VideoPluginShape>;
+/**
+ * Context tag for the Video Plugin.
+ *
+ * This tag provides a type-safe way to access video processing functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { VideoPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const videoPlugin = yield* VideoPlugin;
+ *   const transcoded = yield* videoPlugin.transcode(videoData, { format: "webm", codec: "vp9" });
+ *   const resized = yield* videoPlugin.resize(transcoded, { width: 1280, height: 720, aspectRatio: "keep" });
+ *   return resized;
+ * });
+ * ```
+ */
+declare class VideoPlugin extends VideoPlugin_base {}
+type VideoPluginLayer = Layer.Layer<VideoPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/virus-scan-plugin.d.ts
+/**
+ * Result of a virus scan operation.
+ */
+type ScanResult = {
+  /**
+   * Whether the file is clean (no viruses detected)
+   */
+  isClean: boolean;
+  /**
+   * Array of detected virus/malware names (empty if clean)
+   */
+  detectedViruses: string[];
+};
+/**
+ * Comprehensive metadata about a virus scan operation.
+ */
+type ScanMetadata = {
+  /**
+   * Whether the file was scanned
+   */
+  scanned: boolean;
+  /**
+   * Whether the file is clean (no viruses detected)
+   */
+  isClean: boolean;
+  /**
+   * Array of detected virus/malware names (empty if clean)
+   */
+  detectedViruses: string[];
+  /**
+   * ISO 8601 timestamp of when the scan was performed
+   */
+  scanDate: string;
+  /**
+   * Version of the antivirus engine used
+   */
+  engineVersion: string;
+  /**
+   * ISO 8601 timestamp of when virus definitions were last updated
+   */
+  definitionsDate: string;
+};
+/**
+ * Shape definition for the Virus Scan Plugin interface.
+ * Defines the contract that all virus scanning implementations must follow.
+ */
+type VirusScanPluginShape = {
+  /**
+   * Scans a file for viruses and malware.
+   *
+   * @param input - The input file as a Uint8Array
+   * @returns An Effect that resolves to ScanResult with detection information
+   * @throws {UploadistaError} When virus scanning fails or ClamAV is unavailable
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const virusScanPlugin = yield* VirusScanPlugin;
+   *   const result = yield* virusScanPlugin.scan(fileData);
+   *   if (!result.isClean) {
+   *     console.log('Viruses detected:', result.detectedViruses);
+   *   }
+   * });
+   * ```
+   */
+  scan: (input: Uint8Array) => Effect.Effect<ScanResult, UploadistaError>;
+  /**
+   * Retrieves the version of the antivirus engine.
+   *
+   * @returns An Effect that resolves to the engine version string
+   * @throws {UploadistaError} When version retrieval fails
+   *
+   * @example
+   * ```typescript
+   * const program = Effect.gen(function* () {
+   *   const virusScanPlugin = yield* VirusScanPlugin;
+   *   const version = yield* virusScanPlugin.getVersion();
+   *   console.log('ClamAV version:', version);
+   * });
+   * ```
+   */
+  getVersion: () => Effect.Effect<string, UploadistaError>;
+};
+declare const VirusScanPlugin_base: Context.TagClass<VirusScanPlugin, "VirusScanPlugin", VirusScanPluginShape>;
+/**
+ * Context tag for the Virus Scan Plugin.
+ *
+ * This tag provides a type-safe way to access virus scanning functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { VirusScanPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const virusScanPlugin = yield* VirusScanPlugin;
+ *   const result = yield* virusScanPlugin.scan(fileData);
+ *
+ *   if (!result.isClean) {
+ *     // Handle infected file
+ *     return Effect.fail(new UploadistaError({
+ *       code: "VIRUS_DETECTED",
+ *       message: `Viruses detected: ${result.detectedViruses.join(', ')}`
+ *     }));
+ *   }
+ *
+ *   return fileData;
+ * });
+ * ```
+ */
+declare class VirusScanPlugin extends VirusScanPlugin_base {}
+type VirusScanPluginLayer = Layer.Layer<VirusScanPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/zip-plugin.d.ts
+/**
+ * Parameters for creating a ZIP archive.
+ */
+type ZipParams = {
+  /** Name of the ZIP file to create */zipName: string; /** Whether to include file metadata in the ZIP archive */
+  includeMetadata: boolean;
+};
+/**
+ * Input data structure for ZIP operations.
+ * Represents a single file to be included in the ZIP archive.
+ */
+type ZipInput = {
+  /** Unique identifier for the file */id: string; /** Binary data of the file */
+  data: Uint8Array; /** File metadata including name, size, type, etc. */
+  metadata: UploadFile["metadata"];
+};
+/**
+ * Shape definition for the ZIP Plugin interface.
+ * Defines the contract that all ZIP implementations must follow.
+ */
+type ZipPluginShape = {
+  /**
+   * Creates a ZIP archive from multiple input files.
+   *
+   * @param inputs - Array of files to include in the ZIP archive
+   * @param options - Configuration options for the ZIP creation
+   * @returns An Effect that resolves to the ZIP file as a Uint8Array
+   * @throws {UploadistaError} When ZIP creation fails
+   */
+  zip: (inputs: ZipInput[], options: ZipParams) => Effect.Effect<Uint8Array, UploadistaError>;
+};
+declare const ZipPlugin_base: Context.TagClass<ZipPlugin, "ZipPlugin", ZipPluginShape>;
+/**
+ * Context tag for the ZIP Plugin.
+ *
+ * This tag provides a type-safe way to access ZIP functionality
+ * throughout the application using Effect's dependency injection system.
+ *
+ * @example
+ * ```typescript
+ * import { ZipPlugin } from "@uploadista/core/flow/plugins";
+ *
+ * // In your flow node
+ * const program = Effect.gen(function* () {
+ *   const zipPlugin = yield* ZipPlugin;
+ *   const zipData = yield* zipPlugin.zip(files, { zipName: "archive.zip", includeMetadata: true });
+ *   return zipData;
+ * });
+ * ```
+ */
+declare class ZipPlugin extends ZipPlugin_base {}
+type ZipPluginLayer = Layer.Layer<ZipPlugin, never, never>;
+//#endregion
+//#region src/flow/plugins/plugins.d.ts
+type Plugin = ImagePlugin | ImageAiPlugin | VideoPlugin | DocumentPlugin | DocumentAiPlugin | VirusScanPlugin | CredentialProvider | ZipPlugin;
+type PluginLayer = ImagePluginLayer | ImageAiPluginLayer | VideoPluginLayer | DocumentPluginLayer | DocumentAiPluginLayer | VirusScanPluginLayer | CredentialProviderLayer | ZipPluginLayer;
+//#endregion
+//#region src/flow/plugins/types/describe-image-node.d.ts
+/**
+ * Zod schema for validating describe image node parameters.
+ * Defines the structure and validation rules for image description requests.
+ */
+declare const describeImageParamsSchema: z.ZodObject<{
+  serviceType: z.ZodOptional<z.ZodEnum<{
+    replicate: "replicate";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the describe image node.
+ * Controls which AI service to use for generating image descriptions.
+ */
+type DescribeImageParams = z.infer<typeof describeImageParamsSchema>;
+//#endregion
+//#region src/flow/plugins/types/remove-background-node.d.ts
+/**
+ * Zod schema for validating remove background node parameters.
+ * Defines the structure and validation rules for background removal requests.
+ */
+declare const removeBackgroundParamsSchema: z.ZodObject<{
+  serviceType: z.ZodOptional<z.ZodEnum<{
+    replicate: "replicate";
+  }>>;
+}, z.core.$strip>;
+/**
+ * Parameters for the remove background node.
+ * Controls which AI service to use for background removal processing.
+ */
+type RemoveBackgroundParams = z.infer<typeof removeBackgroundParamsSchema>;
+//#endregion
+//#region src/flow/type-guards.d.ts
+/**
+ * A narrowed typed output with a specific node type and data type.
+ * Unlike TypedOutput<T>, this type has a required nodeType field and
+ * excludes BuiltInTypedOutput from the union, providing better type narrowing.
+ *
+ * @template T - The TypeScript type of the output data
+ * @template TNodeType - The literal string type of the node type ID
+ */
+type NarrowedTypedOutput<T, TNodeType extends string = string> = {
+  nodeType: TNodeType;
+  data: T;
+  nodeId: string;
+  timestamp: string;
+};
+/**
+ * Factory function to create type guards for specific node types.
+ *
+ * Creates a TypeScript type guard that validates both the type tag and
+ * the data structure against the registered schema. This enables type-safe
+ * narrowing of TypedOutput objects in TypeScript.
+ *
+ * @template T - The expected TypeScript type after narrowing
+ * @template TNodeType - The literal string type of the node type ID
+ * @param typeId - The registered type ID to check against (e.g., "storage-output-v1")
+ * @returns A type guard function that narrows TypedOutput to NarrowedTypedOutput<T, TNodeType>
+ *
+ * @example
+ * ```typescript
+ * import { createTypeGuard } from "@uploadista/core/flow";
+ * import { z } from "zod";
+ *
+ * const descriptionSchema = z.object({
+ *   description: z.string(),
+ *   confidence: z.number(),
+ * });
+ *
+ * type DescriptionOutput = z.infer<typeof descriptionSchema>;
+ *
+ * const isDescriptionOutput = createTypeGuard<DescriptionOutput>(
+ *   "description-output-v1"
+ * );
+ *
+ * // Use in code
+ * if (isDescriptionOutput(output)) {
+ *   // output.data is typed as DescriptionOutput
+ *   console.log(output.data.description);
+ * }
+ * ```
+ */
+declare function createTypeGuard<T, TNodeType extends string = string>(typeId: TNodeType): (output: TypedOutput) => output is NarrowedTypedOutput<T, TNodeType>;
+/**
+ * Type guard for UploadFile objects.
+ *
+ * Validates that a value is a valid UploadFile by checking its structure against the schema.
+ * This is useful for determining if a node result is an UploadFile, which affects
+ * auto-persistence and intermediate file tracking.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid UploadFile
+ *
+ * @example
+ * ```typescript
+ * import { isUploadFile } from "@uploadista/core/flow";
+ *
+ * if (isUploadFile(nodeResult)) {
+ *   // nodeResult is typed as UploadFile
+ *   console.log("File ID:", nodeResult.id);
+ *   console.log("Storage:", nodeResult.storage.id);
+ * }
+ * ```
+ */
+declare function isUploadFile(value: unknown): value is UploadFile;
+/**
+ * Type guard for storage output nodes.
+ *
+ * Validates that an output is from a storage node and contains valid UploadFile data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is a storage output with valid UploadFile data
+ *
+ * @example
+ * ```typescript
+ * import { isStorageOutput } from "@uploadista/core/flow";
+ *
+ * if (isStorageOutput(output)) {
+ *   // output.data is typed as UploadFile
+ *   console.log("File URL:", output.data.url);
+ *   console.log("File size:", output.data.size);
+ * }
+ * ```
+ */
+declare const isStorageOutput: (output: TypedOutput) => output is NarrowedTypedOutput<UploadFile, string>;
+/**
+ * Type guard for OCR output nodes.
+ *
+ * Validates that an output is from an OCR node and contains valid structured OCR data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is an OCR output with valid structured text data
+ *
+ * @example
+ * ```typescript
+ * import { isOcrOutput } from "@uploadista/core/flow";
+ *
+ * if (isOcrOutput(output)) {
+ *   // output.data is typed as OcrOutput
+ *   console.log("Extracted text:", output.data.extractedText);
+ *   console.log("Format:", output.data.format);
+ *   console.log("Task type:", output.data.taskType);
+ * }
+ * ```
+ */
+declare const isOcrOutput: (output: TypedOutput) => output is NarrowedTypedOutput<{
+  extractedText: string;
+  format: "markdown" | "plain" | "structured";
+  taskType: "convertToMarkdown" | "freeOcr" | "parseFigure" | "locateObject";
+  confidence?: number | undefined;
+}, string>;
+/**
+ * Type guard for image description output nodes.
+ *
+ * Validates that an output is from an image description node and contains valid description data.
+ *
+ * @param output - The output to check
+ * @returns True if the output is an image description output with valid description data
+ *
+ * @example
+ * ```typescript
+ * import { isImageDescriptionOutput } from "@uploadista/core/flow";
+ *
+ * if (isImageDescriptionOutput(output)) {
+ *   // output.data is typed as ImageDescriptionOutput
+ *   console.log("Description:", output.data.description);
+ *   console.log("Confidence:", output.data.confidence);
+ * }
+ * ```
+ */
+declare const isImageDescriptionOutput: (output: TypedOutput) => output is NarrowedTypedOutput<{
+  description: string;
+  confidence?: number | undefined;
+  metadata?: Record<string, unknown> | undefined;
+}, string>;
+/**
+ * Filter an array of outputs to only those matching a specific type.
+ *
+ * This helper function filters outputs using a type guard and returns a
+ * properly typed array of results. It's useful for extracting specific
+ * output types from multi-output flows.
+ *
+ * @template TOutput - The expected narrowed output type
+ * @param outputs - Array of typed outputs to filter
+ * @param typeGuard - Type guard function to use for filtering
+ * @returns Array of outputs that match the type guard, properly typed
+ *
+ * @example
+ * ```typescript
+ * import { filterOutputsByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * // Get all storage outputs from a multi-output flow
+ * const storageOutputs = filterOutputsByType(
+ *   flowResult.outputs,
+ *   isStorageOutput
+ * );
+ *
+ * for (const output of storageOutputs) {
+ *   // Each output.data is typed as UploadFile
+ *   console.log("Saved file:", output.data.url);
+ * }
+ * ```
+ */
+declare function filterOutputsByType<TOutput extends TypedOutput>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TOutput): TOutput[];
+/**
+ * Get a single output of a specific type from an array of outputs.
+ *
+ * This helper function finds exactly one output matching the type guard.
+ * It throws an error if no outputs match or if multiple outputs match,
+ * ensuring the caller receives exactly the expected result.
+ *
+ * @template TOutput - The expected narrowed output type
+ * @param outputs - Array of typed outputs to search
+ * @param typeGuard - Type guard function to use for matching
+ * @returns The single matching output, properly typed
+ * @throws {UploadistaError} If no outputs match (OUTPUT_NOT_FOUND)
+ * @throws {UploadistaError} If multiple outputs match (MULTIPLE_OUTPUTS_FOUND)
+ *
+ * @example
+ * ```typescript
+ * import { getSingleOutputByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * try {
+ *   const storageOutput = getSingleOutputByType(
+ *     flowResult.outputs,
+ *     isStorageOutput
+ *   );
+ *   // storageOutput.data is typed as UploadFile
+ *   console.log("File saved at:", storageOutput.data.url);
+ * } catch (error) {
+ *   if (error.code === "OUTPUT_NOT_FOUND") {
+ *     console.error("No storage output found");
+ *   } else if (error.code === "MULTIPLE_OUTPUTS_FOUND") {
+ *     console.error("Multiple storage outputs found, expected one");
+ *   }
+ * }
+ * ```
+ */
+declare function getSingleOutputByType<TOutput extends TypedOutput>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TOutput): Effect.Effect<TOutput, UploadistaError>;
+/**
+ * Get the first output of a specific type, if any exists.
+ *
+ * Unlike getSingleOutputByType, this function returns undefined if no outputs
+ * match, and returns the first match if multiple outputs exist. This is useful
+ * when you want a more lenient matching strategy.
+ *
+ * @template TOutput - The expected narrowed output type
+ * @param outputs - Array of typed outputs to search
+ * @param typeGuard - Type guard function to use for matching
+ * @returns The first matching output, or undefined if none match
+ *
+ * @example
+ * ```typescript
+ * import { getFirstOutputByType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * const storageOutput = getFirstOutputByType(
+ *   flowResult.outputs,
+ *   isStorageOutput
+ * );
+ *
+ * if (storageOutput) {
+ *   console.log("First storage output:", storageOutput.data.url);
+ * } else {
+ *   console.log("No storage outputs found");
+ * }
+ * ```
+ */
+declare function getFirstOutputByType<TOutput extends TypedOutput>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TOutput): TOutput | undefined;
+/**
+ * Get an output by its node ID.
+ *
+ * This helper finds an output produced by a specific node instance,
+ * regardless of its type. Useful when you know the specific node ID
+ * you're looking for.
+ *
+ * @param outputs - Array of typed outputs to search
+ * @param nodeId - The node ID to match
+ * @returns The output from the specified node, or undefined if not found
+ *
+ * @example
+ * ```typescript
+ * import { getOutputByNodeId } from "@uploadista/core/flow";
+ *
+ * const cdnOutput = getOutputByNodeId(flowResult.outputs, "cdn-storage");
+ * if (cdnOutput) {
+ *   console.log("CDN output:", cdnOutput.data);
+ * }
+ * ```
+ */
+declare function getOutputByNodeId(outputs: TypedOutput[], nodeId: string): TypedOutput | undefined;
+/**
+ * Check if any outputs match a specific type.
+ *
+ * Simple predicate function to check if at least one output of a given
+ * type exists in the results.
+ *
+ * @template TOutput - The expected narrowed output type
+ * @param outputs - Array of typed outputs to check
+ * @param typeGuard - Type guard function to use for checking
+ * @returns True if at least one output matches the type guard
+ *
+ * @example
+ * ```typescript
+ * import { hasOutputOfType, isStorageOutput } from "@uploadista/core/flow";
+ *
+ * if (hasOutputOfType(flowResult.outputs, isStorageOutput)) {
+ *   console.log("Flow produced at least one storage output");
+ * } else {
+ *   console.log("No storage outputs in this flow");
+ * }
+ * ```
+ */
+declare function hasOutputOfType<TOutput extends TypedOutput>(outputs: TypedOutput[], typeGuard: (output: TypedOutput) => output is TOutput): boolean;
+/**
+ * Type guard for init operation (streaming file upload initialization).
+ *
+ * Checks if the input data is an init operation that starts a streaming
+ * file upload session.
+ *
+ * @param data - Input data to check
+ * @returns True if data is an init operation
+ *
+ * @example
+ * ```typescript
+ * if (isInitOperation(inputData)) {
+ *   console.log("Storage ID:", inputData.storageId);
+ *   console.log("Metadata:", inputData.metadata);
+ * }
+ * ```
+ */
+declare function isInitOperation(data: InputData): data is Extract<InputData, {
+  operation: "init";
+}>;
+/**
+ * Type guard for finalize operation (complete streaming upload).
+ *
+ * Checks if the input data is a finalize operation that completes a
+ * previously initialized streaming upload.
+ *
+ * @param data - Input data to check
+ * @returns True if data is a finalize operation
+ *
+ * @example
+ * ```typescript
+ * if (isFinalizeOperation(inputData)) {
+ *   console.log("Upload ID:", inputData.uploadId);
+ * }
+ * ```
+ */
+declare function isFinalizeOperation(data: InputData): data is Extract<InputData, {
+  operation: "finalize";
+}>;
+/**
+ * Type guard for URL operation (direct file fetch from URL).
+ *
+ * Checks if the input data is a URL operation that fetches a file
+ * directly from an external URL.
+ *
+ * @param data - Input data to check
+ * @returns True if data is a URL operation
+ *
+ * @example
+ * ```typescript
+ * if (isUrlOperation(inputData)) {
+ *   console.log("Fetching from:", inputData.url);
+ *   console.log("Optional storage:", inputData.storageId);
+ * }
+ * ```
+ */
+declare function isUrlOperation(data: InputData): data is Extract<InputData, {
+  operation: "url";
+}>;
+/**
+ * Type guard for upload operations (init or url).
+ *
+ * Checks if the input data is either an init or URL operation (i.e., operations
+ * that trigger new uploads, as opposed to finalize which completes an existing upload).
+ *
+ * @param data - Input data to check
+ * @returns True if data is an init or URL operation
+ *
+ * @example
+ * ```typescript
+ * if (isUploadOperation(inputData)) {
+ *   // This is a new upload, not a finalization
+ *   if (isInitOperation(inputData)) {
+ *     console.log("Streaming upload");
+ *   } else {
+ *     console.log("URL fetch");
+ *   }
+ * }
+ * ```
+ */
+declare function isUploadOperation(data: InputData): data is Extract<InputData, {
+  operation: "init" | "url";
+}>;
+//#endregion
+//#region src/flow/typed-flow.d.ts
+/**
+ * Defines a node that can be used in a typed flow.
+ *
+ * A node definition can be either:
+ * - A plain FlowNode object
+ * - An Effect that resolves to a FlowNode (for nodes requiring dependencies)
+ *
+ * @template TNodeError - The error types that the node can produce
+ * @template TNodeRequirements - The services/dependencies the node requires
+ */
+type NodeDefinition<TNodeError = never, TNodeRequirements = never> = FlowNode<any, any, UploadistaError> | Effect.Effect<FlowNode<any, any, UploadistaError>, TNodeError, TNodeRequirements>;
+/**
+ * A record mapping node IDs to their definitions.
+ *
+ * This is the primary type used for defining the nodes in a typed flow,
+ * allowing TypeScript to infer input/output schemas and requirements.
+ *
+ * @example
+ * ```typescript
+ * const nodes = {
+ *   input: fileInputNode,
+ *   resize: Effect.succeed(imageResizeNode),
+ *   output: s3OutputNode
+ * } satisfies NodeDefinitionsRecord;
+ * ```
+ */
+type NodeDefinitionsRecord = Record<string, NodeDefinition<any, any>>;
+/**
+ * Extracts the error type from a NodeDefinition.
+ *
+ * If the node is an Effect, extracts its error type.
+ * If the node is a plain FlowNode, returns never (no errors).
+ */
+type NodeDefinitionError<T> = T extends Effect.Effect<FlowNode<any, any, UploadistaError>, infer TError, any> ? TError : never;
+/**
+ * Extracts the requirements (dependencies) from a NodeDefinition.
+ *
+ * Uses the shared ExtractEffectRequirements utility for consistency.
+ */
+type NodeDefinitionRequirements<T> = ExtractEffectRequirements<T>;
+/**
+ * Extracts all possible errors from all nodes in a flow as a union.
+ *
+ * This iterates through all nodes in the record and combines their
+ * error types into a single union type.
+ */
+type NodesErrorUnion<TNodes extends NodeDefinitionsRecord> = { [K in keyof TNodes]: NodeDefinitionError<TNodes[K]> }[keyof TNodes];
+/**
+ * Extracts all service requirements from all nodes in a flow as a union.
+ *
+ * This iterates through all nodes in the record and combines their
+ * requirement types into a single union type representing all services
+ * needed by the flow.
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const nodes = {
+ *   resize: imageResizeNode, // requires ImagePlugin
+ *   zip: zipNode,           // requires ZipPlugin
+ * };
+ * type Requirements = NodesRequirementsUnion<typeof nodes>;
+ * // Requirements = ImagePlugin | ZipPlugin
+ * ```
+ */
+type NodesRequirementsUnion<TNodes extends NodeDefinitionsRecord> = { [K in keyof TNodes]: NodeDefinitionRequirements<TNodes[K]> }[keyof TNodes];
+/**
+ * Extracts all service requirements from a flow's nodes.
+ *
+ * This includes all services required by any node in the flow,
+ * including UploadEngine (which is provided by the runtime).
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     input: fileInputNode,
+ *     process: imageProcessNode, // requires ImagePlugin
+ *   },
+ *   edges: [...]
+ * });
+ * type AllRequirements = FlowRequirements<typeof myFlow.nodes>;
+ * // AllRequirements = ImagePlugin | UploadEngine
+ * ```
+ */
+type FlowRequirements<TNodes extends NodeDefinitionsRecord> = NodesRequirementsUnion<TNodes>;
+/**
+ * Extracts plugin service requirements from a flow, excluding UploadEngine.
+ *
+ * This type is useful for determining which plugin layers need to be
+ * provided when creating a server, as UploadEngine is automatically
+ * provided by the runtime.
+ *
+ * @template TNodes - The record of node definitions
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     resize: imageResizeNode, // requires ImagePlugin
+ *     upload: s3OutputNode,   // requires UploadEngine
+ *   },
+ *   edges: [...]
+ * });
+ * type PluginRequirements = FlowPluginRequirements<typeof myFlow.nodes>;
+ * // PluginRequirements = ImagePlugin (UploadEngine excluded)
+ * ```
+ */
+type FlowPluginRequirements<TNodes extends NodeDefinitionsRecord> = Exclude<FlowRequirements<TNodes>, UploadEngine>;
+/**
+ * Infers the concrete FlowNode type from a NodeDefinition.
+ *
+ * If the definition is already a FlowNode, returns it as-is.
+ * If the definition is an Effect, extracts the FlowNode from the Effect's success type.
+ *
+ * Uses the shared ResolveEffect utility for consistency.
+ */
+type InferNode<T> = T extends FlowNode<any, any, UploadistaError> ? T : ResolveEffect<T> extends FlowNode<any, any, UploadistaError> ? ResolveEffect<T> : never;
+type ExtractKeysByNodeType<TNodes extends NodeDefinitionsRecord, TType extends NodeType> = { [K in keyof TNodes]: InferNode<TNodes[K]>["type"] extends TType ? K : never }[keyof TNodes];
+type SchemaInfer<T> = T extends z.ZodTypeAny ? z.infer<T> : never;
+type FlowInputMap<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>]: SchemaInfer<InferNode<TNodes[K]>["inputSchema"]> };
+type FlowOutputMap<TNodes extends NodeDefinitionsRecord> = { [K in Extract<keyof TNodes, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> };
+type FlowInputUnion<TNodes extends NodeDefinitionsRecord> = { [K in Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>]: SchemaInfer<InferNode<TNodes[K]>["inputSchema"]> }[Extract<ExtractKeysByNodeType<TNodes, NodeType.input>, string>];
+type FlowOutputUnion<TNodes extends NodeDefinitionsRecord> = { [K in Extract<keyof TNodes, string>]: SchemaInfer<InferNode<TNodes[K]>["outputSchema"]> }[Extract<keyof TNodes, string>];
+type NodeKey<TNodes extends NodeDefinitionsRecord> = Extract<keyof TNodes, string>;
+type TypedFlowEdge<TNodes extends NodeDefinitionsRecord> = {
+  source: NodeKey<TNodes>;
+  target: NodeKey<TNodes>;
+  sourcePort?: string;
+  targetPort?: string;
+};
+type TypedFlowConfig<TNodes extends NodeDefinitionsRecord> = {
+  flowId: string;
+  name: string;
+  nodes: TNodes;
+  edges: Array<TypedFlowEdge<TNodes>>;
+  typeChecker?: TypeCompatibilityChecker;
+  onEvent?: (event: FlowEvent) => Effect.Effect<{
+    eventId: string | null;
+  }, UploadistaError>;
+  parallelExecution?: {
+    enabled?: boolean;
+    maxConcurrency?: number;
+  };
+  inputSchema?: z.ZodTypeAny;
+  outputSchema?: z.ZodTypeAny;
+  hooks?: {
+    /**
+     * Called when a sink node (terminal node with no outgoing edges) produces an output.
+     * This hook runs after auto-persistence for UploadFile outputs.
+     *
+     * Use this hook to perform additional post-processing such as:
+     * - Saving output metadata to a database
+     * - Tracking outputs in external systems
+     * - Adding custom metadata to outputs
+     * - Triggering downstream workflows
+     *
+     * **Important**: The hook must not have any service requirements (Effect requirements must be `never`).
+     * All necessary services should be captured in the closure when defining the hook.
+     *
+     * @example
+     * ```typescript
+     * // Using Promise (simpler for most users)
+     * hooks: {
+     *   onNodeOutput: async ({ output }) => {
+     *     await db.save(output);
+     *     return output;
+     *   }
+     * }
+     * ```
+     */
+    onNodeOutput?: <TOutput>(context: {
+      output: TOutput;
+      nodeId: string;
+      flowId: string;
+      jobId: string;
+      storageId: string;
+      clientId: string | null;
+    }) => Effect.Effect<TOutput, UploadistaError, never> | Promise<TOutput>;
+  };
+  /**
+   * Circuit breaker configuration for resilience against external service failures.
+   *
+   * @example
+   * ```typescript
+   * circuitBreaker: {
+   *   defaults: { enabled: false },
+   *   nodeTypeOverrides: {
+   *     "Describe Image": {
+   *       enabled: true,
+   *       failureThreshold: 5,
+   *       resetTimeout: 60000,
+   *       fallback: { type: "skip", passThrough: true }
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  circuitBreaker?: {
+    /** Default circuit breaker config for all nodes */defaults?: FlowCircuitBreakerConfig; /** Override circuit breaker config per node type (node name) */
+    nodeTypeOverrides?: Record<string, FlowCircuitBreakerConfig>;
+  };
+};
+declare const typedFlowInputsSymbol: unique symbol;
+declare const typedFlowOutputsSymbol: unique symbol;
+declare const typedFlowPluginsSymbol: unique symbol;
+/**
+ * A type-safe Flow that infers input/output types and requirements from its nodes.
+ *
+ * TypedFlow extends the base Flow type with additional type information that
+ * allows TypeScript to verify inputs, outputs, and plugin requirements at compile time.
+ *
+ * The phantom type properties (using unique symbols) enable type-level metadata
+ * without affecting runtime behavior, allowing other type utilities to extract
+ * this information for validation purposes.
+ *
+ * @template TNodes - Record of node definitions used in the flow
+ * @template TInputSchema - Zod schema for flow inputs (inferred from input nodes)
+ * @template TOutputSchema - Zod schema for flow outputs (inferred from output nodes)
+ *
+ * @example
+ * ```typescript
+ * const myFlow = createFlow({
+ *   nodes: {
+ *     input: fileInputNode,
+ *     resize: imageResizeNode,
+ *     output: s3OutputNode
+ *   },
+ *   edges: [
+ *     { source: 'input', target: 'resize' },
+ *     { source: 'resize', target: 'output' }
+ *   ]
+ * });
+ *
+ * // TypeScript infers:
+ * // - Input types from fileInputNode.inputSchema
+ * // - Output types from s3OutputNode.outputSchema
+ * // - Requirements: ImagePlugin (from resize node)
+ * ```
+ */
+type TypedFlow<TNodes extends NodeDefinitionsRecord, TInputSchema extends z.ZodTypeAny, TOutputSchema extends z.ZodTypeAny> = Flow<TInputSchema, TOutputSchema, FlowRequirements<TNodes>> & {
+  run: (args: {
+    inputs?: Partial<FlowInputMap<TNodes>>;
+    storageId: string;
+    jobId: string;
+  }) => Effect.Effect<FlowExecutionResult<FlowOutputMap<TNodes>>, UploadistaError, FlowRequirements<TNodes>>;
+  resume: (args: {
+    jobId: string;
+    storageId: string;
+    nodeResults: Record<string, unknown>;
+    executionState: {
+      executionOrder: string[];
+      currentIndex: number;
+      inputs: Partial<FlowInputMap<TNodes>>;
+    };
+  }) => Effect.Effect<FlowExecutionResult<FlowOutputMap<TNodes>>, UploadistaError, FlowRequirements<TNodes>>;
+  readonly [typedFlowInputsSymbol]?: FlowInputMap<TNodes>;
+  readonly [typedFlowOutputsSymbol]?: FlowOutputMap<TNodes>;
+  readonly [typedFlowPluginsSymbol]?: FlowPluginRequirements<TNodes>;
+};
+declare function createFlow<TNodes extends NodeDefinitionsRecord>(config: TypedFlowConfig<TNodes>): Effect.Effect<TypedFlow<TNodes, z.ZodType<FlowInputUnion<TNodes>>, z.ZodType<FlowOutputUnion<TNodes>>>, NodesErrorUnion<TNodes> | UploadistaError, FlowRequirements<TNodes>>;
+//#endregion
+//#region src/flow/types/run-args.d.ts
+/**
+ * Zod schema for validating flow run arguments.
+ *
+ * @property inputs - Record mapping input node IDs to their input data
+ *
+ * @example
+ * ```typescript
+ * const args = {
+ *   inputs: {
+ *     "input-node-1": { file: myFile, metadata: { ... } },
+ *     "input-node-2": { file: anotherFile }
+ *   }
+ * };
+ *
+ * // Validate before running
+ * const validated = runArgsSchema.parse(args);
+ * ```
+ */
+declare const runArgsSchema: z.ZodObject<{
+  inputs: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * Type representing validated flow run arguments.
+ *
+ * This type is inferred from the runArgsSchema and ensures type safety
+ * when passing inputs to flow execution.
+ */
+type RunArgs = z.infer<typeof runArgsSchema>;
+//#endregion
+//#region src/flow/utils/file-naming.d.ts
+/**
+ * Extracts the base name (without extension) from a filename.
+ *
+ * @param fileName - The full filename
+ * @returns The filename without extension
+ *
+ * @example
+ * ```typescript
+ * getBaseName("photo.jpg") // "photo"
+ * getBaseName("document.tar.gz") // "document.tar"
+ * getBaseName("noextension") // "noextension"
+ * ```
+ */
+declare function getBaseName(fileName: string): string;
+/**
+ * Extracts the extension (without dot) from a filename.
+ *
+ * @param fileName - The full filename
+ * @returns The extension without leading dot, or empty string if none
+ *
+ * @example
+ * ```typescript
+ * getExtension("photo.jpg") // "jpg"
+ * getExtension("document.tar.gz") // "gz"
+ * getExtension("noextension") // ""
+ * ```
+ */
+declare function getExtension(fileName: string): string;
+/**
+ * Builds a naming context from file and flow execution information.
+ *
+ * @param file - The UploadFile being processed
+ * @param flowContext - Flow execution context (flowId, jobId, nodeId, nodeType)
+ * @param extraVars - Additional variables to include (width, height, format, etc.)
+ * @returns Complete naming context for template interpolation
+ *
+ * @example
+ * ```typescript
+ * const context = buildNamingContext(
+ *   uploadFile,
+ *   { flowId: "flow-1", jobId: "job-1", nodeId: "resize-1", nodeType: "resize" },
+ *   { width: 800, height: 600 }
+ * );
+ * // context.baseName = "photo"
+ * // context.extension = "jpg"
+ * // context.width = 800
+ * // context.height = 600
+ * ```
+ */
+declare function buildNamingContext(file: UploadFile, flowContext: {
+  flowId: string;
+  jobId: string;
+  nodeId: string;
+  nodeType: string;
+}, extraVars?: Record<string, string | number | undefined>): NamingContext;
+/**
+ * Interpolates a mustache-style template with the given context.
+ *
+ * Uses micromustache for fast, secure template rendering.
+ * Unknown variables are preserved as-is (e.g., {{unknown}} stays {{unknown}}).
+ *
+ * @param pattern - Mustache-style template string
+ * @param context - Variables to interpolate
+ * @returns Interpolated string
+ *
+ * @example
+ * ```typescript
+ * interpolateFileName(
+ *   "{{baseName}}-{{width}}x{{height}}.{{extension}}",
+ *   { baseName: "photo", width: 800, height: 600, extension: "jpg" }
+ * );
+ * // Returns: "photo-800x600.jpg"
+ * ```
+ */
+declare function interpolateFileName(pattern: string, context: NamingContext): string;
+/**
+ * Applies file naming configuration to generate a new filename.
+ *
+ * Handles three modes:
+ * - No config: Returns original filename (backward compatible)
+ * - Auto mode: Appends auto-generated suffix based on node type
+ * - Custom mode: Uses template pattern or rename function
+ *
+ * On any error, falls back to the original filename to prevent flow failures.
+ *
+ * @param file - The UploadFile being processed
+ * @param context - Naming context with all available variables
+ * @param config - Optional naming configuration
+ * @returns The new filename (or original on error/no config)
+ *
+ * @example
+ * ```typescript
+ * // Auto mode
+ * applyFileNaming(file, context, {
+ *   mode: 'auto',
+ *   autoSuffix: (ctx) => `${ctx.width}x${ctx.height}`
+ * });
+ * // Returns: "photo-800x600.jpg"
+ *
+ * // Custom mode with template
+ * applyFileNaming(file, context, {
+ *   mode: 'custom',
+ *   pattern: '{{baseName}}-processed.{{extension}}'
+ * });
+ * // Returns: "photo-processed.jpg"
+ *
+ * // Custom mode with function
+ * applyFileNaming(file, context, {
+ *   mode: 'custom',
+ *   rename: (file, ctx) => `${ctx.flowId}-${ctx.fileName}`
+ * });
+ * // Returns: "flow-1-photo.jpg"
+ * ```
+ */
+declare function applyFileNaming(file: UploadFile, context: NamingContext, config?: FileNamingConfig): string;
+/**
+ * Validates a template pattern for common issues.
+ *
+ * Checks for:
+ * - Balanced braces
+ * - Non-empty pattern
+ * - Valid variable names
+ *
+ * @param pattern - Template pattern to validate
+ * @returns Object with isValid flag and optional error message
+ *
+ * @example
+ * ```typescript
+ * validatePattern("{{baseName}}.{{extension}}");
+ * // { isValid: true }
+ *
+ * validatePattern("{{baseName");
+ * // { isValid: false, error: "Unbalanced braces: missing closing }}" }
+ * ```
+ */
+declare function validatePattern(pattern: string): {
+  isValid: boolean;
+  error?: string;
+};
+/**
+ * List of available template variables for documentation and UI.
+ */
+declare const AVAILABLE_TEMPLATE_VARIABLES: readonly [{
+  readonly name: "baseName";
+  readonly description: "Filename without extension";
+  readonly example: "photo";
+}, {
+  readonly name: "extension";
+  readonly description: "File extension without dot";
+  readonly example: "jpg";
+}, {
+  readonly name: "fileName";
+  readonly description: "Full original filename";
+  readonly example: "photo.jpg";
+}, {
+  readonly name: "nodeType";
+  readonly description: "Type of processing node";
+  readonly example: "resize";
+}, {
+  readonly name: "nodeId";
+  readonly description: "Specific node instance ID";
+  readonly example: "resize-1";
+}, {
+  readonly name: "flowId";
+  readonly description: "Flow identifier";
+  readonly example: "flow-abc";
+}, {
+  readonly name: "jobId";
+  readonly description: "Execution job ID";
+  readonly example: "job-123";
+}, {
+  readonly name: "timestamp";
+  readonly description: "ISO 8601 processing time";
+  readonly example: "2024-01-15T10:30:00Z";
+}, {
+  readonly name: "width";
+  readonly description: "Output width (image/video)";
+  readonly example: "800";
+}, {
+  readonly name: "height";
+  readonly description: "Output height (image/video)";
+  readonly example: "600";
+}, {
+  readonly name: "format";
+  readonly description: "Output format";
+  readonly example: "webp";
+}, {
+  readonly name: "quality";
+  readonly description: "Quality setting";
+  readonly example: "80";
+}, {
+  readonly name: "pageNumber";
+  readonly description: "Page number (documents)";
+  readonly example: "1";
+}];
+//#endregion
+//#region src/flow/utils/resolve-upload-metadata.d.ts
+type FileMetadata = UploadFile["metadata"];
+type ResolvedUploadMetadata = {
+  type: string;
+  fileName: string;
+  metadata: FileMetadata;
+  metadataJson: string | undefined;
+};
+declare function resolveUploadMetadata(metadata: FileMetadata): ResolvedUploadMetadata;
+//#endregion
+export { VideoPlugin as $, MemoryFlowQueueStore as $n, ImageAiPluginLayer as $t, isImageDescriptionOutput as A, ExtractLayerServices as An, DistributedCircuitBreaker as Ar, Transformation as At, describeImageParamsSchema as B, FlowQueueServiceShape as Bn, CircuitBreakerState as Br, rotateTransformSchema as Bt, createTypeGuard as C, StreamingTransformResult as Cn, FlowData as Cr, OverlayPosition as Ct, getSingleOutputByType as D, ExtractEffectError as Dn, FlowEdge as Dr, SharpenTransform as Dt, getOutputByNodeId as E, createTransformNode as En, getFlowData as Er, SepiaTransform as Et, isUploadOperation as F, createInputNode as Fn, memoryCircuitBreakerStoreLayer as Fr, contrastTransformSchema as Ft, ZipPlugin as G, FlowLifecycleHook as Gn, transformationSchema as Gt, PluginLayer as H, FlowEngineLayer as Hn, sharpenTransformSchema as Ht, isUrlOperation as I, inputDataSchema as In, CircuitBreakerConfig as Ir, flipTransformSchema as It, ScanMetadata as J, FlowWaitUntil as Jn, resizeParamsSchema as Jt, ZipPluginLayer as K, FlowProvider as Kn, watermarkTransformSchema as Kt, RemoveBackgroundParams as L, inputNodeParamsSchema as Ln, CircuitBreakerEvent as Lr, grayscaleTransformSchema as Lt, isOcrOutput as M, FlowCondition as Mn, kvCircuitBreakerStoreLayer as Mr, WatermarkTransform as Mt, isStorageOutput as N, InputData as Nn, makeKvCircuitBreakerStore as Nr, blurTransformSchema as Nt, hasOutputOfType as O, ExtractEffectRequirements as On, createFlowEdge as Or, TextTransform as Ot, isUploadFile as P, InputNodeParams as Pn, makeMemoryCircuitBreakerStore as Pr, brightnessTransformSchema as Pt, VirusScanPluginShape as Q, FlowQueueStore as Qn, ImageAiPlugin as Qt, removeBackgroundParamsSchema as R, FlowQueueDispatchMarker as Rn, CircuitBreakerEventHandler as Rr, logoTransformSchema as Rt, NarrowedTypedOutput as S, StreamingTransformFn as Sn, Flow as Sr, LogoTransform as St, getFirstOutputByType as T, TransformNodeConfig as Tn, createFlowWithSchema as Tr, RotateTransform as Tt, ZipInput as U, FlowEngineOptions as Un, textTransformSchema as Ut, Plugin as V, FlowEngine as Vn, DEFAULT_CIRCUIT_BREAKER_CONFIG as Vr, sepiaTransformSchema as Vt, ZipParams as W, FlowEngineShape as Wn, transformImageParamsSchema as Wt, VirusScanPlugin as X, createFlowEngine as Xn, optimizeParamsSchema as Xt, ScanResult as Y, WaitUntilCallback as Yn, OptimizeParams as Yt, VirusScanPluginLayer as Z, flowEngine as Zn, ImageAiContext as Zt, NodeDefinitionsRecord as _, CredentialProviderLayer as _n, InputTypeDefinition as _r, BlurTransform as _t, buildNamingContext as a, MergePdfParams as an, ImageDescriptionOutput as ar, trimVideoParamsSchema as at, TypedFlowEdge as b, ParallelScheduler as bn, inputTypeRegistry as br, FlipTransform as bt, interpolateFileName as c, DocumentAiContext as cn, STORAGE_OUTPUT_TYPE_ID as cr, ResizeVideoParams as ct, runArgsSchema as d, DocumentAiPluginShape as dn, ocrOutputSchema as dr, extractFrameVideoParamsSchema as dt, ImageAiPluginShape as en, DeadLetterQueueService as er, VideoPluginLayer as et, FlowInputMap as f, OcrParams as fn, OutputTypeDefinition as fr, DescribeVideoMetadata as ft, NodeDefinition as g, CredentialProvider as gn, validateFlowOutput as gr, ImagePluginShape as gt, FlowRequirements as h, OcrTaskType as hn, outputTypeRegistry as hr, ImagePluginLayer as ht, applyFileNaming as i, DocumentPluginShape as in, IMAGE_DESCRIPTION_OUTPUT_TYPE_ID as ir, TrimVideoParams as it, isInitOperation as j, ResolveEffect as jn, DistributedCircuitBreakerRegistry as jr, TransformationType as jt, isFinalizeOperation as k, ExtractLayerService as kn, AllowRequestResult as kr, TransformImageParams as kt, validatePattern as l, DocumentAiPlugin as ln, STREAMING_INPUT_TYPE_ID as lr, resizeVideoParamsSchema as lt, FlowPluginRequirements as m, OcrResult as mn, OutputValidationResult as mr, ImagePlugin as mt, resolveUploadMetadata as n, DocumentPlugin as nn, createDeadLetterQueueService as nr, VideoStreamInput as nt, getBaseName as o, SplitPdfParams as on, OCR_OUTPUT_TYPE_ID as or, TranscodeVideoParams as ot, FlowOutputMap as p, OcrResolution as pn, OutputTypeRegistry as pr, describeVideoMetadataSchema as pt, ZipPluginShape as q, FlowProviderShape as qn, ResizeParams as qt, AVAILABLE_TEMPLATE_VARIABLES as r, DocumentPluginLayer as rn, deadLetterQueueService as rr, VideoStreamOptions as rt, getExtension as s, SplitPdfResult as sn, OcrOutput as sr, transcodeVideoParamsSchema as st, ResolvedUploadMetadata as t, DocumentMetadata as tn, DeadLetterQueueServiceShape as tr, VideoPluginShape as tt, RunArgs as u, DocumentAiPluginLayer as un, imageDescriptionOutputSchema as ur, ExtractFrameVideoParams as ut, TypedFlow as v, CredentialProviderShape as vn, InputTypeRegistry as vr, BrightnessTransform as vt, filterOutputsByType as w, TransformMode as wn, FlowExecutionResult as wr, ResizeTransform as wt, createFlow as x, ParallelSchedulerConfig as xn, validateFlowInput as xr, GrayscaleTransform as xt, TypedFlowConfig as y, ExecutionLevel as yn, InputValidationResult as yr, ContrastTransform as yt, DescribeImageParams as z, FlowQueueService as zn, CircuitBreakerFallback as zr, resizeTransformSchema as zt };
+//# sourceMappingURL=resolve-upload-metadata-CYl2PHIs.d.mts.map