@uploadista/core 0.0.9 → 0.0.11

package/dist/{index-od64jviT.d.mts → index-CDzzqysG.d.mts}

@@ -762,7 +762,7 @@ type FlowData = {
  * await db.flows.save(flowData);
  * ```
  */
-declare const getFlowData: <TRequirements$1>(flow: Flow<any, any, TRequirements$1>) => FlowData;
+declare const getFlowData: <TRequirements>(flow: Flow<any, any, TRequirements>) => FlowData;
 /**
  * Result of a flow execution - either completed or paused.
  *
@@ -845,21 +845,21 @@ type FlowExecutionResult<TOutput> = {
  * });
  * ```
  */
-type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements$1> = {
+type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z.ZodSchema<any>, TRequirements> = {
   id: string;
   name: string;
   nodes: FlowNode<any, any, UploadistaError$1>[];
   edges: FlowEdge[];
   inputSchema: TFlowInputSchema;
   outputSchema: TFlowOutputSchema;
-  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>["onEvent"];
-  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>["checkJobStatus"];
+  onEvent?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["onEvent"];
+  checkJobStatus?: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TRequirements>["checkJobStatus"];
   run: (args: {
     inputs?: Record<string, z.infer<TFlowInputSchema>>;
     storageId: string;
     jobId: string;
     clientId: string | null;
-  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements$1>;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements>;
   resume: (args: {
     jobId: string;
     storageId: string;
@@ -870,7 +870,7 @@ type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z
       inputs: Record<string, z.infer<TFlowInputSchema>>;
     };
     clientId: string | null;
-  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements$1>;
+  }) => Effect.Effect<FlowExecutionResult<Record<string, z.infer<TFlowOutputSchema>>>, UploadistaError$1, TRequirements>;
   validateTypes: () => {
     isValid: boolean;
     errors: string[];
@@ -952,7 +952,7 @@ type Flow<TFlowInputSchema extends z.ZodSchema<any>, TFlowOutputSchema extends z
  * @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$1 = never, TNodeError = never, TNodeRequirements = never>(config: FlowConfig<TFlowInputSchema, TFlowOutputSchema, TNodeError, TNodeRequirements>): Effect.Effect<Flow<TFlowInputSchema, TFlowOutputSchema, TRequirements$1>, TNodeError, TNodeRequirements>;
+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/types/upload-file.d.ts
 /**
@@ -3035,8 +3035,8 @@ declare class FlowWaitUntil extends FlowWaitUntil_base {
  * const flowProviderLayer = Layer.succeed(FlowProvider, dbFlowProvider);
  * ```
  */
-type FlowProviderShape<TRequirements$1 = any> = {
-  getFlow: (flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements$1>, UploadistaError$1>;
+type FlowProviderShape<TRequirements = any> = {
+  getFlow: (flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
 };
 declare const FlowProvider_base: Context.TagClass<FlowProvider, "FlowProvider", FlowProviderShape<any>>;
 /**
@@ -3142,9 +3142,9 @@ declare class FlowProvider extends FlowProvider_base {}
  * ```
  */
 type FlowServerShape = {
-  getFlow: <TRequirements$1>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements$1>, UploadistaError$1>;
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, TRequirements>, UploadistaError$1>;
   getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError$1>;
-  runFlow: <TRequirements$1>({
+  runFlow: <TRequirements>({
     flowId,
     storageId,
     clientId,
@@ -3154,8 +3154,8 @@ type FlowServerShape = {
     storageId: string;
     clientId: string | null;
     inputs: any;
-  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements$1>;
-  resumeFlow: <TRequirements$1>({
+  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
+  resumeFlow: <TRequirements>({
     jobId,
     nodeId,
     newData,
@@ -3165,7 +3165,7 @@ type FlowServerShape = {
     nodeId: string;
     newData: unknown;
     clientId: string | null;
-  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements$1>;
+  }) => Effect.Effect<FlowJob, UploadistaError$1, TRequirements>;
   pauseFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1>;
   cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1>;
   getJobStatus: (jobId: string) => Effect.Effect<FlowJob, UploadistaError$1>;
@@ -3212,17 +3212,17 @@ declare class FlowServer extends FlowServer_base {}
  * @property kvStore - KV store for flow job metadata
  */
 type FlowServerOptions = {
-  getFlow: <TRequirements$1>({
+  getFlow: <TRequirements>({
     flowId,
     storageId
   }: {
     flowId: string;
     storageId: string;
-  }) => Promise<Flow<any, any, TRequirements$1>>;
+  }) => Promise<Flow<any, any, TRequirements>>;
   kvStore: KvStore<FlowJob>;
 };
 declare function createFlowServer(): Effect.Effect<{
-  getFlow: <TRequirements$1>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, any>, UploadistaError$1, never>;
+  getFlow: <TRequirements>(flowId: string, clientId: string | null) => Effect.Effect<Flow<any, any, any>, UploadistaError$1, never>;
   getFlowData: (flowId: string, clientId: string | null) => Effect.Effect<FlowData, UploadistaError$1, never>;
   runFlow: ({
     flowId,
@@ -3251,8 +3251,8 @@ declare function createFlowServer(): Effect.Effect<{
   cancelFlow: (jobId: string, clientId: string | null) => Effect.Effect<FlowJob, UploadistaError$1, never>;
   subscribeToFlowEvents: (jobId: string, connection: WebSocketConnection) => Effect.Effect<void, UploadistaError$1, never>;
   unsubscribeFromFlowEvents: (jobId: string) => Effect.Effect<void, UploadistaError$1, never>;
-}, never, UploadServer | FlowProvider | FlowJobKVStore | FlowEventEmitter>;
-declare const flowServer: Layer.Layer<FlowServer, never, UploadServer | FlowProvider | FlowJobKVStore | FlowEventEmitter>;
+}, never, FlowEventEmitter | FlowJobKVStore | UploadServer | FlowProvider>;
+declare const flowServer: Layer.Layer<FlowServer, never, FlowEventEmitter | FlowJobKVStore | UploadServer | FlowProvider>;
 type FlowServerLayer = typeof flowServer;
 //#endregion
 //#region src/flow/nodes/input-node.d.ts
@@ -3595,7 +3595,7 @@ declare class ParallelScheduler {
    * // results will be in order: [result1, result2, result3]
    * ```
    */
-  executeNodesInParallel<T, E, R$1>(nodeExecutors: Array<() => Effect.Effect<T, E, R$1>>): Effect.Effect<T[], E, R$1>;
+  executeNodesInParallel<T, E$1, R$1>(nodeExecutors: Array<() => Effect.Effect<T, E$1, R$1>>): Effect.Effect<T[], E$1, R$1>;
   /**
    * Determines if a set of nodes can be safely executed in parallel.
    *
@@ -3677,6 +3677,7 @@ declare const CredentialProvider_base: Context.TagClass<CredentialProvider, "Cre
  * ```
  */
 declare class CredentialProvider extends CredentialProvider_base {}
+type CredentialProviderLayer = Layer.Layer<CredentialProvider, never, never>;
 //#endregion
 //#region src/flow/plugins/image-ai-plugin.d.ts
 /**
@@ -3735,6 +3736,7 @@ declare const ImageAiPlugin_base: Context.TagClass<ImageAiPlugin, "ImageAiPlugin
  * ```
  */
 declare class ImageAiPlugin extends ImageAiPlugin_base {}
+type ImageAiPluginLayer = Layer.Layer<ImageAiPlugin, never, never>;
 //#endregion
 //#region src/flow/plugins/types/optimize-node.d.ts
 /**
@@ -3823,38 +3825,7 @@ declare const ImagePlugin_base: Context.TagClass<ImagePlugin, "ImagePlugin", Ima
  * ```
  */
 declare class ImagePlugin extends ImagePlugin_base {}
-//#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>;
+type ImagePluginLayer = Layer.Layer<ImagePlugin, never, never>;
 //#endregion
 //#region src/flow/plugins/zip-plugin.d.ts
 /**
@@ -3913,17 +3884,348 @@ declare const ZipPlugin_base: Context.TagClass<ZipPlugin, "ZipPlugin", ZipPlugin
  * ```
  */
 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 | CredentialProvider | ZipPlugin;
+type PluginLayer = ImagePluginLayer | ImageAiPluginLayer | 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/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$1 = never, TRequirements = never> = T extends Layer.Layer<infer S, TError$1, 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
+ *
+ * @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
+ * ```
+ */
+type ExtractLayerServices<T extends readonly Layer.Layer<any, any, any>[]> = T[number] extends Layer.Layer<infer S, any, any> ? S : never;
+/**
+ * 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/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$1> | Effect.Effect<FlowNode<any, any, UploadistaError$1>, 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$1>, infer TError, any> ? TError : never;
-type NodeDefinitionRequirements<T> = T extends Effect.Effect<FlowNode<any, any, UploadistaError$1>, any, infer TRequirements> ? TRequirements : 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 UploadServer (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 | UploadServer
+ * ```
+ */
 type FlowRequirements<TNodes extends NodeDefinitionsRecord> = NodesRequirementsUnion<TNodes>;
+/**
+ * Extracts plugin service requirements from a flow, excluding UploadServer.
+ *
+ * This type is useful for determining which plugin layers need to be
+ * provided when creating a server, as UploadServer 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 UploadServer
+ *   },
+ *   edges: [...]
+ * });
+ * type PluginRequirements = FlowPluginRequirements<typeof myFlow.nodes>;
+ * // PluginRequirements = ImagePlugin (UploadServer excluded)
+ * ```
+ */
 type FlowPluginRequirements<TNodes extends NodeDefinitionsRecord> = Exclude<FlowRequirements<TNodes>, UploadServer>;
-type InferNode<T> = T extends FlowNode<any, any, UploadistaError$1> ? T : T extends Effect.Effect<infer R, any, any> ? R extends FlowNode<any, any, UploadistaError$1> ? R : never : never;
+/**
+ * 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$1> ? T : ResolveEffect<T> extends FlowNode<any, any, UploadistaError$1> ? 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"]> };
@@ -3956,6 +4258,40 @@ type TypedFlowConfig<TNodes extends NodeDefinitionsRecord> = {
 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>>;
@@ -3978,52 +4314,6 @@ type TypedFlow<TNodes extends NodeDefinitionsRecord, TInputSchema extends z.ZodT
 };
 declare function createFlow<TNodes extends NodeDefinitionsRecord>(config: TypedFlowConfig<TNodes>): Effect.Effect<TypedFlow<TNodes, z.ZodType<FlowInputUnion<TNodes>>, z.ZodType<FlowOutputUnion<TNodes>>>, NodesErrorUnion<TNodes> | UploadistaError$1, FlowRequirements<TNodes>>;
 //#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/run-args.d.ts
 /**
  * Zod schema for validating flow run arguments.
@@ -4064,5 +4354,5 @@ type ResolvedUploadMetadata = {
 };
 declare function resolveUploadMetadata(metadata: FileMetadata): ResolvedUploadMetadata;
 //#endregion
-export { FlowServerShape as $, BaseKvStore as $t, ImageAiContext as A, FlowEventFlowError as An, UploadEventEmitter as At, StorageParams as B, FlowEventNodeStart as Bn, EventBroadcaster as Bt, describeImageParamsSchema as C, TypeCompatibilityChecker as Cn, InputFile as Ct, resizeParamsSchema as D, FlowEvent as Dn, EventEmitter as Dt, ResizeParams as E, EventType as En, BaseEventEmitterService as Et, ExecutionLevel as F, FlowEventNodeEnd as Fn, WebSocketMessage as Ft, createInputNode as G, createFlowNode as Gn, DataStoreConfig as Gt, storageParamsSchema as H, ConditionOperator as Hn, BufferedUploadFileDataStore as Ht, ParallelScheduler as I, FlowEventNodeError as In, webSocketMessageSchema as It, FlowProvider as J, UploadFileDataStores as Jt, inputDataSchema as K, getNodeData as Kn, DataStoreWriteOptions as Kt, ParallelSchedulerConfig as L, FlowEventNodePause as Ln, UploadEvent as Lt, ImageAiPluginShape as M, FlowEventFlowStart as Mn, flowEventEmitter as Mt, CredentialProvider as N, FlowEventJobEnd as Nn, uploadEventEmitter as Nt, OptimizeParams as O, FlowEventFlowCancel as On, FlowEventEmitter as Ot, CredentialProviderShape as P, FlowEventJobStart as Pn, WebSocketConnection as Pt, FlowServerOptions as Q, isDataStore as Qt, TransformNodeConfig as R, FlowEventNodeResponse as Rn, UploadEventType as Rt, DescribeImageParams as S, NodeTypeMap as Sn, MiddlewareServiceLive as St, ImagePluginShape as T, waitingNodeExecution as Tn, BaseEventEmitter as Tt, InputData as U, ConditionValue as Un, DataStore as Ut, createStorageNode as V, ConditionField as Vn, EventBroadcasterService as Vt, InputNodeParams as W, NodeType as Wn, DataStoreCapabilities as Wt, FlowServer as X, UploadStrategy as Xt, FlowProviderShape as Y, UploadFileDataStoresShape as Yt, FlowServerLayer as Z, createDataStoreLayer as Zt, ZipParams as _, FlowConfig as _n, detectMimeType as _t, FlowCondition as a, flowJobKvStore as an, FlowJobStatus as at, RemoveBackgroundParams as b, NodeConnectionValidator as bn, MiddlewareNext as bt, FlowPluginRequirements as c, UploadFile as cn, NegotiatedStrategy as ct, NodeDefinitionsRecord as d, FlowData as dn, UploadServer as dt, BaseKvStoreService as en, FlowWaitUntil as et, TypedFlow as f, FlowExecutionResult as fn, UploadServerOptions as ft, ZipInput as g, createFlowEdge as gn, compareMimeTypes as gt, createFlow as h, FlowEdge as hn, uploadServer as ht, runArgsSchema as i, UploadFileKVStore as in, FlowJob as it, ImageAiPlugin as j, FlowEventFlowPause as jn, eventToMessageSerializer as jt, optimizeParamsSchema as k, FlowEventFlowEnd as kn, TypedEventEmitter as kt, FlowRequirements as l, uploadFileSchema as ln, UploadStrategyNegotiator as lt, TypedFlowEdge as m, getFlowData as mn, createUploadServer as mt, resolveUploadMetadata as n, KvStore as nn, createFlowServer as nt, FlowInputMap as o, jsonSerializer as on, FlowJobTask as ot, TypedFlowConfig as p, createFlowWithSchema as pn, UploadServerShape as pt, inputNodeParamsSchema as q, UploadFileDataStore as qt, RunArgs as r, TypedKvStore as rn, flowServer as rt, FlowOutputMap as s, uploadFileKvStore as sn, FlowJobTaskStatus as st, ResolvedUploadMetadata as t, FlowJobKVStore as tn, WaitUntilCallback as tt, NodeDefinition as u, Flow as un, UploadStrategyOptions as ut, ZipPlugin as v, FlowNode as vn, Middleware as vt, ImagePlugin as w, completeNodeExecution as wn, inputFileSchema as wt, removeBackgroundParamsSchema as x, NodeExecutionResult as xn, MiddlewareService as xt, ZipPluginShape as y, FlowNodeData as yn, MiddlewareContext as yt, createTransformNode as z, FlowEventNodeResume as zn, uploadEventSchema as zt };
-//# sourceMappingURL=index-od64jviT.d.mts.map
+export { storageParamsSchema as $, ConditionOperator as $n, BufferedUploadFileDataStore as $t, ZipPluginLayer as A, FlowNodeData as An, MiddlewareContext as At, ImageAiPlugin as B, FlowEventFlowEnd as Bn, TypedEventEmitter as Bt, DescribeImageParams as C, FlowExecutionResult as Cn, UploadServerOptions as Ct, ZipInput as D, createFlowEdge as Dn, compareMimeTypes as Dt, PluginLayer as E, FlowEdge as En, uploadServer as Et, ResizeParams as F, completeNodeExecution as Fn, inputFileSchema as Ft, CredentialProviderShape as G, FlowEventJobStart as Gn, WebSocketConnection as Gt, ImageAiPluginShape as H, FlowEventFlowPause as Hn, eventToMessageSerializer as Ht, resizeParamsSchema as I, waitingNodeExecution as In, BaseEventEmitter as It, ParallelSchedulerConfig as J, FlowEventNodePause as Jn, UploadEvent as Jt, ExecutionLevel as K, FlowEventNodeEnd as Kn, WebSocketMessage as Kt, OptimizeParams as L, EventType as Ln, BaseEventEmitterService as Lt, ImagePlugin as M, NodeExecutionResult as Mn, MiddlewareService as Mt, ImagePluginLayer as N, NodeTypeMap as Nn, MiddlewareServiceLive as Nt, ZipParams as O, FlowConfig as On, detectMimeType as Ot, ImagePluginShape as P, TypeCompatibilityChecker as Pn, InputFile as Pt, createStorageNode as Q, ConditionField as Qn, EventBroadcasterService as Qt, optimizeParamsSchema as R, FlowEvent as Rn, EventEmitter as Rt, removeBackgroundParamsSchema as S, FlowData as Sn, UploadServer as St, Plugin as T, getFlowData as Tn, createUploadServer as Tt, CredentialProvider as U, FlowEventFlowStart as Un, flowEventEmitter as Ut, ImageAiPluginLayer as V, FlowEventFlowError as Vn, UploadEventEmitter as Vt, CredentialProviderLayer as W, FlowEventJobEnd as Wn, uploadEventEmitter as Wt, createTransformNode as X, FlowEventNodeResume as Xn, uploadEventSchema as Xt, TransformNodeConfig as Y, FlowEventNodeResponse as Yn, UploadEventType as Yt, StorageParams as Z, FlowEventNodeStart as Zn, EventBroadcaster as Zt, ExtractLayerService as _, jsonSerializer as _n, FlowJobTask as _t, FlowInputMap as a, UploadFileDataStores as an, FlowProvider as at, FlowCondition as b, uploadFileSchema as bn, UploadStrategyNegotiator as bt, FlowRequirements as c, createDataStoreLayer as cn, FlowServerLayer as ct, TypedFlow as d, BaseKvStoreService as dn, FlowWaitUntil as dt, DataStore as en, ConditionValue as er, InputData as et, TypedFlowConfig as f, FlowJobKVStore as fn, WaitUntilCallback as ft, ExtractEffectRequirements as g, flowJobKvStore as gn, FlowJobStatus as gt, ExtractEffectError as h, UploadFileKVStore as hn, FlowJob as ht, runArgsSchema as i, UploadFileDataStore as in, inputNodeParamsSchema as it, ZipPluginShape as j, NodeConnectionValidator as jn, MiddlewareNext as jt, ZipPlugin as k, FlowNode as kn, Middleware as kt, NodeDefinition as l, isDataStore as ln, FlowServerOptions as lt, createFlow as m, TypedKvStore as mn, flowServer as mt, resolveUploadMetadata as n, DataStoreConfig as nn, createFlowNode as nr, createInputNode as nt, FlowOutputMap as o, UploadFileDataStoresShape as on, FlowProviderShape as ot, TypedFlowEdge as p, KvStore as pn, createFlowServer as pt, ParallelScheduler as q, FlowEventNodeError as qn, webSocketMessageSchema as qt, RunArgs as r, DataStoreWriteOptions as rn, getNodeData as rr, inputDataSchema as rt, FlowPluginRequirements as s, UploadStrategy as sn, FlowServer as st, ResolvedUploadMetadata as t, DataStoreCapabilities as tn, NodeType as tr, InputNodeParams as tt, NodeDefinitionsRecord as u, BaseKvStore as un, FlowServerShape as ut, ExtractLayerServices as v, uploadFileKvStore as vn, FlowJobTaskStatus as vt, describeImageParamsSchema as w, createFlowWithSchema as wn, UploadServerShape as wt, RemoveBackgroundParams as x, Flow as xn, UploadStrategyOptions as xt, ResolveEffect as y, UploadFile as yn, NegotiatedStrategy as yt, ImageAiContext as z, FlowEventFlowCancel as zn, FlowEventEmitter as zt };
+//# sourceMappingURL=index-CDzzqysG.d.mts.map