@omnitend/dashboard-for-laravel 0.47.0 → 0.47.2

package/dist/types/index.d.ts

@@ -219,7 +219,9 @@ export interface FieldDefinition {
      * For a field whose value is a list of rows (a `repeater`, or a span
      * field that renders its own rows and owns `key.N.*` error keys): the
      * row's own name, called with the row (`model[key][index]`, or `{}` when
-     * the model has no such row) and its 0-based index. When it returns a
+     * the model has no such row) and its 0-based index (for a failure's row
+     * that has since moved, its current index; once removed, the index it
+     * failed at: the index "(line N)" counts). When it returns a
      * non-empty string, the error summary lists that row's errors under it
      * alone ("Chaucer Ale (Pint): Enter a price.") instead of
      * "<sub-field label> (line N)". Returning `undefined`, `null` or `""`
@@ -359,6 +361,8 @@ export interface BaseFieldDef {
     plaintext?: MaybeFn<boolean>;
     submit?: boolean;
     errorKeys?: string[];
+    /** On a repeater, or a span field that renders its own rows. */
+    rowLabel?: (row: Record<string, any>, index: number) => string | null | undefined;
     when?: MaybeFn<boolean>;
     show?: () => boolean;
 }
@@ -461,7 +465,6 @@ export interface ComponentFieldDef extends BaseFieldDef {
 export interface RepeaterFieldDef extends BaseFieldDef {
     type: "repeater";
     fields?: FieldDef[];
-    rowLabel?: (row: Record<string, any>, index: number) => string | null | undefined;
     addLabel?: string;
     minItems?: number;
     maxItems?: number;
@@ -508,13 +511,16 @@ export interface FormTab {
 }
 /**
  * Slot props of DXField's `password-actions` slot (DXForm:
- * `password-actions(<key>)`): content placed beside a password input, inside
- * its input group after the reveal (eye) toggle, such as a "Generate password"
- * button. `setRevealed` drives the same state the eye toggles.
+ * `password-actions(<key>)`): content placed beside a password input, such as
+ * a "Generate password" button. It renders after the input group (the input
+ * and the reveal (eye) toggle), in `.dx-password-field__actions`, and wraps
+ * onto its own line below the input when the row is too narrow to keep
+ * `--dx-password-input-min-width`. `setRevealed` drives the same state the
+ * eye toggles.
  *
  * ```vue
  * <template #password-actions(password)="{ update, setRevealed, disabled }">
- *   <DButton variant="outline-secondary" :disabled="disabled"
+ *   <DButton variant="secondary" :disabled="disabled"
  *     @click="update(generatePassword()); setRevealed(true)">Generate</DButton>
  * </template>
  * ```

package/dist/utils/formErrorTargets.d.ts

@@ -1,18 +1,19 @@
-/**
- * Which field a validation-error key belongs to (#194).
- *
- * One pure function decides, so the error summary's rows, the tab a failed
- * submit selects and the field it scrolls to can never disagree. No Vue: the
- * caller injects visibility and label resolution, so DXForm can pass its own
- * `when`/`context`-aware predicates and a standalone summary can use the
- * defaults below.
- */
 import type { FieldDefinition, FormTab } from "../types";
-import type { ValidationErrors } from "../composables/useForm";
+import type { FailedRow, ValidationErrors } from "../composables/useForm";
 /** One error key and where it belongs. */
 export interface ErrorTarget {
     /** The key as the server sent it (`lines.0.price`). */
     errorKey: string;
+    /**
+     * Where to take the user for this error now. The same as `errorKey`,
+     * except for a row error resolved with `failedRows`: the key at the
+     * failed row's CURRENT index (`lines.1.price` once row 0 is removed),
+     * or the owning field's key when that row is gone (removed, replaced, or
+     * flagged by the field's `softDeleteKey`); DXForm then focuses the
+     * field's container, not a row. Always set by `resolveErrorTargets`;
+     * optional so targets built by hand still type.
+     */
+    focusKey?: string;
     /** The server's messages for that key, as sent. */
     messages: string[];
     /**
@@ -55,6 +56,14 @@ export interface ResolveErrorTargetsOptions {
      * humanised key, so a broken label can never hide an error.
      */
     resolveLabel?: (field: FieldDefinition, labelModel: Record<string, any>) => string | null | undefined;
+    /**
+     * The rows a failed submit's errors named, as captured then
+     * (`SubmitFailure.failedRows`). Pass it when resolving that failure's
+     * errors after the form may have changed (the error summary does), so a
+     * row error keeps the name of the row that failed and points at where
+     * that row is now. Leave it out for the form's live errors.
+     */
+    failedRows?: Record<string, FailedRow>;
 }
 /**
  * `delivery_date` → "Delivery date"; `lines.0.price` → "Lines price (line 1)".
@@ -79,7 +88,10 @@ export declare function humaniseErrorKey(key: string): string;
  * Labels: the owning field's label; for `field.N.sub` the sub-field's label
  * (when the field defines `fields` and one has that key) or the field's own,
  * plus "(line N+1)" — unless the field's `rowLabel` names that row, when
- * the row's name is the whole label; for any other nested key (a media map's
+ * the row's name is the whole label. With `failedRows`, a row key's label
+ * reads the row as it was when the submit failed, and its `focusKey` and
+ * line number follow that row to where it is now (see `ownedTarget`); for
+ * any other nested key (a media map's
  * `image_media.<uuid>`) the field's label. An unowned key is humanised.
  *
  * Display lines: "Label: message", except that the label is left off when

package/docs/public/api-reference.json

@@ -1,8 +1,8 @@
 {
-  "generated": "2026-10-21T10:08:54.451Z",
+  "generated": "2026-10-21T13:19:32.045Z",
   "package": {
     "name": "@omnitend/dashboard-for-laravel",
-    "version": "0.47.0"
+    "version": "0.47.2"
   },
   "components": {
     "base": [
@@ -2205,7 +2205,7 @@
                   "name": "(value: any) => void"
                 },
                 "name": "update",
-                "description": "Setter that writes the value back and clears the field's validation error."
+                "description": "Setter that writes the value back and clears the field's validation error, and every error under `<key>.` when the value is an array whose rows were added, removed, replaced or reordered (rows the slot draws itself)."
               }
             ]
           },
@@ -2287,7 +2287,7 @@
                   "name": "(value: any) => void"
                 },
                 "name": "update",
-                "description": "Setter that writes the value back and clears the field's validation error."
+                "description": "Setter that writes the value back and clears the field's validation error, and every error under `<key>.` when the value is an array whose rows were added, removed, replaced or reordered (rows the slot draws itself)."
               }
             ]
           },
@@ -4433,7 +4433,7 @@
           },
           {
             "name": "`edit-password-actions(${key})`",
-            "description": "Extra controls beside password field `<key>`'s input in the edit/create modal, inside its input group after the reveal (eye) toggle — e.g. a \"Generate password\" button. Name it `edit-password-actions(<fieldKey>)`.",
+            "description": "Extra controls beside password field `<key>`'s input in the edit/create modal, after its input group (the input and the reveal (eye) toggle); wraps below the input when the row is too narrow — e.g. a \"Generate password\" button. Name it `edit-password-actions(<fieldKey>)`.",
             "bindings": [
               {
                 "name": "name",

package/docs/public/docs-map.md

@@ -1,7 +1,7 @@
 # Documentation Map
 
 > Auto-generated hierarchical overview of all documentation
-> Last updated: 2026-10-21T10:08:54.546Z
+> Last updated: 2026-10-21T13:19:32.105Z
 
 This file provides a complete map of all available documentation for AI agents and developers.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnitend/dashboard-for-laravel",
-  "version": "0.47.0",
+  "version": "0.47.2",
   "description": "Vue 3 dashboard components for Laravel with Bootstrap Vue Next",
   "type": "module",
   "main": "./dist/dashboard-for-laravel.umd.cjs",

package/resources/js/components/extended/DXField.vue

@@ -22,14 +22,14 @@
           @binding {FieldDefinition} field The field definition being rendered.
           @binding {any} model The model passed to field predicates (defaults to the live form data).
           @binding {any} value The current field value.
-          @binding {(value: any) => void} update Setter that writes the value back and clears the field's validation error.
+          @binding {(value: any) => void} update Setter that writes the value back and clears the field's validation error, and every error under `<key>.` when the value is an array whose rows were added, removed, replaced or reordered (rows the slot draws itself).
         -->
         <slot
             name="span"
             :field="field"
             :model="model"
             :value="fieldValue"
-            :update="setValue"
+            :update="setValueFromSlot"
         />
     </div>
 
@@ -85,7 +85,7 @@
                 :field="field"
                 :model="model"
                 :value="fieldValue"
-                :update="setValue"
+                :update="setValueFromSlot"
             />
         </div>
         <!--
@@ -93,7 +93,7 @@
           @binding {FieldDefinition} field The field definition being rendered.
           @binding {any} model The model passed to field predicates (defaults to the live form data).
           @binding {any} value The current field value.
-          @binding {(value: any) => void} update Setter that writes the value back and clears the field's validation error.
+          @binding {(value: any) => void} update Setter that writes the value back and clears the field's validation error, and every error under `<key>.` when the value is an array whose rows were added, removed, replaced or reordered (rows the slot draws itself).
         -->
         <slot
             v-else-if="showValueSlot && $slots.value"
@@ -101,7 +101,7 @@
             :field="field"
             :model="model"
             :value="fieldValue"
-            :update="setValue"
+            :update="setValueFromSlot"
         />
         <template v-else>
             <!-- Checkbox (horizontal): the row label (shell #label) names the
@@ -420,6 +420,7 @@ import {
     onBeforeUnmount,
     provide,
     ref,
+    toRaw,
     useId,
     useSlots,
     watch,
@@ -744,6 +745,59 @@ function setValue(value: any): void {
     props.form.clearError(errorKey.value);
 }
 
+/** The raw rows of an array value, in order, or null for any other value. */
+function rowIdentitiesOf(value: unknown): unknown[] | null {
+    return Array.isArray(value) ? value.map((row) => toRaw(row)) : null;
+}
+
+/**
+ * The field's rows as last seen: refreshed by the watcher below whenever the
+ * array or its membership changes (not on edits inside a row), and by each
+ * slot `update`. The watcher runs before the next render, so a slot that
+ * changes the rows in place and calls `update` in the same handler is still
+ * compared against the rows from before the change.
+ */
+let lastSeenRows: unknown[] | null = null;
+watch(
+    () => rowIdentitiesOf(fieldValue.value),
+    (rows) => {
+        lastSeenRows = rows;
+    },
+    { immediate: true },
+);
+
+function haveRowsMoved(previous: unknown[] | null, next: unknown[]): boolean {
+    if (previous === null || previous.length !== next.length) return true;
+    return next.some((row, index) => row !== previous[index]);
+}
+
+/**
+ * `update` for the `span` and `value` slots (and so DXTable's `edit-span` /
+ * `edit-value`). Like a plain set, it clears the field's own error. When the
+ * value is an array whose rows changed (added, removed, replaced or
+ * reordered, compared by identity with the rows as last seen), it also
+ * clears every error under `<key>.` (`lines.3.price`), as the repeater's add
+ * and remove do: a per-row error would otherwise stay under whichever row
+ * now sits at its index. An update that keeps the same rows in the same
+ * order (a row editor writing the array back on each keystroke), or a
+ * value that is not an array (an `address` object), keeps the nested
+ * errors: they still name the right place. They come back on the next
+ * submit either way.
+ */
+function setValueFromSlot(value: any): void {
+    const nextRows = rowIdentitiesOf(value);
+    const rowsMoved = nextRows !== null && haveRowsMoved(lastSeenRows, nextRows);
+    setValue(value);
+    if (nextRows !== null) lastSeenRows = nextRows;
+    if (!rowsMoved) return;
+    const prefix = `${errorKey.value}.`;
+    for (const key of Object.keys(props.form.errors)) {
+        if (key.startsWith(prefix)) {
+            props.form.clearError(key);
+        }
+    }
+}
+
 const fieldState = computed(() => props.form.getState(errorKey.value));
 
 // A label function that throws falls back to the humanised key, as the
@@ -882,8 +936,13 @@ function setPasswordRevealed(revealed: boolean): void {
 // v-for is keyed on `field.key`, which is stable across rows) and swaps in a
 // fresh form per record. Without this, revealing row A's password leaves row
 // B's — and the create form's — showing in clear text.
+// Two sources, not one getter returning `[form, key]`: that array is new on
+// every run, so the callback would fire on ANY change the getter read,
+// including a new `field` object from a consumer that rebuilds its fields
+// from form data on each edit, re-masking straight after `setRevealed(true)`
+// or the first keystroke after the eye.
 watch(
-    () => [props.form, props.field.key],
+    [() => props.form, () => props.field.key],
     () => {
         passwordRevealed.value = false;
     },

package/resources/js/components/extended/DXForm.vue

@@ -227,7 +227,11 @@ import DXFormField from "./DXFormField.vue";
 import DXSaveButton from "./DXSaveButton.vue";
 import DXFormErrorSummary, { type ErrorSummarySelection } from "./DXFormErrorSummary.vue";
 import { resolveErrorTargets, type ErrorTarget } from "../../utils/formErrorTargets";
-import type { UseFormReturn, ValidationErrors } from "../../composables/useForm";
+import type {
+    SubmitFailure,
+    UseFormReturn,
+    ValidationErrors,
+} from "../../composables/useForm";
 import type { DefineFormReturn } from "../../composables/defineForm";
 import { useContainerWidth } from "../../composables/useContainerWidth";
 import type { FieldDefinition, FormTab, LabelCols, MaybeFn } from "../../types";
@@ -590,13 +594,17 @@ const visibleTabKeys = computed<string[]>(() =>
  * field definition (consumer-rendered content) still owns its own key and
  * keys nested under it.
  */
-function errorTargetsFor(errors: ValidationErrors | null | undefined): ErrorTarget[] {
+function errorTargetsFor(
+    errors: ValidationErrors | null | undefined,
+    failedRows?: SubmitFailure["failedRows"],
+): ErrorTarget[] {
     return resolveErrorTargets(errors, {
         fields: resolvedFields.value,
         tabs: hasTabs.value ? props.tabs : undefined,
         model: model.value,
         isFieldVisible,
         isTabVisible: (tab) => visibleTabKeys.value.includes(tab.key),
+        failedRows,
     });
 }
 
@@ -605,10 +613,14 @@ const liveErrorTargets = computed<ErrorTarget[]>(() =>
     erroredKeys.value.length === 0 ? [] : errorTargetsFor(resolvedForm.value.errors),
 );
 
-/** Targets for what the last failed submit returned (the summary's rows). */
+/**
+ * Targets for what the last failed submit returned (the summary's rows). The
+ * failure's captured rows keep a row error naming, and pointing at, the row
+ * that failed after rows are removed or reordered.
+ */
 const summaryTargets = computed<ErrorTarget[]>(() => {
     const failure = resolvedForm.value.submitFailure;
-    return failure ? errorTargetsFor(failure.errors) : [];
+    return failure ? errorTargetsFor(failure.errors, failure.failedRows) : [];
 });
 
 /** Key of the first visible tab owning a visible errored field, or null. */
@@ -1073,6 +1085,33 @@ function focusSelectedTab(): void {
     document.getElementById(buttonIdFor(selectedKey))?.focus();
 }
 
+/**
+ * Focus a field's container rather than any control inside it: the field's
+ * labelled group when it has one (a repeater's `fieldset`, announced by its
+ * legend), else the marked element itself. It is made focusable for this
+ * focus only (`tabindex="-1"`, removed again on blur), so the Tab order is
+ * unchanged. Used when the row an error named is gone: every control inside
+ * the field belongs to some other row. True once it holds focus.
+ */
+function focusFieldContainer(element: HTMLElement): boolean {
+    const container =
+        element.querySelector<HTMLElement>(':scope > fieldset, :scope > [role="group"]') ??
+        element;
+    if (!container.hasAttribute("tabindex")) {
+        container.setAttribute("tabindex", "-1");
+        container.addEventListener(
+            "blur",
+            () => container.removeAttribute("tabindex"),
+            { once: true },
+        );
+    }
+    element.scrollIntoView({ block: "nearest" });
+    container.focus({ preventScroll: true });
+    if (document.activeElement === container) return true;
+    if (container.getAttribute("tabindex") === "-1") container.removeAttribute("tabindex");
+    return false;
+}
+
 /**
  * Take the user to an error a summary lists: select its tab, wait for the
  * pane to render, look the field up in the form (its marker, anywhere
@@ -1085,7 +1124,11 @@ function focusSelectedTab(): void {
  * its key whenever its element leaves the DOM (a re-render replacing it),
  * and a moment with none at all is waited out. When no marker renders
  * within the field's render frames, or nothing in it takes focus, focus
- * moves to the selected tab's button. Exposed so a summary rendered OUTSIDE
+ * moves to the selected tab's button. When the row the error named is gone
+ * (`focusKey` is the field's key while `errorKey` names something under it:
+ * the row was removed, replaced or soft-deleted), the field's container
+ * takes focus instead of a control, since every control in it belongs to
+ * another row (`focusFieldContainer`). Exposed so a summary rendered OUTSIDE
  * the form (DXTable's modal footer) can drive it.
  */
 async function focusErrorTarget(target: ErrorSummarySelection): Promise<void> {
@@ -1093,8 +1136,12 @@ async function focusErrorTarget(target: ErrorSummarySelection): Promise<void> {
         commitTabKey(target.tabKey);
     }
     const token = ++revealToken;
+    const isTargetGone =
+        target.focusKey === target.fieldKey &&
+        target.errorKey !== undefined &&
+        target.errorKey !== target.fieldKey;
     let element = await renderedErrorElement(
-        target.errorKey ?? target.fieldKey,
+        target.focusKey ?? target.errorKey ?? target.fieldKey,
         target.fieldKey,
     );
     if (token !== revealToken) return;
@@ -1102,6 +1149,10 @@ async function focusErrorTarget(target: ErrorSummarySelection): Promise<void> {
         focusSelectedTab();
         return;
     }
+    if (isTargetGone) {
+        if (!focusFieldContainer(element)) focusSelectedTab();
+        return;
+    }
     const path = element.getAttribute("data-dx-field-key") ?? target.fieldKey;
     scrollFieldIntoView(element);
 

package/resources/js/components/extended/DXFormErrorSummary.vue

@@ -75,6 +75,16 @@ export interface ErrorSummarySelection {
     tabKey: string | null;
     /** The error key as the server sent it. */
     errorKey: string;
+    /**
+     * Where to take the user: the error key at the failed row's current
+     * index, or the field's key when that row is gone (see
+     * `ErrorTarget.focusKey`), when DXForm's `focusErrorTarget` focuses the
+     * field's container rather than any row's control. Equal to `errorKey`
+     * for everything else.
+     * Always emitted; optional so a selection built by hand for DXForm's
+     * exposed `focusErrorTarget` still types (it then uses `errorKey`).
+     */
+    focusKey?: string;
 }
 
 interface Props {
@@ -171,6 +181,7 @@ const targets = computed<ErrorTarget[]>(() => {
         isFieldVisible: props.isFieldVisible,
         isTabVisible: props.isTabVisible,
         resolveLabel: props.resolveLabel,
+        failedRows: failure.value.failedRows,
     });
 });
 
@@ -178,6 +189,7 @@ interface Row {
     id: string;
     text: string;
     errorKey: string;
+    focusKey: string;
     fieldKey: string | null;
     tabKey: string | null;
 }
@@ -188,6 +200,7 @@ const rows = computed<Row[]>(() =>
             id: `${target.errorKey}#${index}`,
             text,
             errorKey: target.errorKey,
+            focusKey: target.focusKey ?? target.errorKey,
             fieldKey: target.fieldKey,
             tabKey: target.tabKey,
         })),
@@ -227,6 +240,7 @@ function selectRow(row: Row): void {
         fieldKey: row.fieldKey,
         tabKey: row.tabKey,
         errorKey: row.errorKey,
+        focusKey: row.focusKey,
     });
 }
 </script>

package/resources/js/components/extended/DXTableEditorModal.vue

@@ -116,7 +116,7 @@
                 </template>
 
                 <!-- Forward edit-password-actions(key) → password-actions(key):
-                     content beside the password input, inside its input group,
+                     content after the password input group (input and eye),
                      with a handle on dfl's own reveal (eye) state. -->
                 <template
                     v-for="key in editPasswordActionsSlotKeys"
@@ -124,7 +124,7 @@
                     #[`password-actions(${key})`]="sp"
                 >
                     <!--
-                      @slot Extra controls beside password field `<key>`'s input in the edit/create modal, inside its input group after the reveal (eye) toggle — e.g. a "Generate password" button. Name it `edit-password-actions(<fieldKey>)`.
+                      @slot Extra controls beside password field `<key>`'s input in the edit/create modal, after its input group (the input and the reveal (eye) toggle); wraps below the input when the row is too narrow — e.g. a "Generate password" button. Name it `edit-password-actions(<fieldKey>)`.
                       @binding {object} item The row being edited (null in create mode).
                       @binding {any} value The current field value.
                       @binding {Function} update Call with a new value to update the field.

package/resources/js/composables/useForm.ts

@@ -1,11 +1,13 @@
 import {
     reactive,
     computed,
+    markRaw,
     toRaw,
     type ComputedRef,
     type WritableComputedRef,
 } from "vue";
 import { api, type ApiError } from "../utils/api";
+import { getByPath } from "../utils/objectPath";
 
 export interface ValidationErrors {
     [key: string]: string[];
@@ -24,6 +26,37 @@ export interface SubmitFailure {
     message: string;
     /** The validation errors the submit returned (`{}` when none). */
     errors: ValidationErrors;
+    /**
+     * The rows the errors named, keyed by row path: the path up to the
+     * key's FIRST numeric segment (`lines.2` for `lines.2.price` and for
+     * `lines.2.options.0.name`; a row nested inside a row is not recorded,
+     * since the summary follows the outer row). Absent when no error key
+     * names a row that exists in the form data. The error summary uses it
+     * to keep naming and finding the row that failed after rows are removed
+     * or reordered.
+     *
+     * The rows are read from the form data when the failure response
+     * ARRIVES, not when the request was sent. Rows added, removed or
+     * reordered while the request was in flight, or a submit `transform`
+     * that drops or reorders rows, can attach an error to the wrong row
+     * here, exactly as a bare index key always could.
+     */
+    failedRows?: Record<string, FailedRow>;
+}
+
+/** One row a failed submit's errors named (see `SubmitFailure.failedRows`). */
+export interface FailedRow {
+    /**
+     * The row object itself (raw, not a reactive proxy), so its current
+     * index can be found by identity. A row array replaced wholesale (a
+     * reload) holds new objects, and the row then counts as gone.
+     */
+    row: object;
+    /**
+     * A copy of the row taken when the submit failed, for labels: a row's
+     * name (`rowLabel`) reads it, so later edits do not rename the error.
+     */
+    snapshot: Record<string, any>;
 }
 
 export interface FormSubmitOptions<TPayload = unknown, TResponse = unknown> {
@@ -222,6 +255,52 @@ function submitFailureFrom(error: unknown): SubmitFailure | null {
     };
 }
 
+/**
+ * A copy of a row for `FailedRow.snapshot`: a deep clone when the row allows
+ * one (`File`, `Blob` and `Date` values clone fine), else a shallow copy, so
+ * a row `structuredClone` refuses still gets a name. It refuses a row
+ * holding a function, a symbol, a DOM node or a proxy (a reactive object
+ * nested in the row: the row itself is raw, the objects inside it may not
+ * be). A class instance does NOT make it throw: it is cloned as a plain
+ * object, losing its prototype, getters and private fields, so a `rowLabel`
+ * reading a getter on such a value reads `undefined` (and falls back to the
+ * line form).
+ */
+function snapshotRow(row: object): Record<string, any> {
+    try {
+        return structuredClone(row) as Record<string, any>;
+    } catch {
+        return { ...(row as Record<string, any>) };
+    }
+}
+
+/**
+ * The `failedRows` for a failure's error keys, read from the form data as it
+ * is when the failure is recorded. Only the row at a key's first numeric
+ * segment is recorded: that is the only one the error summary reads
+ * (`<field key>.<index>`), so deeper rows would be cloned for nothing.
+ * Undefined when no key names a row.
+ */
+function failedRowsFor(
+    errors: ValidationErrors,
+    data: Record<string, any>,
+): Record<string, FailedRow> | undefined {
+    const rows: Record<string, FailedRow> = {};
+    for (const errorKey of Object.keys(errors)) {
+        const segments = errorKey.split(".");
+        const firstRowSegment = segments.findIndex(
+            (segment, index) => index > 0 && /^\d+$/.test(segment),
+        );
+        if (firstRowSegment < 0) continue;
+        const rowPath = segments.slice(0, firstRowSegment + 1).join(".");
+        if (rows[rowPath] !== undefined) continue;
+        const row = toRaw(getByPath(data, rowPath));
+        if (row === null || typeof row !== "object") continue;
+        rows[rowPath] = markRaw({ row, snapshot: snapshotRow(row) });
+    }
+    return Object.keys(rows).length > 0 ? rows : undefined;
+}
+
 function errorsFromLaravel(error: any): {
     errors: ValidationErrors;
     message: string;
@@ -523,6 +602,13 @@ export function useForm<TData extends Record<string, any>>(
                     setErrors(errors);
                     setMessage(message);
                     if (failure) {
+                        const failedRows = failedRowsFor(
+                            failure.errors,
+                            toRaw(state.data) as Record<string, any>,
+                        );
+                        if (failedRows !== undefined) {
+                            failure.failedRows = failedRows;
+                        }
                         state.submitFailure = failure;
                         state.failedSubmitCount += 1;
                     }

package/resources/js/index.ts

@@ -180,6 +180,7 @@ export type {
     FormState,
     UseFormReturn,
     SubmitFailure,
+    FailedRow,
 } from "./composables/useForm";
 
 export type {

package/resources/js/types/index.ts

@@ -278,7 +278,9 @@ export interface FieldDefinition {
      * For a field whose value is a list of rows (a `repeater`, or a span
      * field that renders its own rows and owns `key.N.*` error keys): the
      * row's own name, called with the row (`model[key][index]`, or `{}` when
-     * the model has no such row) and its 0-based index. When it returns a
+     * the model has no such row) and its 0-based index (for a failure's row
+     * that has since moved, its current index; once removed, the index it
+     * failed at: the index "(line N)" counts). When it returns a
      * non-empty string, the error summary lists that row's errors under it
      * alone ("Chaucer Ale (Pint): Enter a price.") instead of
      * "<sub-field label> (line N)". Returning `undefined`, `null` or `""`
@@ -458,6 +460,8 @@ export interface BaseFieldDef {
     plaintext?: MaybeFn<boolean>;
     submit?: boolean;
     errorKeys?: string[];
+    /** On a repeater, or a span field that renders its own rows. */
+    rowLabel?: (row: Record<string, any>, index: number) => string | null | undefined;
     when?: MaybeFn<boolean>;
     show?: () => boolean;
 }
@@ -597,7 +601,6 @@ export interface ComponentFieldDef extends BaseFieldDef {
 export interface RepeaterFieldDef extends BaseFieldDef {
     type: "repeater";
     fields?: FieldDef[];
-    rowLabel?: (row: Record<string, any>, index: number) => string | null | undefined;
     addLabel?: string;
     minItems?: number;
     maxItems?: number;
@@ -673,13 +676,16 @@ export interface FormTab {
 
 /**
  * Slot props of DXField's `password-actions` slot (DXForm:
- * `password-actions(<key>)`): content placed beside a password input, inside
- * its input group after the reveal (eye) toggle, such as a "Generate password"
- * button. `setRevealed` drives the same state the eye toggles.
+ * `password-actions(<key>)`): content placed beside a password input, such as
+ * a "Generate password" button. It renders after the input group (the input
+ * and the reveal (eye) toggle), in `.dx-password-field__actions`, and wraps
+ * onto its own line below the input when the row is too narrow to keep
+ * `--dx-password-input-min-width`. `setRevealed` drives the same state the
+ * eye toggles.
  *
  * ```vue
  * <template #password-actions(password)="{ update, setRevealed, disabled }">
- *   <DButton variant="outline-secondary" :disabled="disabled"
+ *   <DButton variant="secondary" :disabled="disabled"
  *     @click="update(generatePassword()); setRevealed(true)">Generate</DButton>
  * </template>
  * ```