@omnitend/dashboard-for-laravel 0.47.0 → 0.47.1

package/dist/types/index.d.ts

@@ -359,6 +359,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 +463,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 +509,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,17 @@
-/**
- * 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. 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 +54,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 +86,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:01:22.201Z",
   "package": {
     "name": "@omnitend/dashboard-for-laravel",
-    "version": "0.47.0"
+    "version": "0.47.1"
   },
   "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 any error under `<key>.` (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 any error under `<key>.` (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:01:22.256Z
 
 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.1",
   "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 any error under `<key>.` (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 any error under `<key>.` (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
@@ -744,6 +744,24 @@ function setValue(value: any): void {
     props.form.clearError(errorKey.value);
 }
 
+/**
+ * `update` for the `span` and `value` slots (and so DXTable's `edit-span` /
+ * `edit-value`). Such a slot may draw rows of its own and write the whole
+ * array back, so besides the field's own error it clears every error under
+ * `<key>.` (`lines.3.price`), as the repeater's add and remove do: the rows
+ * may have moved, and a stale per-row error would stay in the summary under
+ * the wrong row. They come back on the next submit.
+ */
+function setValueFromSlot(value: any): void {
+    setValue(value);
+    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 +900,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. */
@@ -1094,7 +1106,7 @@ async function focusErrorTarget(target: ErrorSummarySelection): Promise<void> {
     }
     const token = ++revealToken;
     let element = await renderedErrorElement(
-        target.errorKey ?? target.fieldKey,
+        target.focusKey ?? target.errorKey ?? target.fieldKey,
         target.fieldKey,
     );
     if (token !== revealToken) return;

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

@@ -75,6 +75,14 @@ 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`). 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 +179,7 @@ const targets = computed<ErrorTarget[]>(() => {
         isFieldVisible: props.isFieldVisible,
         isTabVisible: props.isTabVisible,
         resolveLabel: props.resolveLabel,
+        failedRows: failure.value.failedRows,
     });
 });
 
@@ -178,6 +187,7 @@ interface Row {
     id: string;
     text: string;
     errorKey: string;
+    focusKey: string;
     fieldKey: string | null;
     tabKey: string | null;
 }
@@ -188,6 +198,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 +238,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,29 @@ export interface SubmitFailure {
     message: string;
     /** The validation errors the submit returned (`{}` when none). */
     errors: ValidationErrors;
+    /**
+     * The rows the errors named, as they were when the submit failed, keyed
+     * by row path (`lines.2` for `lines.2.price`; every numeric segment of
+     * every error key gets one). 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.
+     */
+    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 +247,42 @@ function submitFailureFrom(error: unknown): SubmitFailure | null {
     };
 }
 
+/**
+ * A copy of a row for `FailedRow.snapshot`: a deep clone when the row allows
+ * one, else a shallow copy (a row holding a function or a `File` proxy that
+ * `structuredClone` refuses still gets a name).
+ */
+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. 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(".");
+        for (let index = 1; index < segments.length; index += 1) {
+            if (!/^\d+$/.test(segments[index])) continue;
+            const rowPath = segments.slice(0, index + 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 +584,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

@@ -458,6 +458,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 +599,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 +674,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/resources/js/utils/formErrorTargets.ts

@@ -7,8 +7,9 @@
  * `when`/`context`-aware predicates and a standalone summary can use the
  * defaults below.
  */
+import { toRaw } from "vue";
 import type { FieldDefinition, FormTab } from "../types";
-import type { ValidationErrors } from "../composables/useForm";
+import type { FailedRow, ValidationErrors } from "../composables/useForm";
 import {
     isFieldVisible as isFieldVisibleFor,
     resolvePredicate,
@@ -19,6 +20,14 @@ import { getByPath } from "./objectPath";
 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. 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[];
     /**
@@ -65,6 +74,14 @@ export interface ResolveErrorTargetsOptions {
         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>;
 }
 
 interface Candidate {
@@ -175,7 +192,10 @@ function rowLabelFor(
  * 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
@@ -266,22 +286,68 @@ export function resolveErrorTargets(
         return longest;
     };
 
-    const ownedLabel = (errorKey: string, field: FieldDefinition): string => {
-        if (!isNestedUnder(errorKey, field.key)) return labelFor(field);
-        const [first, second] = errorKey.slice(field.key.length + 1).split(".");
-        if (!NUMERIC_SEGMENT.test(first)) return labelFor(field);
+    /**
+     * Where a failed row is now: its index in the field's live rows, found by
+     * identity, or -1 when it is gone (removed, or the rows were replaced).
+     */
+    const currentIndexOf = (field: FieldDefinition, failedRow: FailedRow): number => {
+        const liveRows = getByPath(model, field.key);
+        if (!Array.isArray(liveRows)) return -1;
+        return liveRows.findIndex((row) => toRaw(row) === failedRow.row);
+    };
+
+    /**
+     * The label and focus key for an owned error key. For a row key
+     * (`field.N.sub`) with a captured failed row, both follow that row: the
+     * label is read from the row as it was when the submit failed, and the
+     * focus key uses the row's current index, or is the field's key when the
+     * row is gone. "(line N)" then counts the row's CURRENT position while it
+     * exists (the line a click takes the user to), and the position it failed
+     * at once it is gone.
+     */
+    const ownedTarget = (
+        errorKey: string,
+        field: FieldDefinition,
+    ): { label: string; focusKey: string } => {
+        if (!isNestedUnder(errorKey, field.key)) {
+            return { label: labelFor(field), focusKey: errorKey };
+        }
+        const [first, second, ...deeper] = errorKey
+            .slice(field.key.length + 1)
+            .split(".");
+        if (!NUMERIC_SEGMENT.test(first)) {
+            return { label: labelFor(field), focusKey: errorKey };
+        }
+        const failedIndex = Number(first);
         const subField =
             second !== undefined
                 ? field.fields?.find((candidate) => candidate.key === second)
                 : undefined;
-        // DXRepeater renders a sub-field with the ROW as its model, so its
-        // label resolves against the row here too.
-        const row = getByPath(model, `${field.key}.${first}`);
-        const rowModel = row !== null && typeof row === "object" ? row : {};
-        const rowName = rowLabelFor(field, rowModel, Number(first));
-        if (rowName !== null) return rowName;
+        const failedRow = options.failedRows?.[`${field.key}.${first}`];
+
+        let rowModel: Record<string, any>;
+        let lineIndex = failedIndex;
+        let focusKey = errorKey;
+        if (failedRow !== undefined) {
+            rowModel = failedRow.snapshot;
+            const currentIndex = currentIndexOf(field, failedRow);
+            if (currentIndex >= 0) {
+                lineIndex = currentIndex;
+                const rest = second !== undefined ? [second, ...deeper] : [];
+                focusKey = [field.key, String(currentIndex), ...rest].join(".");
+            } else {
+                focusKey = field.key;
+            }
+        } else {
+            // DXRepeater renders a sub-field with the ROW as its model, so its
+            // label resolves against the row here too.
+            const row = getByPath(model, `${field.key}.${first}`);
+            rowModel = row !== null && typeof row === "object" ? row : {};
+        }
+        const rowName = rowLabelFor(field, rowModel, failedIndex);
+        if (rowName !== null) return { label: rowName, focusKey };
         const base = subField ? labelFor(subField, rowModel) : labelFor(field);
-        return `${base} (line ${Number(first) + 1})`;
+        return { label: `${base} (line ${lineIndex + 1})`, focusKey };
     };
 
     // ——— one target per error key with at least one message
@@ -298,15 +364,15 @@ export function resolveErrorTargets(
         );
         if (messages.length === 0) return;
         const owner = ownerOf(errorKey);
+        const owned = owner ? ownedTarget(errorKey, owner.field) : null;
         pending.push({
             target: {
                 errorKey,
+                focusKey: owned ? owned.focusKey : errorKey,
                 messages,
                 fieldKey: owner ? owner.field.key : null,
                 tabKey: owner ? owner.tabKey : null,
-                label: owner
-                    ? ownedLabel(errorKey, owner.field)
-                    : humaniseErrorKey(errorKey),
+                label: owned ? owned.label : humaniseErrorKey(errorKey),
             },
             rank: owner ? owner.rank : [UNOWNED_RANK, UNOWNED_RANK],
             order,