chore(forking): move the fork-sync changes to their own PR

The dependent-omission fix and the fork file-copy de-duplication are reviewed
separately in #6787. They are the only changes here that overlap #6776, and
they carry their own design tradeoff, so they should not ride along with the
unrelated audit fixes in this PR.

Author: waleedlatif1

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

@@ -5,15 +5,12 @@ 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 => ({
@@ -146,39 +143,15 @@ describe('applyDependentRepick', () => {
 
     expect(next).toEqual({
       [dependentKey(site)]: 'site-new',
-      [dependentKey(drive)]: DEPENDENT_CLEARED_BY_PARENT,
-      [dependentKey(spreadsheet)]: DEPENDENT_CLEARED_BY_PARENT,
-      [dependentKey(sheet)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(drive)]: '',
+      [dependentKey(spreadsheet)]: '',
+      [dependentKey(sheet)]: '',
       [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' })
@@ -231,96 +204,12 @@ describe('applyDependentRepick', () => {
       )
     ).toEqual({
       [dependentKey(projectOne)]: 'P1-NEW',
-      [dependentKey(issueOne)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(issueOne)]: '',
       [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(
@@ -392,51 +281,6 @@ 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,46 +10,18 @@ function sameDependencyScope(left: ForkDependentReconfig, right: ForkDependentRe
 }
 
 /**
- * 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.
+ * 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.
  */
 export function applyDependentRepick(
   reconfig: Record<string, string>,
   changedField: ForkDependentReconfig,
   blockFields: ForkDependentReconfig[],
-  value: string,
-  previousValue?: string
+  value: 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]
@@ -69,7 +41,7 @@ export function applyDependentRepick(
       }
 
       visitedFields.add(fieldKey)
-      nextState[fieldKey] = DEPENDENT_CLEARED_BY_PARENT
+      nextState[fieldKey] = ''
       if (field.providesContextKey) pendingContextKeys.push(field.providesContextKey)
     }
   }
@@ -79,19 +51,16 @@ 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, 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.
+ * 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.
  */
 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
 }
@@ -109,41 +78,10 @@ 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
@@ -154,12 +92,6 @@ 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,11 +204,10 @@ function DependentSelector({
   reconfig,
   setReconfig,
 }: DependentSelectorProps) {
-  const effectiveValueIn = (f: ForkDependentReconfig, state: Record<string, string>) =>
+  const effectiveValue = (f: ForkDependentReconfig) =>
     copying
-      ? effectiveCopyDependentValue(f, state)
-      : effectiveDependentValue(f, state, parentChanged)
-  const effectiveValue = (f: ForkDependentReconfig) => effectiveValueIn(f, reconfig)
+      ? effectiveCopyDependentValue(f, reconfig)
+      : effectiveDependentValue(f, reconfig, parentChanged)
   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.
@@ -231,17 +230,7 @@ function DependentSelector({
       enabled={parentValue !== '' && ready}
       value={effectiveValue(field)}
       onChange={(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)
-          )
-        )
+        setReconfig((current) => applyDependentRepick(current, field, block.fields, value))
       }
       title={field.title}
     />