@uploadista/flow-utility-nodes 0.0.13-beta.4 → 0.0.13

package/dist/nodes/index.d.cts

@@ -1,8 +1,11 @@
-import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BbFUu_Oc.cjs";
+import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-Brh9A17P.cjs";
+import * as _uploadista_core_flow1 from "@uploadista/core/flow";
+import { NodeType, ZipPlugin } from "@uploadista/core/flow";
+import * as zod_v4_core0 from "zod/v4/core";
+import * as zod0 from "zod";
+import { z } from "zod";
 import * as _uploadista_core_errors0 from "@uploadista/core/errors";
 import { UploadistaError } from "@uploadista/core/errors";
-import * as _uploadista_core_flow2 from "@uploadista/core/flow";
-import { ZipPlugin } from "@uploadista/core/flow";
 import { UploadFile } from "@uploadista/core/types";
 import { Effect } from "effect";
 import { UploadServer } from "@uploadista/core/upload";
@@ -12,25 +15,129 @@ declare function createConditionalNode(id: string, {
   field,
   operator,
   value
-}: ConditionalParams): Effect.Effect<_uploadista_core_flow2.FlowNode<UploadFile, UploadFile, _uploadista_core_errors0.UploadistaError>, never, never>;
+}: ConditionalParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: zod0.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  outputSchema: zod0.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<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, _uploadista_core_errors0.UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, never>;
 //#endregion
 //#region src/nodes/merge-node.d.ts
 declare function createMergeNode(id: string, {
   strategy,
   separator: _separator
-}: MergeParams): Effect.Effect<_uploadista_core_flow2.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
+}: MergeParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: z.ZodType<Record<string, UploadFile>, unknown, z.core.$ZodTypeInternals<Record<string, UploadFile>, unknown>>;
+  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: Record<string, UploadFile>;
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer>;
 //#endregion
 //#region src/nodes/multiplex-node.d.ts
 declare function createMultiplexNode(id: string, {
   outputCount: _outputCount,
   strategy
-}: MultiplexParams): Effect.Effect<_uploadista_core_flow2.FlowNode<UploadFile, UploadFile, UploadistaError>, never, UploadServer>;
+}: MultiplexParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: zod0.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  outputSchema: zod0.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<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer>;
 //#endregion
 //#region src/nodes/zip-node.d.ts
 declare function createZipNode(id: string, {
   zipName,
   includeMetadata
-}: ZipParams): Effect.Effect<_uploadista_core_flow2.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer | ZipPlugin>;
+}: ZipParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: z.ZodType<Record<string, UploadFile>, unknown, z.core.$ZodTypeInternals<Record<string, UploadFile>, unknown>>;
+  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: Record<string, UploadFile>;
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer | ZipPlugin>;
 //#endregion
 export { createConditionalNode, createMergeNode, createMultiplexNode, createZipNode };
 //# sourceMappingURL=index.d.cts.map

package/dist/nodes/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,wBAAA,CAAA,eAAA;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA;;;iBCLlC,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,yBAAA;;;iBCE1C,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA,eAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;;;;IAF/B,QAAA,EAAA,MAAA,GAAA,IAAqB;EAEjC,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,4CAAA,KAAA,CAAA;EAAO,SAAA,CAAA,EAAA;IAAU,KAAA,EAAA,MAAA;IAAS,QAAA,EAAA,MAAA;IAAiB,KAAA,EAAA,OAAA;;;;;;;;;;;;;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;IDRlC,SAAA,EAAA,MAAA;IAEZ,MAAA,EAAA,MAAA;IAAO,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAU,QAAA,EAAA,MAAA,GAAA,IAAA;EAAS,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAiB,SAAA,CAAA,EAAA;;;;;;;;;;;;;;;;;;iBEC/B,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;;IFL1C,MAAA,EAAA,MAAA;IAEZ,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAO,QAAA,EAAA,MAAA,GAAA,IAAA;EAAU,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAS,SAAA,CAAA,EAAA;IAAiB,KAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;iBGK/B,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;IHTzB,SAAA,EAAA,MAAA;IAEZ,MAAA,EAAA,MAAA;IAAO,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAU,QAAA,EAAA,MAAA,GAAA,IAAA;EAAS,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAiB,SAAA,CAAA,EAAA"}

package/dist/nodes/index.d.mts

@@ -1,36 +1,143 @@
-import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-bdgJgJHI.mjs";
+import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-7DDOD4H0.mjs";
 import * as _uploadista_core_flow1 from "@uploadista/core/flow";
-import { ZipPlugin } from "@uploadista/core/flow";
+import { NodeType, ZipPlugin } from "@uploadista/core/flow";
 import { UploadFile } from "@uploadista/core/types";
 import { Effect } from "effect";
 import * as _uploadista_core_errors0 from "@uploadista/core/errors";
 import { UploadistaError } from "@uploadista/core/errors";
 import { UploadServer } from "@uploadista/core/upload";
+import * as zod0 from "zod";
+import { z } from "zod";
+import * as zod_v4_core0 from "zod/v4/core";
 
 //#region src/nodes/conditional-node.d.ts
 declare function createConditionalNode(id: string, {
   field,
   operator,
   value
-}: ConditionalParams): Effect.Effect<_uploadista_core_flow1.FlowNode<UploadFile, UploadFile, _uploadista_core_errors0.UploadistaError>, never, never>;
+}: ConditionalParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: zod0.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  outputSchema: zod0.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<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, _uploadista_core_errors0.UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, never>;
 //#endregion
 //#region src/nodes/merge-node.d.ts
 declare function createMergeNode(id: string, {
   strategy,
   separator: _separator
-}: MergeParams): Effect.Effect<_uploadista_core_flow1.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
+}: MergeParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: z.ZodType<Record<string, UploadFile>, unknown, z.core.$ZodTypeInternals<Record<string, UploadFile>, unknown>>;
+  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: Record<string, UploadFile>;
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer>;
 //#endregion
 //#region src/nodes/multiplex-node.d.ts
 declare function createMultiplexNode(id: string, {
   outputCount: _outputCount,
   strategy
-}: MultiplexParams): Effect.Effect<_uploadista_core_flow1.FlowNode<UploadFile, UploadFile, UploadistaError>, never, UploadServer>;
+}: MultiplexParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: zod0.ZodType<UploadFile, unknown, zod_v4_core0.$ZodTypeInternals<UploadFile, unknown>>;
+  outputSchema: zod0.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<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer>;
 //#endregion
 //#region src/nodes/zip-node.d.ts
 declare function createZipNode(id: string, {
   zipName,
   includeMetadata
-}: ZipParams): Effect.Effect<_uploadista_core_flow1.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer | ZipPlugin>;
+}: ZipParams): Effect.Effect<_uploadista_core_flow1.FlowNodeData & {
+  inputSchema: z.ZodType<Record<string, UploadFile>, unknown, z.core.$ZodTypeInternals<Record<string, UploadFile>, unknown>>;
+  outputSchema: z.ZodType<UploadFile, unknown, z.core.$ZodTypeInternals<UploadFile, unknown>>;
+  run: (args: {
+    data: Record<string, UploadFile>;
+    jobId: string;
+    storageId: string;
+    flowId: string;
+    inputs?: Record<string, unknown>;
+    clientId: string | null;
+  }) => Effect.Effect<_uploadista_core_flow1.NodeExecutionResult<UploadFile>, UploadistaError, never>;
+  condition?: {
+    field: string;
+    operator: string;
+    value: unknown;
+  };
+  multiInput?: boolean;
+  multiOutput?: boolean;
+  pausable?: boolean;
+  retry?: {
+    maxRetries?: number;
+    retryDelay?: number;
+    exponentialBackoff?: boolean;
+  };
+} & {
+  type: NodeType;
+}, never, UploadServer | ZipPlugin>;
 //#endregion
 export { createConditionalNode, createMergeNode, createMultiplexNode, createZipNode };
 //# sourceMappingURL=index.d.mts.map

package/dist/nodes/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,wBAAA,CAAA,eAAA;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA;;;iBCLlC,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,yBAAA;;;iBCE1C,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA,eAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;;;;IAF/B,QAAA,EAAA,MAAA,GAAA,IAAqB;EAEjC,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,4CAAA,KAAA,CAAA;EAAO,SAAA,CAAA,EAAA;IAAU,KAAA,EAAA,MAAA;IAAS,QAAA,EAAA,MAAA;IAAiB,KAAA,EAAA,OAAA;;;;;;;;;;;;;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;IDRlC,SAAA,EAAA,MAAA;IAEZ,MAAA,EAAA,MAAA;IAAO,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAU,QAAA,EAAA,MAAA,GAAA,IAAA;EAAS,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAiB,SAAA,CAAA,EAAA;;;;;;;;;;;;;;;;;;iBEC/B,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;;IFL1C,MAAA,EAAA,MAAA;IAEZ,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAO,QAAA,EAAA,MAAA,GAAA,IAAA;EAAU,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAS,SAAA,CAAA,EAAA;IAAiB,KAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;iBGK/B,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,YAAA;;;;;;IHTzB,SAAA,EAAA,MAAA;IAEZ,MAAA,EAAA,MAAA;IAAO,MAAA,CAAA,QAAA,CAAA,MAAA,EAAA,OAAA,CAAA;IAAU,QAAA,EAAA,MAAA,GAAA,IAAA;EAAS,CAAA,EAAA,gBAAA,2CAAA,WAAA,CAAA,iBAAA,EAAA,KAAA,CAAA;EAAiB,SAAA,CAAA,EAAA"}

package/dist/types/index.d.cts

@@ -1,2 +1,2 @@
-import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BbFUu_Oc.cjs";
+import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-Brh9A17P.cjs";
 export { ConditionalParams, MergeParams, MultiplexParams, ZipParams, conditionalParamsSchema, mergeParamsSchema, multiplexParamsSchema, zipParamsSchema };

package/dist/types/index.d.mts

@@ -1,2 +1,2 @@
-import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-bdgJgJHI.mjs";
+import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-7DDOD4H0.mjs";
 export { ConditionalParams, MergeParams, MultiplexParams, ZipParams, conditionalParamsSchema, mergeParamsSchema, multiplexParamsSchema, zipParamsSchema };

package/dist/{zip-node-BbFUu_Oc.d.cts → zip-node-7DDOD4H0.d.mts}

@@ -3,19 +3,19 @@ import { z } from "zod";
 //#region src/types/conditional-node.d.ts
 declare const conditionalParamsSchema: z.ZodObject<{
   field: z.ZodEnum<{
-    size: "size";
     mimeType: "mimeType";
+    size: "size";
     width: "width";
     height: "height";
     extension: "extension";
   }>;
   operator: z.ZodEnum<{
-    startsWith: "startsWith";
     equals: "equals";
     notEquals: "notEquals";
     greaterThan: "greaterThan";
     lessThan: "lessThan";
     contains: "contains";
+    startsWith: "startsWith";
   }>;
   value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 }, z.core.$strip>;
@@ -36,8 +36,8 @@ type MergeParams = z.infer<typeof mergeParamsSchema>;
 declare const multiplexParamsSchema: z.ZodObject<{
   outputCount: z.ZodNumber;
   strategy: z.ZodDefault<z.ZodEnum<{
-    split: "split";
     copy: "copy";
+    split: "split";
   }>>;
 }, z.core.$strip>;
 type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
@@ -51,4 +51,4 @@ declare const zipParamsSchema: z.ZodObject<{
 type ZipParams = z.infer<typeof zipParamsSchema>;
 //#endregion
 export { MergeParams as a, conditionalParamsSchema as c, multiplexParamsSchema as i, zipParamsSchema as n, mergeParamsSchema as o, MultiplexParams as r, ConditionalParams as s, ZipParams as t };
-//# sourceMappingURL=zip-node-BbFUu_Oc.d.cts.map
+//# sourceMappingURL=zip-node-7DDOD4H0.d.mts.map

package/dist/{zip-node-BbFUu_Oc.d.cts.map → zip-node-7DDOD4H0.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"zip-node-BbFUu_Oc.d.cts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,IAAA,EAAA,MAAA;;;;;;;IAAuB,UAAA,EAAA,YAAA;IAAA,MAAA,EAAA,QAAA;IAaxB,SAAA,EAAA,WAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}
+{"version":3,"file":"zip-node-7DDOD4H0.d.mts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,QAAA,EAAA,UAAA;;;;;;;IAAuB,MAAA,EAAA,QAAA;IAAA,SAAA,EAAA,WAAA;IAaxB,WAAA,EAAA,aAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}

package/dist/{zip-node-bdgJgJHI.d.mts → zip-node-Brh9A17P.d.cts}

@@ -3,19 +3,19 @@ import { z } from "zod";
 //#region src/types/conditional-node.d.ts
 declare const conditionalParamsSchema: z.ZodObject<{
   field: z.ZodEnum<{
-    size: "size";
     mimeType: "mimeType";
+    size: "size";
     width: "width";
     height: "height";
     extension: "extension";
   }>;
   operator: z.ZodEnum<{
-    startsWith: "startsWith";
     equals: "equals";
     notEquals: "notEquals";
     greaterThan: "greaterThan";
     lessThan: "lessThan";
     contains: "contains";
+    startsWith: "startsWith";
   }>;
   value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 }, z.core.$strip>;
@@ -36,8 +36,8 @@ type MergeParams = z.infer<typeof mergeParamsSchema>;
 declare const multiplexParamsSchema: z.ZodObject<{
   outputCount: z.ZodNumber;
   strategy: z.ZodDefault<z.ZodEnum<{
-    split: "split";
     copy: "copy";
+    split: "split";
   }>>;
 }, z.core.$strip>;
 type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
@@ -51,4 +51,4 @@ declare const zipParamsSchema: z.ZodObject<{
 type ZipParams = z.infer<typeof zipParamsSchema>;
 //#endregion
 export { MergeParams as a, conditionalParamsSchema as c, multiplexParamsSchema as i, zipParamsSchema as n, mergeParamsSchema as o, MultiplexParams as r, ConditionalParams as s, ZipParams as t };
-//# sourceMappingURL=zip-node-bdgJgJHI.d.mts.map
+//# sourceMappingURL=zip-node-Brh9A17P.d.cts.map

package/dist/{zip-node-bdgJgJHI.d.mts.map → zip-node-Brh9A17P.d.cts.map}

@@ -1 +1 @@
-{"version":3,"file":"zip-node-bdgJgJHI.d.mts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,IAAA,EAAA,MAAA;;;;;;;IAAuB,UAAA,EAAA,YAAA;IAAA,MAAA,EAAA,QAAA;IAaxB,SAAA,EAAA,WAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}
+{"version":3,"file":"zip-node-Brh9A17P.d.cts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,QAAA,EAAA,UAAA;;;;;;;IAAuB,MAAA,EAAA,QAAA;IAAA,SAAA,EAAA,WAAA;IAaxB,WAAA,EAAA,aAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/flow-utility-nodes",
   "type": "module",
-  "version": "0.0.13-beta.4",
+  "version": "0.0.13",
   "description": "Utility nodes for Uploadista Flow",
   "license": "MIT",
   "author": "Uploadista",
@@ -20,19 +20,24 @@
     }
   },
   "dependencies": {
-    "effect": "3.19.2",
+    "effect": "3.19.3",
     "zod": "4.1.12",
-    "@uploadista/core": "0.0.13-beta.4"
+    "@uploadista/core": "0.0.13"
   },
   "devDependencies": {
-    "@types/node": "24.10.0",
-    "tsdown": "0.16.0",
-    "@uploadista/typescript-config": "0.0.13-beta.4"
+    "@effect/vitest": "0.27.0",
+    "@types/node": "24.10.1",
+    "tsdown": "0.16.3",
+    "vitest": "4.0.8",
+    "@uploadista/typescript-config": "0.0.13"
   },
   "scripts": {
     "build": "tsdown",
+    "check": "biome check --write ./src",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
-    "check": "biome check --write ./src"
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:watch": "vitest --watch"
   }
 }

package/tests/utility-nodes.test.ts

@@ -0,0 +1,779 @@
+import { describe, expect, it } from "@effect/vitest";
+import { UploadistaError } from "@uploadista/core/errors";
+import {
+  TestUploadServer,
+  TestZipPlugin,
+} from "@uploadista/core/testing";
+import type { UploadFile } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+import {
+  createConditionalNode,
+  createMergeNode,
+  createMultiplexNode,
+  createZipNode,
+} from "../src/nodes";
+
+/**
+ * Test utilities for creating sample UploadFile objects
+ */
+const createTestUploadFile = (
+  id: string,
+  overrides?: Partial<UploadFile>,
+): UploadFile => ({
+  id,
+  offset: 0,
+  size: 1024,
+  storage: {
+    id: "test-storage",
+    type: "memory",
+  },
+  metadata: {
+    mimeType: "text/plain",
+    originalName: `file-${id}.txt`,
+    extension: "txt",
+  },
+  creationDate: new Date().toISOString(),
+  ...overrides,
+});
+
+const createTestImageFile = (
+  id: string,
+  width: number,
+  height: number,
+): UploadFile =>
+  createTestUploadFile(id, {
+    metadata: {
+      mimeType: "image/jpeg",
+      originalName: `image-${id}.jpg`,
+      extension: "jpg",
+      width,
+      height,
+    },
+  });
+
+/**
+ * Test layer combining all mocks
+ */
+const TestLayer = Layer.mergeAll(TestUploadServer, TestZipPlugin);
+
+describe("Utility Nodes", () => {
+  describe("ConditionalNode", () => {
+    it.effect("should create conditional node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-1", {
+          field: "mimeType",
+          operator: "equals",
+          value: "image/jpeg",
+        });
+
+        expect(node.id).toBe("cond-1");
+        expect(node.name).toBe("Conditional Router");
+        expect(node.description).toContain("Routes flow based on");
+        expect(node.condition).toEqual({
+          field: "mimeType",
+          operator: "equals",
+          value: "image/jpeg",
+        });
+      }),
+    );
+
+    it.effect("should pass through data unchanged", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-2", {
+          field: "size",
+          operator: "greaterThan",
+          value: 1000,
+        });
+
+        const testFile = createTestUploadFile("test-1");
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toEqual(testFile);
+        }
+      }),
+    );
+
+    it.effect("should create node with equals operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-equals", {
+          field: "extension",
+          operator: "equals",
+          value: "jpg",
+        });
+
+        expect(node.condition?.operator).toBe("equals");
+      }),
+    );
+
+    it.effect("should create node with notEquals operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-not-equals", {
+          field: "mimeType",
+          operator: "notEquals",
+          value: "image/png",
+        });
+
+        expect(node.condition?.operator).toBe("notEquals");
+      }),
+    );
+
+    it.effect("should create node with greaterThan operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-gt", {
+          field: "size",
+          operator: "greaterThan",
+          value: 5000,
+        });
+
+        expect(node.condition?.operator).toBe("greaterThan");
+        expect(node.condition?.value).toBe(5000);
+      }),
+    );
+
+    it.effect("should create node with lessThan operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-lt", {
+          field: "width",
+          operator: "lessThan",
+          value: 1920,
+        });
+
+        expect(node.condition?.operator).toBe("lessThan");
+      }),
+    );
+
+    it.effect("should create node with contains operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-contains", {
+          field: "mimeType",
+          operator: "contains",
+          value: "image",
+        });
+
+        expect(node.condition?.operator).toBe("contains");
+      }),
+    );
+
+    it.effect("should create node with startsWith operator", () =>
+      Effect.gen(function* () {
+        const node = yield* createConditionalNode("cond-starts", {
+          field: "extension",
+          operator: "startsWith",
+          value: "jp",
+        });
+
+        expect(node.condition?.operator).toBe("startsWith");
+      }),
+    );
+
+    it.effect("should work with different field types", () =>
+      Effect.gen(function* () {
+        const fields: Array<
+          "mimeType" | "size" | "width" | "height" | "extension"
+        > = ["mimeType", "size", "width", "height", "extension"];
+
+        for (const field of fields) {
+          const node = yield* createConditionalNode(`cond-${field}`, {
+            field,
+            operator: "equals",
+            value: field === "size" ? 1000 : "test",
+          });
+
+          expect(node.condition?.field).toBe(field);
+        }
+      }),
+    );
+  });
+
+  describe("MergeNode", () => {
+    it.effect("should merge multiple files using concat strategy", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-1", {
+          strategy: "concat",
+        });
+
+        const file1 = createTestUploadFile("file-1");
+        const file2 = createTestUploadFile("file-2");
+        const file3 = createTestUploadFile("file-3");
+
+        const result = yield* node.run({
+          data: {
+            input1: file1,
+            input2: file2,
+            input3: file3,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          if (result.data) {
+            expect(result.data.metadata?.mimeType).toBe(
+              "application/octet-stream",
+            );
+            expect(result.data.metadata?.extension).toBe("bin");
+            expect(result.data.size).toBeGreaterThan(0);
+          }
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should handle single file input", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-single", {
+          strategy: "concat",
+        });
+
+        const file1 = createTestUploadFile("single-file");
+
+        const result = yield* node.run({
+          data: {
+            input1: file1,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          expect(result.data.metadata?.mimeType).toBe(
+            "application/octet-stream",
+          );
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with no inputs", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-empty", {
+          strategy: "concat",
+        });
+
+        const result = yield* Effect.either(
+          node.run({
+            data: {},
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+        if (result._tag === "Left") {
+          expect(result.left).toBeInstanceOf(UploadistaError);
+          expect(result.left.code).toBe("VALIDATION_ERROR");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with null inputs", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-null", {
+          strategy: "concat",
+        });
+
+        const result = yield* Effect.either(
+          node.run({
+            data: null as any,
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with unknown strategy", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-unknown", {
+          strategy: "unknown" as any,
+        });
+
+        const file1 = createTestUploadFile("file-1");
+
+        const result = yield* Effect.either(
+          node.run({
+            data: { input1: file1 },
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+        if (result._tag === "Left") {
+          expect(result.left).toBeInstanceOf(UploadistaError);
+          expect(result.left.body).toContain("Unknown merge strategy");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should preserve file order in concat", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-order", {
+          strategy: "concat",
+        });
+
+        const file1 = createTestUploadFile("first");
+        const file2 = createTestUploadFile("second");
+        const file3 = createTestUploadFile("third");
+
+        const result = yield* node.run({
+          data: {
+            a: file1,
+            b: file2,
+            c: file3,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          expect(result.data.metadata?.originalName).toContain(
+            "merged_3_files",
+          );
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should create node with proper metadata", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergeNode("merge-meta", {
+          strategy: "concat",
+        });
+
+        expect(node.id).toBe("merge-meta");
+        expect(node.name).toBe("Merge Files");
+        expect(node.description).toContain("concat strategy");
+        expect(node.multiInput).toBe(true);
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("MultiplexNode", () => {
+    it.effect("should multiplex file using copy strategy", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-1", {
+          outputCount: 3,
+          strategy: "copy",
+        });
+
+        const testFile = createTestUploadFile("source-file");
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          expect(result.data.id).not.toBe(testFile.id);
+          expect(result.data.metadata?.mimeType).toBe("text/plain");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should preserve metadata when copying", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-meta", {
+          outputCount: 2,
+          strategy: "copy",
+        });
+
+        const testFile = createTestImageFile("image-1", 800, 600);
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.mimeType).toBe("image/jpeg");
+          expect(result.data.metadata?.extension).toBe("jpg");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should handle metadata as string", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-string-meta", {
+          outputCount: 1,
+          strategy: "copy",
+        });
+
+        const testFile = createTestUploadFile("file-with-string-meta", {
+          metadata: {
+            mimeType: "application/pdf",
+            originalName: "document.pdf",
+          },
+        });
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with split strategy", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-split", {
+          outputCount: 2,
+          strategy: "split",
+        });
+
+        const testFile = createTestUploadFile("test-file");
+
+        const result = yield* Effect.either(
+          node.run({
+            data: testFile,
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+        if (result._tag === "Left") {
+          expect(result.left).toBeInstanceOf(UploadistaError);
+          expect(result.left.body).toContain("Split strategy is not supported");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with unknown strategy", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-unknown", {
+          outputCount: 2,
+          strategy: "invalid" as any,
+        });
+
+        const testFile = createTestUploadFile("test-file");
+
+        const result = yield* Effect.either(
+          node.run({
+            data: testFile,
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+        if (result._tag === "Left") {
+          expect(result.left).toBeInstanceOf(UploadistaError);
+          expect(result.left.body).toContain("Unknown multiplex strategy");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should create node with proper metadata", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-props", {
+          outputCount: 5,
+          strategy: "copy",
+        });
+
+        expect(node.id).toBe("multiplex-props");
+        expect(node.name).toBe("Multiplex");
+        expect(node.description).toContain("copy strategy");
+        expect(node.multiOutput).toBe(true);
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should handle large files", () =>
+      Effect.gen(function* () {
+        const node = yield* createMultiplexNode("multiplex-large", {
+          outputCount: 2,
+          strategy: "copy",
+        });
+
+        const largeFile = createTestUploadFile("large-file", {
+          size: 10 * 1024 * 1024, // 10MB
+        });
+
+        const result = yield* node.run({
+          data: largeFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("ZipNode", () => {
+    it.effect("should create zip from multiple files", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-1", {
+          zipName: "archive.zip",
+          includeMetadata: false,
+        });
+
+        const file1 = createTestUploadFile("file-1");
+        const file2 = createTestUploadFile("file-2");
+        const file3 = createTestUploadFile("file-3");
+
+        const result = yield* node.run({
+          data: {
+            input1: file1,
+            input2: file2,
+            input3: file3,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          expect(result.data.metadata?.mimeType).toBe("application/zip");
+          expect(result.data.metadata?.extension).toBe("zip");
+          expect(result.data.metadata?.fileName).toBe("archive.zip");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should include metadata when requested", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-with-meta", {
+          zipName: "files-with-metadata.zip",
+          includeMetadata: true,
+        });
+
+        const file1 = createTestImageFile("img-1", 1920, 1080);
+        const file2 = createTestImageFile("img-2", 800, 600);
+
+        const result = yield* node.run({
+          data: {
+            image1: file1,
+            image2: file2,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.fileName).toBe(
+            "files-with-metadata.zip",
+          );
+          expect(result.data.size).toBeGreaterThan(0);
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should handle custom zip names", () =>
+      Effect.gen(function* () {
+        const customName = "my-custom-archive-2024.zip";
+        const node = yield* createZipNode("zip-custom-name", {
+          zipName: customName,
+          includeMetadata: false,
+        });
+
+        const file1 = createTestUploadFile("doc-1");
+
+        const result = yield* node.run({
+          data: { doc: file1 },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.fileName).toBe(customName);
+          expect(result.data.metadata?.originalName).toBe(customName);
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with no inputs", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-empty", {
+          zipName: "empty.zip",
+          includeMetadata: false,
+        });
+
+        const result = yield* Effect.either(
+          node.run({
+            data: {},
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+        if (result._tag === "Left") {
+          expect(result.left).toBeInstanceOf(UploadistaError);
+          expect(result.left.code).toBe("VALIDATION_ERROR");
+          expect(result.left.body).toContain("No inputs provided to zip node");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should fail with null inputs", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-null", {
+          zipName: "null.zip",
+          includeMetadata: false,
+        });
+
+        const result = yield* Effect.either(
+          node.run({
+            data: null as any,
+            jobId: "test-job",
+            flowId: "test-flow",
+            storageId: "test-storage",
+            clientId: "test-client",
+          }),
+        );
+
+        expect(result._tag).toBe("Left");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should create node with proper metadata", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-props", {
+          zipName: "test.zip",
+          includeMetadata: true,
+        });
+
+        expect(node.id).toBe("zip-props");
+        expect(node.name).toBe("Zip Files");
+        expect(node.description).toBe(
+          "Combines multiple files into a zip archive",
+        );
+        expect(node.multiInput).toBe(true);
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should handle multiple files with different types", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-mixed", {
+          zipName: "mixed-files.zip",
+          includeMetadata: false,
+        });
+
+        const textFile = createTestUploadFile("text-file");
+        const imageFile = createTestImageFile("image-file", 640, 480);
+        const pdfFile = createTestUploadFile("pdf-file", {
+          metadata: {
+            mimeType: "application/pdf",
+            originalName: "document.pdf",
+            extension: "pdf",
+          },
+        });
+
+        const result = yield* node.run({
+          data: {
+            text: textFile,
+            image: imageFile,
+            pdf: pdfFile,
+          },
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          expect(result.data.metadata?.mimeType).toBe("application/zip");
+          expect(result.data.size).toBeGreaterThan(0);
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should process files concurrently", () =>
+      Effect.gen(function* () {
+        const node = yield* createZipNode("zip-concurrent", {
+          zipName: "concurrent.zip",
+          includeMetadata: false,
+        });
+
+        // Create many files to test concurrent processing
+        const files: Record<string, UploadFile> = {};
+        for (let i = 0; i < 10; i++) {
+          files[`file${i}`] = createTestUploadFile(`file-${i}`);
+        }
+
+        const startTime = Date.now();
+
+        const result = yield* node.run({
+          data: files,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        const duration = Date.now() - startTime;
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+          // Should complete reasonably quickly even with 10 files
+          expect(duration).toBeLessThan(5000);
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * Shared vitest configuration template for uploadista-sdk packages
+ *
+ * This template should be used by all SDK packages to ensure consistent
+ * testing configuration across the monorepo.
+ *
+ * Key features:
+ * - Tests in dedicated `tests/` directories (not colocated with src)
+ * - Node environment for server-side code
+ * - V8 coverage provider
+ * - Global test functions available
+ * - Effect testing support via @effect/vitest
+ *
+ * Usage:
+ * Copy this file to your package root as `vitest.config.ts` and customize
+ * if needed (though most packages should use this as-is).
+ */
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    exclude: ["node_modules", "dist"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "**/*.d.ts",
+        "**/*.test.ts",
+        "**/*.spec.ts",
+        "tests/",
+      ],
+    },
+  },
+});