@@ -0,0 +1,11 @@
+---
+'@object-ui/components': minor
+---
+
+feat(data-table): pass `pendingRow` to the host cell editor — the row with its staged edits merged over it (#7188)
+
+`data-table` already computed each row's `pendingChanges` entry in the row loop that
+renders the editor; it now hands the injected editor that row merged with those staged
+values as `pendingRow`, next to the persisted `row`. Nothing about `row`, `value`,
+`stage`, `commit` or `cancel` changed. A host editor that scopes itself by a sibling
+field can read `pendingRow` and follow an edit the user has made but not yet saved.
@@ -0,0 +1,14 @@
+---
+'@object-ui/plugin-grid': patch
+---
+
+Fix: a `dependsOn` lookup edited inline follows a parent edited in the same row **before**
+it is saved (#7188, finishing #7165).
+
+#7165 shipped an explicitly-labelled interim: the grid's inline editor scoped a
+`dependsOn` picker by `ctx.row`, the **saved** record. Edit the parent cell, do not save,
+open the child — and the child still listed candidates for the parent's persisted value
+(or stayed gated if that value was empty). The grid now scopes by `ctx.pendingRow ?? ctx.row`,
+where `pendingRow` is the row merged with its staged, unsaved edits, so picking a parent
+re-scopes the child immediately — the form's live-record semantics from #2216. The interim
+marker that named #7188 is gone with the interim.
@@ -0,0 +1,24 @@
+---
+'@object-ui/types': minor
+---
+
+feat(types): `renderCellEditor`'s context gains `pendingRow` — the persisted row merged with its staged, unsaved edits (#7188)
+
+The inline cell editor's context on `DataTableSchema` (declared by #6882) carried the row
+once, as `row` — the **persisted** record. A widget that scopes itself by a sibling field
+(a `dependsOn` lookup) had no way to see a parent that was edited in the same row but not
+yet saved, so it kept listing candidates for the old parent.
+
+The context now carries the row twice, deliberately:
+
+- `row` — unchanged: the persisted record, what the data source last returned.
+- `pendingRow` — **new**: `row` shallow-merged with the row's staged, unsaved edits. The
+  same object as `row` when nothing is staged.
+
+`row` was **not** redefined to mean the merged record — that would silently change an
+already-published member, and a host that needs the persisted value would have lost its
+only source. Both are addressable. The zod mirror's `renderCellEditor` is `z.function()`
+and encodes no parameter shape; its description records the delta and names the member
+on `DataTableSchema` as the authority. The #6882 exact-shape pin was extended (not
+weakened) in the same change, with a control proving the pin can tell the seventh member's
+presence from its absence.
@@ -49,7 +49,8 @@ interface DataTableSchema {
   singleClickEdit?: boolean;             // Enter edit mode on single click (default: false)
   renderCellEditor?: (ctx: {             // Host-supplied editor widget; null -> built-in input
     column: any;
-    row: any;
+    row: any;                            // the persisted record
+    pendingRow: any;                     // row + this row's staged, unsaved edits (#7188)
     value: any;
     stage: (v: any) => void;
     commit: (v?: any) => void;
@@ -124,6 +125,13 @@ affordances the built-in editors have: Enter commits from a single-line input,
 Escape cancels, and a click outside commits. Use `stage` to record a value while
 staying in edit mode, `commit` to save, and `cancel` to discard.
 
+The context carries the row twice, on purpose: `row` is the persisted record, and
+`pendingRow` is that record with the row's staged, unsaved edits merged over it
+(the same object as `row` when nothing is staged). A widget that scopes itself by
+a sibling field — a `dependsOn` lookup — should read `pendingRow`, so a parent
+edited in the same row re-scopes the child before anything is saved; `row` stays
+the place to read what the data source last returned.
+
 ## Examples
 
 ### Product Inventory
 
@@ -981,6 +981,33 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
   const [editValue, setEditValue] = useState<any>('');
   // Track pending changes for multi-cell editing: rowIndex -> { columnKey -> newValue }
   const [pendingChanges, setPendingChanges] = useState<Map<number, Record<string, any>>>(new Map());
+
+  // objectui#7188 — the row merged with its STAGED edits, handed to the host
+  // editor as `pendingRow` next to the persisted `row`. Cached per row object
+  // and rebuilt whenever `pendingChanges` is replaced (every stage / save /
+  // cancel builds a new Map), so the merged record keeps its IDENTITY across
+  // renders that stage nothing. That matters: `LookupField` keys its
+  // `dependentFilter` / `popoverFilter` memos on the identity of the record it
+  // is handed, and its recent-ids effect keys on `popoverFilter`, so a fresh
+  // object per render would re-issue that query on every table re-render while
+  // the picker is open (`useRecordQuery` itself is immune — it keys on a JSON
+  // signature). `row` is identity-stable for the same reason; a row with
+  // nothing staged is handed `row` itself.
+  const pendingRows = useMemo(() => {
+    const byRow = new WeakMap<object, any>();
+    return {
+      /** `row` merged with its staged edits — or `row` itself when it has none. */
+      of(row: any, rowIndex: number): any {
+        const changes = pendingChanges.get(rowIndex);
+        if (!changes || row === null || typeof row !== 'object') return row;
+        const hit = byRow.get(row);
+        if (hit !== undefined) return hit;
+        const merged = { ...row, ...changes };
+        byRow.set(row, merged);
+        return merged;
+      },
+    };
+  }, [pendingChanges]);
   const [isSaving, setIsSaving] = useState(false);
   // Last save failure message (server validation text, etc.) shown in the
   // toolbar; null when the last save attempt succeeded or nothing's been saved.
@@ -1025,8 +1052,8 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
   //
   // The listener is still needed, for a different reason: NOTHING EVER HANDS
   // THE WIDGET ONE. The wrapper below carries `onKeyDown` alone, and the
-  // context object `renderCellEditor` receives — `{ column, row, value, stage,
-  // commit, cancel }` — has no DOM-props slot to put an `onBlur` in.
+  // context object `renderCellEditor` receives — `{ column, row, pendingRow,
+  // value, stage, commit, cancel }` — has no DOM-props slot to put an `onBlur` in.
   //
   // ⚠️ The second half of that reason is GONE (objectui#6909). The in-repo
   // factory behind the seam, `@object-ui/fields`' `FieldEditWidget`, used to
@@ -2320,6 +2347,12 @@ const DataTableRenderer = ({ schema }: { schema: DataTableSchema }) => {
                                   const node = injectEditor({
                                     column: col,
                                     row,
+                                    // The persisted row with this row's staged,
+                                    // unsaved edits merged over it (objectui#7188);
+                                    // the SAME object as `row` when nothing is
+                                    // staged, so `row === pendingRow` reads as
+                                    // "clean" on the host side.
+                                    pendingRow: rowHasChanges ? pendingRows.of(row, rowIndex) : row,
                                     value: editValue,
                                     stage: stageEdit,
                                     commit: (v?: any) => saveEdit(true, v),
 
@@ -860,11 +860,16 @@ export type ObjectGridDataTableSchemaHolds = {
    * REDUNDANT since objectui#6882 (2026-08-30) — `DataTableSchema` declares this
    * key itself now, with a shape measured `Equal` to this one. `data-table`
    * calls it to render a host cell editor; returning `null` falls through to the
-   * built-in text / number / date inputs.
+   * built-in text / number / date inputs. objectui#7188 added `pendingRow` (the
+   * persisted `row` merged with the row's staged, unsaved edits) upstream, and
+   * this copy carries it too so the seam's intersection stays INERT — `Equal`
+   * in both directions, as #7196 measured — rather than becoming a second,
+   * narrower signature that a `pendingRow`-reading host would trip on.
    */
   renderCellEditor?: (ctx: {
     column: any;
     row: any;
+    pendingRow: any;
     value: any;
     stage: (v: any) => void;
     commit: (v?: any) => void;
@@ -4015,7 +4020,7 @@ export const ObjectGrid: React.FC<ObjectGridComponentProps> = ({
     // handing DataTable an editor factory would leave the built-in fallback
     // editors as the only reachable ones if any future path re-opened the mode.
     renderCellEditor: inlineEditable
-      ? (ctx: { column: any; row: any; value: any; stage: (v: any) => void; commit: (v?: any) => void }) => {
+      ? (ctx: { column: any; row: any; pendingRow: any; value: any; stage: (v: any) => void; commit: (v?: any) => void }) => {
           const fieldDef = (objectSchema as any)?.fields?.[ctx.column?.accessorKey];
           if (!fieldDef || !hasFieldEditWidget(fieldDef.type)) return null;
           const discrete = DISCRETE_EDIT_TYPES.has(fieldDef.type);
@@ -4035,50 +4040,35 @@ export const ObjectGrid: React.FC<ObjectGridComponentProps> = ({
               field={field}
               value={ctx.value}
               onChange={(v: any) => (discrete ? ctx.commit(v) : ctx.stage(v))}
-              // ⚠️ INTERIM (objectui#7165) — the SAVED row, not the staged one.
+              // The record a dependent widget scopes itself by (objectui#7165,
+              // finished by objectui#7188). `LookupField` resolves
+              // `dependentValues ?? ctx.formValues ?? ctx.data ?? {}`, and only
+              // the FIRST link is suppliable by any host: `SchemaRendererContextType`
+              // declares exactly `dataSource` / `debug` / `debugFlags` / `apiFetch`,
+              // so the tail is unconditionally empty repo-wide (objectui#7206) —
+              // which is why the repair is this prop and could not have been a
+              // provider. A grid that supplied none of the three rendered every
+              // `dependsOn` column as a permanently gated, disabled trigger
+              // ("Select region first") even when the row carried the parent —
+              // a field that could never be filled, with no diagnostic. PR
+              // objectui#2216 gave the FORM renderer exactly this injection (its
+              // LIVE watched record); the other half — every picker taking the
+              // `dependsOn` chain as a hard `baseFilter` — is host-independent
+              // and was already live here, so this line supplies a missing INPUT
+              // and re-implements no cascade.
               //
-              // The record a dependent widget scopes itself by. `LookupField`
-              // resolves `dependentValues ?? ctx.formValues ?? ctx.data ?? {}`
-              // and this grid supplied NONE of the three, so the resolved record
-              // was `{}` for every row. ⚠️ Only the FIRST link was ever
-              // suppliable, by this host or any other:
-              // `SchemaRendererContextType` declares exactly `dataSource` /
-              // `debug` / `debugFlags` / `apiFetch`, so the tail is
-              // unconditionally empty repo-wide (objectui#7206). That is why the
-              // repair has to be this prop and could not have been a provider. A column declaring `dependsOn` therefore
-              // rendered a permanently gated, disabled trigger ("Select region
-              // first") even when the row carried the parent value — a field
-              // that could never be filled, with no diagnostic. PR objectui#2216
-              // gave the FORM renderer exactly this injection (its live watched
-              // record); only that half was per-host, and the grid never got it.
-              // The other half — every picker taking the `dependsOn` chain as a
-              // hard `baseFilter` — is host-independent and was already live
-              // here, so this line supplies a missing INPUT and re-implements no
-              // cascade.
-              //
-              // ⛔ WHAT IS STILL WRONG, precisely: `ctx.row` is the PERSISTED
-              // record. A parent edited but NOT YET SAVED in this same row does
-              // not re-scope the child — the picker keeps listing candidates for
-              // the parent's saved value, and stays gated if that saved value is
-              // empty. objectui#2215's form fix was explicitly the LIVE record,
-              // so picking a parent re-scopes the child immediately. Matching
-              // that is objectui#7188, and it is the finished shape.
-              //
-              // Why the interim ships instead of the finished shape: the staged
-              // values live in `data-table`'s `pendingChanges` — in scope at the
-              // call site, so this is not a plumbing problem — and carrying them
-              // across needs a SEVENTH member on `renderCellEditor`'s context.
-              // `@object-ui/types` declares that context (objectui#6882,
-              // maintainer ruling 2026-08-30, replacing a `(schema as any)` cast)
-              // and pins its shape by EXACT type equality. That is a
-              // published-surface contract change with its own review floor, so
-              // it belongs to objectui#7188, not to this line.
-              //
-              // ⛔ Do NOT read this as settled. "Never fillable" → "scoped by
-              // the saved parent" is strictly better and strictly not finished;
-              // whether the user should be TOLD the scope came from the saved row
-              // is an OPEN question on objectui#7188, not a closed one.
-              dependentValues={ctx.row}
+              // `pendingRow` is the PERSISTED row shallow-merged with this row's
+              // STAGED, unsaved edits (`data-table` builds it from its
+              // `pendingChanges`), so a parent edited in the same row re-scopes
+              // the child before anything is saved — the form's semantics.
+              // `ctx.row` alone was #7165's interim and scoped by the SAVED
+              // parent. `pendingRow` is a REQUIRED member of the declared
+              // context (`@object-ui/types`, objectui#6882 + #7188), so the
+              // `?? ctx.row` never selects for a conforming host; it is spelled
+              // so a context handed to this factory WITHOUT it degrades to the
+              // saved-row scoping rather than to `{}` — gated forever — and it
+              // is the spelling objectui#7188's ruling chose.
+              dependentValues={ctx.pendingRow ?? ctx.row}
             />
           );
         }