merge: graft the fork-sync omission fix onto #6776

#6776 landed on staging as a competing fix for the same fork-sync
defects this branch addressed. Take its work wholesale and keep only the
part of ours it does not cover.

Kept from upstream (#6776): the `sameDependencyScope` cascade guard,
`getDisplayedDependentFields` with the "Edit configuration" chip,
per-scope provider indexing, the `blockChainState(block, field, ...)`
scope filter, and the `dependent-reconfigs` / `workspace-fork` contract
changes that emit `dependencyScope` and per-scope context keys for
nested tool params.

Kept from this branch: `DEPENDENT_CLEARED_BY_PARENT` and
`submittedDependentValue`. The scope guard decides WHICH descendants a
re-pick invalidates; the sentinel decides HOW an invalidated one is
represented, and those are different layers. Without the sentinel the
cascade still writes `''` into the reconfig map and
`buildDependentValues` still submits it, so a hidden optional dependent's
stored target value is destroyed by a parent re-pick the user never
applied to it. The scope guard does not close this: two top-level block
subblocks both have `dependencyScope === undefined`, so it is a no-op
there. #6776 also widens the exposure by emitting context keys for
nested tool params that previously could never be cascaded onto.

Also kept: the `previousValue` no-op guard in `applyDependentRepick` (a
separate bug - re-selecting the value a field already shows must not
invalidate its descendants) and the post-sync reset in `use-fork-sync`.

Dropped from this branch: the sticky-visibility predicate in
`isDependentConfigurationActionable` and its three tests. It and
upstream's edit chip are two mechanisms for one visibility problem, and
it is unnecessary - a marked REQUIRED field reads as `''` through
`effectiveDependentValue`, so the existing `required && value === ''`
arm keeps it on screen and keeps it gating Sync. Only marked OPTIONAL
fields drop out of the default view, and those are omitted from the
payload, so hiding them costs nothing; the edit chip brings them back.

Reconciled the cascade assertions in `dependent-value.test.ts` to the
sentinel, including upstream's nested-tool-instance case.

Author: waleedlatif1

apps/docs/package.json

@@ -27,7 +27,7 @@
     "fumadocs-mdx": "14.3.2",
     "fumadocs-openapi": "10.8.1",
     "fumadocs-ui": "16.8.5",
-    "next": "16.2.12",
+    "next": "16.3.1",
     "next-themes": "^0.4.6",
     "react": "19.2.4",
     "react-dom": "19.2.4",

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

@@ -10,6 +10,7 @@ import {
   effectiveCopyDependentValue,
   effectiveDependentValue,
   getActionableDependentFields,
+  getDisplayedDependentFields,
   isDependentClearedByParent,
   isDependentConfigurationActionable,
   submittedDependentValue,
@@ -177,6 +178,63 @@ describe('applyDependentRepick', () => {
     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' })
+
+    expect(
+      applyDependentRepick(
+        { [dependentKey(unrelated)]: 'still-keep-me' },
+        leaf,
+        [leaf, unrelated],
+        'ISSUE-2'
+      )
+    ).toEqual({
+      [dependentKey(leaf)]: 'ISSUE-2',
+      [dependentKey(unrelated)]: 'still-keep-me',
+    })
+  })
+
+  it('does not clear a descendant belonging to another nested tool instance', () => {
+    const projectOne = field({
+      subBlockKey: 'tools[0].projectId',
+      dependencyScope: 'tools[0]',
+      providesContextKey: 'projectId',
+    })
+    const issueOne = field({
+      subBlockKey: 'tools[0].issueKey',
+      dependencyScope: 'tools[0]',
+      consumesContextKeys: ['projectId'],
+    })
+    const projectTwo = field({
+      subBlockKey: 'tools[1].projectId',
+      dependencyScope: 'tools[1]',
+      providesContextKey: 'projectId',
+    })
+    const issueTwo = field({
+      subBlockKey: 'tools[1].issueKey',
+      dependencyScope: 'tools[1]',
+      consumesContextKeys: ['projectId'],
+    })
+    const previous = {
+      [dependentKey(issueOne)]: 'P1-1',
+      [dependentKey(issueTwo)]: 'P2-1',
+    }
+
+    expect(
+      applyDependentRepick(
+        previous,
+        projectOne,
+        [projectOne, issueOne, projectTwo, issueTwo],
+        'P1-NEW'
+      )
+    ).toEqual({
+      [dependentKey(projectOne)]: 'P1-NEW',
+      [dependentKey(issueOne)]: DEPENDENT_CLEARED_BY_PARENT,
+      [dependentKey(issueTwo)]: 'P2-1',
+    })
+  })
 })
 
 describe('submittedDependentValue', () => {
@@ -261,23 +319,6 @@ describe('submittedDependentValue', () => {
     expect(submittedDependentValue(untouched, {}, mappedParent)).toBe('INBOX')
     expect(submittedDependentValue(copied, {}, { copying: true, parentChanged: false })).toBe('doc')
   })
-
-  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' })
-
-    expect(
-      applyDependentRepick(
-        { [dependentKey(unrelated)]: 'still-keep-me' },
-        leaf,
-        [leaf, unrelated],
-        'ISSUE-2'
-      )
-    ).toEqual({
-      [dependentKey(leaf)]: 'ISSUE-2',
-      [dependentKey(unrelated)]: 'still-keep-me',
-    })
-  })
 })
 
 describe('isDependentConfigurationActionable', () => {
@@ -351,47 +392,6 @@ describe('isDependentConfigurationActionable', () => {
     ).toBe(true)
   })
 
-  it('keeps a required field on screen after the user fills it in', () => {
-    const issue = field({ subBlockKey: 'issueKey', required: true, currentValue: '' })
-    const picked = applyDependentRepick({}, issue, [issue], 'ISSUE-7', '')
-
-    expect(
-      isDependentConfigurationActionable(issue, picked, {
-        parentResolved: true,
-        parentChanged: false,
-        copying: false,
-      })
-    ).toBe(true)
-  })
-
-  it('keeps an optional descendant on screen once a parent re-pick blanked it', () => {
-    const spreadsheet = field({
-      subBlockKey: 'spreadsheetId',
-      currentValue: 'doc-old',
-      providesContextKey: 'spreadsheetId',
-    })
-    const range = field({
-      subBlockKey: 'range',
-      currentValue: 'A1:D50',
-      consumesContextKeys: ['spreadsheetId'],
-    })
-    const next = applyDependentRepick(
-      {},
-      spreadsheet,
-      [spreadsheet, range],
-      'doc-new',
-      effectiveDependentValue(spreadsheet, {}, false)
-    )
-
-    expect(
-      isDependentConfigurationActionable(range, next, {
-        parentResolved: true,
-        parentChanged: false,
-        copying: false,
-      })
-    ).toBe(true)
-  })
-
   it('shows a required field that a parent re-pick blanked (it blocks Sync)', () => {
     const spreadsheet = field({
       subBlockKey: 'spreadsheetId',
@@ -503,35 +503,6 @@ describe('getActionableDependentFields', () => {
     ).toEqual(['spreadsheetId', 'sheetName'])
   })
 
-  it("keeps the block's only required field (and its provider) after the user fills it in", () => {
-    const spreadsheet = field({
-      subBlockKey: 'spreadsheetId',
-      title: 'Spreadsheet',
-      currentValue: 'doc-target',
-      providesContextKey: 'spreadsheetId',
-    })
-    const sheet = field({
-      subBlockKey: 'sheetName',
-      title: 'Sheet',
-      currentValue: '',
-      required: true,
-      consumesContextKeys: ['spreadsheetId'],
-    })
-    const fields = [spreadsheet, sheet]
-
-    // The card is on screen because the required sheet is missing; the user picks one.
-    expect(
-      getActionableDependentFields(fields, {}, unchangedMappedParent).map((f) => f.subBlockKey)
-    ).toEqual(['spreadsheetId', 'sheetName'])
-    const picked = applyDependentRepick({}, sheet, fields, 'Sheet1', '')
-
-    // The block still has configurable fields, so its workflow card cannot unmount underneath
-    // the user - who would otherwise be unable to see or change what they just picked.
-    expect(
-      getActionableDependentFields(fields, picked, unchangedMappedParent).map((f) => f.subBlockKey)
-    ).toEqual(['spreadsheetId', 'sheetName'])
-  })
-
   it('walks transitive providers and leaves unrelated optional fields hidden', () => {
     const unrelated = field({
       subBlockKey: 'optionalLabel',
@@ -567,4 +538,63 @@ describe('getActionableDependentFields', () => {
       ).map((dependent) => dependent.subBlockKey)
     ).toEqual(['siteId', 'driveId', 'spreadsheetId'])
   })
+
+  it('finds a required child provider only within the same nested tool instance', () => {
+    const projectOne = field({
+      subBlockKey: 'tools[0].projectId',
+      dependencyScope: 'tools[0]',
+      providesContextKey: 'projectId',
+    })
+    const projectTwo = field({
+      subBlockKey: 'tools[1].projectId',
+      dependencyScope: 'tools[1]',
+      providesContextKey: 'projectId',
+    })
+    const issueOne = field({
+      subBlockKey: 'tools[0].issueKey',
+      dependencyScope: 'tools[0]',
+      currentValue: '',
+      required: true,
+      consumesContextKeys: ['projectId'],
+    })
+
+    expect(
+      getActionableDependentFields(
+        [projectOne, projectTwo, issueOne],
+        {},
+        unchangedMappedParent
+      ).map((dependent) => dependent.subBlockKey)
+    ).toEqual(['tools[0].projectId', 'tools[0].issueKey'])
+  })
+})
+
+describe('getDisplayedDependentFields', () => {
+  const unchangedMappedParent = {
+    parentResolved: true,
+    parentChanged: false,
+    copying: false,
+  }
+
+  it('reveals configured and optional fields only after the explicit edit action', () => {
+    const configuredRequired = field({ subBlockKey: 'projectId', required: true })
+    const optional = field({ subBlockKey: 'issueKey', currentValue: '', required: false })
+
+    expect(
+      getDisplayedDependentFields([configuredRequired, optional], {}, unchangedMappedParent, false)
+    ).toEqual([])
+    expect(
+      getDisplayedDependentFields([configuredRequired, optional], {}, unchangedMappedParent, true)
+    ).toEqual([configuredRequired, optional])
+  })
+
+  it('never shows selectors before their parent mapping is resolved', () => {
+    expect(
+      getDisplayedDependentFields(
+        [field()],
+        {},
+        { ...unchangedMappedParent, parentResolved: false },
+        true
+      )
+    ).toEqual([])
+  })
 })

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

@@ -5,6 +5,10 @@ export function dependentKey(dependent: ForkDependentReconfig): string {
   return `${dependent.targetWorkflowId}:${dependent.targetBlockId}:${dependent.subBlockKey}`
 }
 
+function sameDependencyScope(left: ForkDependentReconfig, right: ForkDependentReconfig): boolean {
+  return left.dependencyScope === right.dependencyScope
+}
+
 /**
  * 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
@@ -47,7 +51,13 @@ export function applyDependentRepick(
 
     for (const field of blockFields) {
       const fieldKey = dependentKey(field)
-      if (visitedFields.has(fieldKey) || !field.consumesContextKeys.includes(contextKey)) continue
+      if (
+        !sameDependencyScope(changedField, field) ||
+        visitedFields.has(fieldKey) ||
+        !field.consumesContextKeys.includes(contextKey)
+      ) {
+        continue
+      }
 
       visitedFields.add(fieldKey)
       nextState[fieldKey] = DEPENDENT_CLEARED_BY_PARENT
@@ -136,10 +146,11 @@ export interface DependentConfigurationState {
  * 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.
  *
- * Anything the session already touched stays shown - the user picked it, cleared it, or a parent
- * re-pick invalidated it. Re-deriving pure satisfaction would pull the field (and, when it is its
- * block's only one, the whole workflow card) out from under the user the instant they filled it
- * in, and would hide a descendant a parent re-pick just blanked.
+ * 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,
@@ -148,7 +159,6 @@ export function isDependentConfigurationActionable(
 ): boolean {
   if (!state.parentResolved) return false
   if (state.parentChanged || state.copying) return true
-  if (reconfig[dependentKey(field)] !== undefined) return true
   return field.required && effectiveDependentValue(field, reconfig, false) === ''
 }
 
@@ -165,17 +175,23 @@ export function getActionableDependentFields(
   const actionable = new Set(
     fields.filter((field) => isDependentConfigurationActionable(field, reconfig, state))
   )
-  const providersByContextKey = new Map<string, ForkDependentReconfig>()
+  const providersByScope = new Map<string | undefined, Map<string, ForkDependentReconfig>>()
   for (const field of fields) {
-    if (field.providesContextKey) providersByContextKey.set(field.providesContextKey, field)
+    if (!field.providesContextKey) continue
+    let providers = providersByScope.get(field.dependencyScope)
+    if (!providers) {
+      providers = new Map()
+      providersByScope.set(field.dependencyScope, providers)
+    }
+    providers.set(field.providesContextKey, field)
   }
 
   const pending = Array.from(actionable)
   for (let index = 0; index < pending.length; index += 1) {
     const field = pending[index]
     if (!field) continue
     for (const contextKey of field.consumesContextKeys) {
-      const provider = providersByContextKey.get(contextKey)
+      const provider = providersByScope.get(field.dependencyScope)?.get(contextKey)
       if (!provider || actionable.has(provider)) continue
       actionable.add(provider)
       pending.push(provider)
@@ -184,3 +200,18 @@ export function getActionableDependentFields(
 
   return fields.filter((field) => actionable.has(field))
 }
+
+/**
+ * Fields rendered in the mapping UI. Required missing fields remain visible by default; an
+ * explicit edit action reveals every active selector under a resolved parent without changing
+ * which fields gate Sync.
+ */
+export function getDisplayedDependentFields(
+  fields: ForkDependentReconfig[],
+  reconfig: Record<string, string>,
+  state: DependentConfigurationState,
+  showConfigured: boolean
+): ForkDependentReconfig[] {
+  if (!state.parentResolved) return []
+  return showConfigured ? fields : getActionableDependentFields(fields, reconfig, state)
+}