fix(forking): stop a parent re-pick blanking a dependent's stored target value

A dependent selector (a sheet under a spreadsheet, a label under a mailbox)
is invalidated when its parent is re-picked, because the stored child no
longer exists under the new parent. That invalidation was recorded by writing
an empty string into the in-session override map — the same value the user's
own "clear this field" produces. The two are not the same thing, and the map
is submitted verbatim and written into the target workflow's configuration,
so an invalidated field cleared the target's real stored value.

The sharpest case is an undo. Re-pick a parent away from its original target,
then back. The parent nets out unchanged, so nothing is remapped and the
remap's own clearing pass never runs — but the child is still blank, and that
blank lands on a value the user never touched, with nothing in the UI showing
it happened.

Record the invalidation with a distinct marker instead. It reads as blank in
the selector, the in-block chain context, and the Sync gate, so a required
invalidated field still blocks Sync and still renders; but it is omitted from
the submitted payload rather than sent as empty, so no override is written and
the target keeps what it had. A blank the user picked themselves is still
submitted and still clears the target.

Also: skip the cascade entirely when a re-pick selects the value the field
already had, since the selector fires its change handler either way.

Fork file copy: a file whose name is already taken in a reused target folder
is de-duplicated with the same allocator the ordinary upload path uses, rather
than colliding with the folder-name unique index and being dropped from the
fork with its blob deleted.

Adds hook-level coverage for the submitted payload, which had none.

Author: waleedlatif1

apps/sim/ee/workspace-forking/components/fork-sync/dependent-value.test.ts

@@ -5,12 +5,15 @@ import { describe, expect, it } from 'vitest'
 import type { ForkDependentReconfig } from '@/lib/api/contracts/workspace-fork'
 import {
   applyDependentRepick,
+  DEPENDENT_CLEARED_BY_PARENT,
   dependentKey,
   effectiveCopyDependentValue,
   effectiveDependentValue,
   getActionableDependentFields,
   getDisplayedDependentFields,
+  isDependentClearedByParent,
   isDependentConfigurationActionable,
+  submittedDependentValue,
 } from '@/ee/workspace-forking/components/fork-sync/dependent-value'
 
 const field = (overrides: Partial<ForkDependentReconfig> = {}): ForkDependentReconfig => ({
@@ -143,15 +146,39 @@ describe('applyDependentRepick', () => {
 
     expect(next).toEqual({
       [dependentKey(site)]: 'site-new',
-      [dependentKey(drive)]: '',
-      [dependentKey(spreadsheet)]: '',
-      [dependentKey(sheet)]: '',
+      [dependentKey(drive)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(spreadsheet)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(sheet)]: DEPENDENT_CLEARED_BY_PARENT,
       [dependentKey(unrelated)]: 'still-keep-me',
     })
     expect(effectiveDependentValue(drive, next, false)).toBe('')
     expect(effectiveCopyDependentValue(sheet, next)).toBe('')
   })
 
+  it('re-picking the value the field already had leaves its descendants alone', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      currentValue: 'sheet-doc',
+      providesContextKey: 'spreadsheetId',
+    })
+    const range = field({
+      subBlockKey: 'range',
+      currentValue: 'Sheet1!A1:D',
+      consumesContextKeys: ['spreadsheetId'],
+    })
+
+    const next = applyDependentRepick(
+      {},
+      spreadsheet,
+      [spreadsheet, range],
+      'sheet-doc',
+      effectiveDependentValue(spreadsheet, {}, false)
+    )
+
+    expect(next).toEqual({ [dependentKey(spreadsheet)]: 'sheet-doc' })
+    expect(effectiveDependentValue(range, next, false)).toBe('Sheet1!A1:D')
+  })
+
   it('only changes the selected field when it provides no selector context', () => {
     const leaf = field({ subBlockKey: 'issueKey', currentValue: 'ISSUE-1' })
     const unrelated = field({ subBlockKey: 'label', currentValue: 'keep-me' })
@@ -204,12 +231,96 @@ describe('applyDependentRepick', () => {
       )
     ).toEqual({
       [dependentKey(projectOne)]: 'P1-NEW',
-      [dependentKey(issueOne)]: '',
+      [dependentKey(issueOne)]: DEPENDENT_CLEARED_BY_PARENT,
       [dependentKey(issueTwo)]: 'P2-1',
     })
   })
 })
 
+describe('submittedDependentValue', () => {
+  const mappedParent = { copying: false, parentChanged: false }
+
+  it('omits an optional descendant a parent re-pick blanked, so the target keeps its value', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      currentValue: 'doc-old',
+      providesContextKey: 'spreadsheetId',
+    })
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      currentValue: 'Sheet1',
+      required: true,
+      consumesContextKeys: ['spreadsheetId'],
+    })
+    const range = field({
+      subBlockKey: 'range',
+      currentValue: 'A1:D50',
+      required: false,
+      consumesContextKeys: ['spreadsheetId'],
+    })
+
+    const next = applyDependentRepick(
+      {},
+      spreadsheet,
+      [spreadsheet, sheet, range],
+      'doc-new',
+      effectiveDependentValue(spreadsheet, {}, false)
+    )
+
+    expect(isDependentClearedByParent(range, next)).toBe(true)
+    expect(submittedDependentValue(range, next, mappedParent)).toBeUndefined()
+    expect(submittedDependentValue(sheet, next, mappedParent)).toBeUndefined()
+    expect(submittedDependentValue(spreadsheet, next, mappedParent)).toBe('doc-new')
+  })
+
+  it('submits an empty value the user picked themselves, so an explicit clear still clears', () => {
+    const label = field({ subBlockKey: 'label', currentValue: 'INBOX' })
+
+    const next = applyDependentRepick({}, label, [label], '', 'INBOX')
+
+    expect(isDependentClearedByParent(label, next)).toBe(false)
+    expect(submittedDependentValue(label, next, mappedParent)).toBe('')
+  })
+
+  it('submits a re-picked descendant once the user chooses a replacement', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      currentValue: 'doc-old',
+      providesContextKey: 'spreadsheetId',
+    })
+    const range = field({
+      subBlockKey: 'range',
+      currentValue: 'A1:D50',
+      consumesContextKeys: ['spreadsheetId'],
+    })
+
+    const cleared = applyDependentRepick(
+      {},
+      spreadsheet,
+      [spreadsheet, range],
+      'doc-new',
+      effectiveDependentValue(spreadsheet, {}, false)
+    )
+    const repicked = applyDependentRepick(
+      cleared,
+      range,
+      [spreadsheet, range],
+      'A1:Z',
+      effectiveDependentValue(range, cleared, false)
+    )
+
+    expect(submittedDependentValue(range, repicked, mappedParent)).toBe('A1:Z')
+  })
+
+  it('falls back to the stored value under an unchanged parent and to the source when copying', () => {
+    const untouched = field({ subBlockKey: 'label', currentValue: 'INBOX' })
+    const copied = field({ subBlockKey: 'documentSelector', currentValue: '', sourceValue: 'doc' })
+
+    expect(submittedDependentValue(untouched, {}, mappedParent)).toBe('INBOX')
+    expect(submittedDependentValue(copied, {}, { copying: true, parentChanged: false })).toBe('doc')
+  })
+})
+
 describe('isDependentConfigurationActionable', () => {
   it('hides stored values when the mapped parent is unchanged', () => {
     expect(
@@ -281,6 +392,51 @@ describe('isDependentConfigurationActionable', () => {
     ).toBe(true)
   })
 
+  it('shows a required field that a parent re-pick blanked (it blocks Sync)', () => {
+    const spreadsheet = field({
+      subBlockKey: 'spreadsheetId',
+      currentValue: 'doc-old',
+      providesContextKey: 'spreadsheetId',
+    })
+    const sheet = field({
+      subBlockKey: 'sheetName',
+      required: true,
+      currentValue: 'Sheet1',
+      consumesContextKeys: ['spreadsheetId'],
+    })
+    const next = applyDependentRepick(
+      {},
+      spreadsheet,
+      [spreadsheet, sheet],
+      'doc-new',
+      effectiveDependentValue(spreadsheet, {}, false)
+    )
+
+    // The sync gate reads the same blank the selector shows, so the field gates and is visible.
+    expect(effectiveDependentValue(sheet, next, false)).toBe('')
+    expect(
+      isDependentConfigurationActionable(sheet, next, {
+        parentResolved: true,
+        parentChanged: false,
+        copying: false,
+      })
+    ).toBe(true)
+  })
+
+  it('shows a required field the user emptied themselves (it blocks Sync)', () => {
+    const sheet = field({ subBlockKey: 'sheetName', required: true, currentValue: 'Sheet1' })
+    const next = applyDependentRepick({}, sheet, [sheet], '', 'Sheet1')
+
+    expect(effectiveDependentValue(sheet, next, false)).toBe('')
+    expect(
+      isDependentConfigurationActionable(sheet, next, {
+        parentResolved: true,
+        parentChanged: false,
+        copying: false,
+      })
+    ).toBe(true)
+  })
+
   it('hides dependents until their parent is resolved', () => {
     expect(
       isDependentConfigurationActionable(

apps/sim/ee/workspace-forking/components/fork-sync/dependent-value.ts

@@ -10,18 +10,46 @@ function sameDependencyScope(left: ForkDependentReconfig, right: ForkDependentRe
 }
 
 /**
- * Store a dependent re-pick and clear every selector transitively scoped by it. Empty-string
- * overrides are intentional: an absent override means "fall back to the stored value", while a
- * changed provider makes every stored descendant stale for both mapped and copied parents.
+ * Marker stored for a descendant whose value an in-session parent re-pick invalidated, kept
+ * distinct from the user's own empty pick. It reads as blank everywhere it is consumed - the
+ * selector, the in-block chain context, and the sync gate - but is never submitted: the user
+ * has not chosen a replacement, so no override is written for it. A `''` the user picked
+ * themselves IS submitted and does clear the target.
+ *
+ * What the omission buys differs by path. On Save nothing rewrites the target draft, so its
+ * stored value survives outright - including across an undo (re-pick away, then back), where
+ * the parent nets out unchanged so `clearDependentsOnRemap` never fires and an explicit `''`
+ * would land on a value nobody touched. On Sync the written state is source-derived and
+ * `clearDependentsOnRemap` already blanks every top-level dependent of a remapped parent, so
+ * omission preserves nothing there; what it prevents is an explicit `''` reaching the fields
+ * that pass does not cover - nested `tools[i].param` values in particular, which
+ * `applyNestedToolOverrides` would otherwise blank.
+ *
+ * The escaped NUL prefix keeps it disjoint from every real selector value (ids, names, label
+ * paths) - no selector can produce one, so it can never collide with a genuine pick.
+ */
+export const DEPENDENT_CLEARED_BY_PARENT = '\u0000fork-sync:cleared-by-parent'
+
+/**
+ * Store a dependent re-pick and invalidate every selector transitively scoped by it, marking
+ * each with `DEPENDENT_CLEARED_BY_PARENT`: a changed provider makes every stored descendant
+ * stale for both mapped and copied parents, but only the fields the user reviews themselves
+ * get written to the target.
+ *
+ * `previousValue` is the field's effective value before the pick. `onChange` fires even when
+ * the user re-selects the value the field already had, and that pick moves no scope, so nothing
+ * below it went stale - the cascade is skipped. Omit it only where no prior value is known.
  */
 export function applyDependentRepick(
   reconfig: Record<string, string>,
   changedField: ForkDependentReconfig,
   blockFields: ForkDependentReconfig[],
-  value: string
+  value: string,
+  previousValue?: string
 ): Record<string, string> {
   const changedKey = dependentKey(changedField)
   const nextState = { ...reconfig, [changedKey]: value }
+  if (previousValue !== undefined && previousValue === value) return nextState
   if (!changedField.providesContextKey) return nextState
 
   const pendingContextKeys = [changedField.providesContextKey]
@@ -41,7 +69,7 @@ export function applyDependentRepick(
       }
 
       visitedFields.add(fieldKey)
-      nextState[fieldKey] = ''
+      nextState[fieldKey] = DEPENDENT_CLEARED_BY_PARENT
       if (field.providesContextKey) pendingContextKeys.push(field.providesContextKey)
     }
   }
@@ -51,16 +79,19 @@ export function applyDependentRepick(
 
 /**
  * The value sent + displayed for a dependent: the user's in-session re-pick if present, else the
- * stored value (`currentValue`). Blank when the parent target changed in-session, since the old
- * stored value was for the previous parent and won't resolve against the new one. Shared by the
- * sync gate + payload build and the per-block selector so the rule can't drift between them.
+ * stored value (`currentValue`). Blank when the parent target changed in-session, or when an
+ * in-block parent re-pick invalidated it, since the old stored value was for the previous parent
+ * and won't resolve against the new one. Shared by the sync gate and the per-block selector so
+ * the rule can't drift between them. What gets SUBMITTED is `submittedDependentValue`, which
+ * additionally omits the fields the user has not reviewed.
  */
 export function effectiveDependentValue(
   field: ForkDependentReconfig,
   reconfig: Record<string, string>,
   parentChanged: boolean
 ): string {
   const repicked = reconfig[dependentKey(field)]
+  if (repicked === DEPENDENT_CLEARED_BY_PARENT) return ''
   if (repicked !== undefined) return repicked
   return parentChanged ? '' : field.currentValue
 }
@@ -78,10 +109,41 @@ export function effectiveCopyDependentValue(
   reconfig: Record<string, string>
 ): string {
   const repicked = reconfig[dependentKey(field)]
+  if (repicked === DEPENDENT_CLEARED_BY_PARENT) return ''
   if (repicked !== undefined) return repicked
   return field.currentValue || field.sourceValue
 }
 
+/**
+ * Whether an in-block parent re-pick invalidated this field and the user has not re-picked it
+ * since. Such a field shows blank but is not submitted: blanking the target on the user's behalf
+ * would destroy a stored value they never chose to clear.
+ */
+export function isDependentClearedByParent(
+  field: ForkDependentReconfig,
+  reconfig: Record<string, string>
+): boolean {
+  return reconfig[dependentKey(field)] === DEPENDENT_CLEARED_BY_PARENT
+}
+
+/**
+ * The value this dependent contributes to the submitted mapping, or `undefined` when it must be
+ * OMITTED so the target keeps what it already stores. Only a field the user reviewed is written:
+ * an explicit empty pick clears the target, while a value merely invalidated by a parent re-pick
+ * is left alone (it is on screen and blank, and if it is required the sync gate blocks until the
+ * user picks one - `effectiveDependentValue` reports it as blank).
+ */
+export function submittedDependentValue(
+  field: ForkDependentReconfig,
+  reconfig: Record<string, string>,
+  state: { copying: boolean; parentChanged: boolean }
+): string | undefined {
+  if (isDependentClearedByParent(field, reconfig)) return undefined
+  return state.copying
+    ? effectiveCopyDependentValue(field, reconfig)
+    : effectiveDependentValue(field, reconfig, state.parentChanged)
+}
+
 export interface DependentConfigurationState {
   parentResolved: boolean
   parentChanged: boolean
@@ -92,6 +154,12 @@ export interface DependentConfigurationState {
  * Whether a dependent selector needs to be shown. A changed or copied parent requires review
  * because its children resolve in a different scope. An unchanged mapping only needs a selector
  * when a required value is missing; its stored values are already valid and sync-ready.
+ *
+ * A field a parent re-pick invalidated reads as blank through `effectiveDependentValue`, so a
+ * REQUIRED one stays on screen here and keeps gating Sync. An optional one drops out of the
+ * default view - `getDisplayedDependentFields` brings it back under explicit edit mode - and
+ * hiding it loses nothing, because `submittedDependentValue` omits it from the payload rather
+ * than blanking the target.
  */
 export function isDependentConfigurationActionable(
   field: ForkDependentReconfig,

apps/sim/ee/workspace-forking/components/fork-sync/fork-sync-view.tsx

@@ -204,10 +204,11 @@ function DependentSelector({
   reconfig,
   setReconfig,
 }: DependentSelectorProps) {
-  const effectiveValue = (f: ForkDependentReconfig) =>
+  const effectiveValueIn = (f: ForkDependentReconfig, state: Record<string, string>) =>
     copying
-      ? effectiveCopyDependentValue(f, reconfig)
-      : effectiveDependentValue(f, reconfig, parentChanged)
+      ? effectiveCopyDependentValue(f, state)
+      : effectiveDependentValue(f, state, parentChanged)
+  const effectiveValue = (f: ForkDependentReconfig) => effectiveValueIn(f, reconfig)
   const { providedValues, providedContextKeys } = blockChainState(block, field, effectiveValue)
   // Disabled until every in-block parent it depends on has a value, so a child never queries
   // a stale upstream value.
@@ -230,7 +231,17 @@ function DependentSelector({
       enabled={parentValue !== '' && ready}
       value={effectiveValue(field)}
       onChange={(value) =>
-        setReconfig((current) => applyDependentRepick(current, field, block.fields, value))
+        setReconfig((current) =>
+          // The pre-pick value comes from the state being updated, so re-selecting the value
+          // already shown is recognised as the no-op it is and leaves descendants intact.
+          applyDependentRepick(
+            current,
+            field,
+            block.fields,
+            value,
+            effectiveValueIn(field, current)
+          )
+        )
       }
       title={field.title}
     />