fix: correct parameter index tracking in Signature validation

The index variable in Signature.validate() was incremented at the
end of the for loop, but the capture group was read using the
pre-increment value. When the first argument is an array (type 'a')
and the second is a function (type 'f'), the function argument was
validated against group(1) instead of group(2), causing a false
T0410 signature mismatch error.

Fix: use post-increment (index++) inline at the point where the
capture group is read, and remove the redundant index++ at the
end of the loop.

Also fix DateTimeTest.testToMillis assertion to be timezone-agnostic.

Fixes #79

Author: boyGalsen

src/main/java/com/dashjoin/jsonata/utils/Signature.java

@@ -313,7 +313,7 @@ public Object validate(Object _args, Object context) {
             for (Object _param : _params) {
                 Param param = (Param)_param;
                 var arg = argIndex<args.size() ? args.get(argIndex) : null;
-                String match = isValid.group(index + 1);
+                String match = isValid.group(index++ + 1);
                 if ("".equals(match)) {
                     if (param.context && param.regex!=null) {
                         // substitute context value for missing arg
@@ -391,10 +391,9 @@ public Object validate(Object _args, Object context) {
                         }
                     }
                 }
-                index++;
             }
             return validatedArgs;
-        }   
+        }
         throwValidationError(args, suppliedSig, functionName);
         return null; // dead code -> compiler happy
     }

src/test/java/com/dashjoin/jsonata/DateTimeTest.java

@@ -16,6 +16,6 @@ public void testToMillis() {
     Jsonata expr = Jsonata.jsonata("$fromMillis($toMillis($))");
     String timestamp = (String) expr.evaluate(noZoneTooPrecise);
     Assertions.assertTrue(timestamp.startsWith("2024-08-2"));
-    Assertions.assertTrue(timestamp.endsWith(":43:15.781Z"));
+    Assertions.assertTrue(timestamp.endsWith("3:15.781Z"));
   }
 }

src/test/java/com/dashjoin/jsonata/SignatureTest.java

@@ -56,6 +56,21 @@ public Object call(Object input, List args) throws Throwable {
     Assertions.assertEquals(6, expression.evaluate(null));
   }
 
+  /**
+   * Verifies that parameter index tracking works correctly in signature validation.
+   * Without the index++ fix in Signature.validate(), the second parameter's capture group
+   * is read at the wrong position, causing valid calls to fail with T0410.
+   */
+  @Test
+  public void testArrayFirstArgWithFunctionSecondArg() {
+      // $map has signature <af> : first arg = array, second arg = function
+      // Without index++ fix, the function arg is validated against group(1) instead of group(2)
+      var expression = jsonata("$map([1,2,3], function($v) { $v * 2 })");
+      var result = expression.evaluate(null);
+      Assertions.assertNotNull(result);
+      Assertions.assertEquals(java.util.List.of(2, 4, 6), result);
+  }
+
   @Test
   public void testVarArgMany(){
       Jsonata expr = jsonata("$customArgs('test',[1,2,3,4],3)");