@@ -237,6 +237,7 @@ All rules from `@regle/rules` are re-exported from this package. Commonly used r
 | `withMessage` | Attaches a custom message to any rule                      |
 | `isFilled`    | Type guard: checks if a value is defined                   |
 | `outOfRange`  | Number must be between `min` and `max` (passes when empty) |
+| `queryFilter` | String must be a parsable query filter (passes when empty) |
 
 `type Maybe<T>` and `type FormRuleDeclaration<T>` are also re-exported for use in custom validator signatures.
 
 
@@ -0,0 +1,20 @@
+import { createRule, type Maybe } from '@regle/core'
+import { isFilled } from '@regle/rules'
+import { parse } from 'complex-matcher'
+
+export const queryFilter = createRule({
+  validator(value: Maybe<string>) {
+    if (!isFilled(value)) {
+      return true
+    }
+
+    try {
+      parse(value)
+
+      return true
+    } catch {
+      return false
+    }
+  },
+  message: 'Invalid query',
+})
@@ -3,6 +3,7 @@ export * from './custom-rules/port.rule.ts'
 export * from './custom-rules/ipv4-or-cidr.rule.ts'
 export * from './custom-rules/ip-addresses.rule.ts'
 export * from './custom-rules/ip.regex.ts'
+export * from './custom-rules/query-filter.rule.ts'
 export * from './merge-validation-configs.ts'
 export * from './types.ts'
 export * from './use-form-validation.ts'
 
@@ -3,7 +3,6 @@ import type {
   FormFieldMetadata,
   FormRuleTree,
   FormValidationConfig,
-  FormValidationRules,
   UseFormValidationReturn,
 } from './types.ts'
 import { useRegle } from '@regle/core'
@@ -21,45 +20,6 @@ type RegleStatusAccessor = {
   $touch: () => void
 }
 
-/**
- * Automatically injects `$each: {}` into the rule tree for every field whose
- * current value is an array, if that field is present in the rules but has no
- * `$each` declared yet.
- *
- * This is required because Regle needs `$each` to know a field is a collection
- * and to produce the `{ $self, $each }` error shape instead of a flat string[].
- */
-function injectCollectionMarkers<TData extends Record<string, unknown>>(
-  data: TData,
-  rules: FormValidationRules<TData>
-): FormValidationRules<TData> {
-  const arrayKeys = Object.keys(data).filter(key => Array.isArray(data[key]))
-
-  if (arrayKeys.length === 0) {
-    return rules
-  }
-
-  const inject = (ruleTree: FormRuleTree<TData>): FormRuleTree<TData> => {
-    const result = { ...ruleTree } as Record<string, unknown>
-
-    for (const key of arrayKeys) {
-      const fieldRules = result[key]
-
-      if (fieldRules !== null && typeof fieldRules === 'object' && !('$each' in fieldRules)) {
-        result[key] = { ...(fieldRules as object), $each: {} }
-      }
-    }
-
-    return result as FormRuleTree<TData>
-  }
-
-  if (typeof rules === 'function') {
-    return () => inject((rules as () => FormRuleTree<TData>)())
-  }
-
-  return inject(rules)
-}
-
 /**
  * Calls `useRegle` with a simplified signature.
  *
@@ -81,9 +41,10 @@ function toMessage(fieldErrors: unknown): string | undefined {
     return fieldErrors[0]
   }
 
-  // Collection-field errors take the { $self: string[], $each: ... } shape ? surface the first $self message.
+  // Collection-field errors take the { $self: string[], $each: ... } shape: surface the first $self message.
   if (fieldErrors !== null && typeof fieldErrors === 'object' && '$self' in fieldErrors) {
     const $self = (fieldErrors as { $self?: unknown }).$self
+
     if (Array.isArray($self)) {
       return $self[0]
     }
@@ -113,21 +74,10 @@ export function useFormValidation<TData extends Record<string, unknown>>(
 ): UseFormValidationReturn<TData> {
   // All four useRegle calls must be unconditional — Vue composables cannot be called conditionally.
   // When a group has no rules, an empty rule tree produces an empty $fields map.
-  // injectCollectionMarkers ensures array fields always have $each declared so Regle produces
-  // the { $self, $each } error shape.
-  const { r$: blurErrors$ } = callUseRegle(data, injectCollectionMarkers(data, config.errors?.onBlur ?? EMPTY_RULES))
-  const { r$: submitErrors$ } = callUseRegle(
-    data,
-    injectCollectionMarkers(data, config.errors?.onSubmit ?? EMPTY_RULES)
-  )
-  const { r$: blurWarnings$ } = callUseRegle(
-    data,
-    injectCollectionMarkers(data, config.warnings?.onBlur ?? EMPTY_RULES)
-  )
-  const { r$: submitWarnings$ } = callUseRegle(
-    data,
-    injectCollectionMarkers(data, config.warnings?.onSubmit ?? EMPTY_RULES)
-  )
+  const { r$: blurErrors$ } = callUseRegle(data, config.errors?.onBlur ?? EMPTY_RULES)
+  const { r$: submitErrors$ } = callUseRegle(data, config.errors?.onSubmit ?? EMPTY_RULES)
+  const { r$: blurWarnings$ } = callUseRegle(data, config.warnings?.onBlur ?? EMPTY_RULES)
+  const { r$: submitWarnings$ } = callUseRegle(data, config.warnings?.onSubmit ?? EMPTY_RULES)
 
   // Cast at the Regle boundary: Regle's inferred types are too complex to thread through
   // generics here, but the runtime shape is always compatible with RegleStatusAccessor.
 
@@ -228,11 +228,12 @@ Each step config is a `FormValidationConfig` scoped to its own sub-object: writi
 
 #### Navigation
 
-| Property      | Type                                 | Description                                                                                                           |
-| ------------- | ------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
-| `currentStep` | `ComputedRef<keyof TSteps & string>` | The currently active step name                                                                                        |
-| `next`        | `() => Promise<boolean>`             | Validates the current step; advances to the next step only if validation passes. Returns `true` if the step was valid |
-| `back`        | `() => void`                         | Goes to the previous step without validation                                                                          |
+| Property      | Type                                    | Description                                                                                                           |
+| ------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| `currentStep` | `ComputedRef<keyof TSteps & string>`    | The currently active step name                                                                                        |
+| `next`        | `() => Promise<boolean>`                | Validates the current step; advances to the next step only if validation passes. Returns `true` if the step was valid |
+| `back`        | `() => void`                            | Goes to the previous step without validation                                                                          |
+| `backTo`      | `(step: keyof TSteps & string) => void` | Goes back to an earlier step without validation; does nothing if the step is not before the current one               |
 
 #### Validation state
 
 
@@ -106,6 +106,14 @@ export function useMultiStepValidatedForm<
     }
   }
 
+  function backTo(stepName: keyof TSteps & string): void {
+    const stepIndex = stepKeys.indexOf(stepName)
+
+    if (stepIndex < currentStepIndex.value) {
+      currentStepIndex.value = stepIndex
+    }
+  }
+
   function resolveStepFromField<K extends FlatKeys<TData>>(key: K): keyof TData & string {
     const stepKey = fieldToStep.get(key)
 
@@ -190,6 +198,7 @@ export function useMultiStepValidatedForm<
     currentStep,
     next,
     back,
+    backTo,
     isStepValid,
     areAllStepsValid,
     isValidating,