feat(workspace-forking): configure a repointed custom block's inputs at sync time

Repointing a custom block leaves it with no usable inputs — its sub-blocks are
keyed by the SOURCE block's Start field ids, which describe nothing on the new
block. Until now the user had to open the synced workflow and re-enter them by
hand, with no indication anything was missing.

A credential or table swap already makes its `dependsOn` fields reconfigurable in
the sync modal. Repointing a custom block is the same idea at its limit: not a
subset of fields is invalidated but ALL of them, so all of them are offered. They
travel the existing dependent-value channel end to end — collected into the diff,
stored per (target workflow, block, sub-block), pre-filled from the store, gating
Sync when required and empty, and applied to the written state — so nothing about
storage, pre-fill, or the Sync gate is new.

`parentKind`/`parentSourceId` are the block itself, which is already the key a
reconfig is joined to its mapping row on, so the fields render under their own
row with no extra wiring. `selectorKey`/`parentContextKey` become optional: a
custom block's inputs are typed values, not selectors, and the modal renders a
plain field (a textarea for the JSON-valued types) instead of an option list.

Deliberately no seeding from the source value: it belongs to a different block's
field of the same position, so pre-filling it would carry a value meaning
something else. A block whose type does not change is skipped entirely — its ids
still describe it, so its values carry as they always did.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/app/api/workspaces/[id]/fork/diff/route.ts

@@ -14,6 +14,7 @@ import {
 } from '@/ee/workspace-forking/lib/copy/deploy-bridge'
 import { assertCanPromote } from '@/ee/workspace-forking/lib/lineage/authz'
 import { loadForkBlockMap } from '@/ee/workspace-forking/lib/mapping/block-map-store'
+import { collectForkCustomBlockReconfigs } from '@/ee/workspace-forking/lib/mapping/custom-block-reconfigs'
 import {
   collectForkDependentReconfigs,
   collectForkResourceUsages,
@@ -127,7 +128,25 @@ export const GET = withRouteHandler(
     // that's exactly what the first sync copies verbatim, so the pre-fill is honest and
     // configuring it ahead of the first sync is possible (the deterministic target ids
     // already exist).
+    // Custom-block inputs join the same list: repointing a block makes every one of its
+    // inputs reconfigurable (see `collectForkCustomBlockReconfigs`), and they store, pre-fill,
+    // gate Sync, and apply through this identical channel.
+    const customBlockReconfigs = await collectForkCustomBlockReconfigs({
+      items: plan.items,
+      sourceStates,
+      resolveTargetBlockId: resolveBlockId,
+      resolve: plan.resolver,
+      targetWorkspaceId: plan.targetWorkspaceId,
+    })
+
     const dependentReconfigs = [
+      ...customBlockReconfigs.map((field) => ({
+        ...field,
+        currentValue:
+          storedByKey.get(
+            forkDependentValueKey(field.targetWorkflowId, field.targetBlockId, field.subBlockKey)
+          ) ?? field.currentValue,
+      })),
       ...collectForkDependentReconfigs(plan.items, sourceStates, resolveBlockId).map((field) => ({
         ...field,
         currentValue:

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

@@ -6,6 +6,7 @@ import {
   ChevronDown,
   Chip,
   ChipCombobox,
+  ChipModalField,
   ChipSwitch,
   CollapsibleCard,
   cn,
@@ -90,6 +91,9 @@ const NEW_TRIGGER_URL_VALUE = '__new_trigger_url__'
  */
 const MAPPING_TARGET_TRIGGER_CLASS = 'w-[380px] flex-shrink-0'
 
+/** Custom-block input types whose value is JSON, so the field needs a textarea, not a line. */
+const CUSTOM_BLOCK_JSON_FIELD_TYPES = new Set(['object', 'array'])
+
 interface DependentBlock {
   targetBlockId: string
   blockName: string
@@ -205,12 +209,38 @@ function DependentSelector({
   reconfig,
   setReconfig,
 }: DependentSelectorProps) {
+  // A custom block's inputs exist BECAUSE its type was repointed, so `parentChanged` is
+  // always true for them — but unlike a re-picked selector their stored value is the user's
+  // own configuration for the target and must pre-fill, not blank out.
+  const isCustomBlockInput = field.parentKind === 'custom-block'
   const effectiveValueIn = (f: ForkDependentReconfig, state: DependentReconfigState) =>
-    copying
-      ? effectiveCopyDependentValue(f, state)
-      : effectiveDependentValue(f, state, parentChanged)
+    isCustomBlockInput
+      ? effectiveDependentValue(f, state, false)
+      : copying
+        ? effectiveCopyDependentValue(f, state)
+        : effectiveDependentValue(f, state, parentChanged)
   const baselineValueFor = (f: ForkDependentReconfig) => effectiveValueIn(f, {})
   const effectiveValue = (f: ForkDependentReconfig) => effectiveValueIn(f, reconfig)
+  if (isCustomBlockInput) {
+    // Not a selector: there is no parent resource to browse and no options to fetch, just the
+    // target block's own declared input. Rendered as a plain field so the user types the value
+    // the repointed block should run with. Structured types get a textarea because their value
+    // is JSON, matching how `subBlockTypeForField` renders them on the canvas.
+    const setValue = (value: string) =>
+      setReconfig((current) => ({ ...current, [dependentKey(field)]: value }))
+    const shared = {
+      title: field.title,
+      required: field.required,
+      value: effectiveValue(field),
+      onChange: setValue,
+    }
+    return CUSTOM_BLOCK_JSON_FIELD_TYPES.has(field.fieldType ?? '') ? (
+      <ChipModalField {...shared} type='textarea' />
+    ) : (
+      <ChipModalField {...shared} type='input' />
+    )
+  }
+
   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.
@@ -228,7 +258,7 @@ function DependentSelector({
         ...providedValues,
         // Owning workspace, for workspace-scoped selectors like table.columns.
         workspaceId: copying ? sourceWorkspaceId : workspaceId,
-        [field.parentContextKey]: parentValue,
+        ...(field.parentContextKey ? { [field.parentContextKey]: parentValue } : {}),
       }}
       enabled={parentValue !== '' && ready}
       value={effectiveValue(field)}

apps/sim/ee/workspace-forking/lib/copy/copy-workflows.test.ts

@@ -580,9 +580,7 @@ describe('copyWorkflowStateIntoTarget custom-block remap', () => {
       ...baseParams,
       tx: stubTx(),
       transformBlockType: (type) => (type === UAT ? PROD : type),
-      customBlockInputsByBlockId: new Map([
-        ['tgt-blk-cb', new Map([['field-prod-x', 'prod value X']])],
-      ]),
+      dependentOverrides: new Map([['tgt-blk-cb', new Map([['field-prod-x', 'prod value X']])]]),
     })
 
     const subBlocks = writtenBlock().subBlocks ?? {}
@@ -600,7 +598,7 @@ describe('copyWorkflowStateIntoTarget custom-block remap', () => {
       ...baseParams,
       tx: stubTx(),
       transformBlockType: (type) => (type === UAT ? PROD : type),
-      customBlockInputsByBlockId: new Map([
+      dependentOverrides: new Map([
         [
           'tgt-blk-cb',
           new Map([
@@ -625,9 +623,7 @@ describe('copyWorkflowStateIntoTarget custom-block remap', () => {
       ...baseParams,
       tx: stubTx(),
       transformBlockType: (type) => type,
-      customBlockInputsByBlockId: new Map([
-        ['tgt-blk-cb', new Map([['field-prod-x', 'must not apply']])],
-      ]),
+      dependentOverrides: new Map([['tgt-blk-cb', new Map([['field-prod-x', 'must not apply']])]]),
     })
 
     const subBlocks = writtenBlock().subBlocks ?? {}

apps/sim/ee/workspace-forking/lib/copy/copy-workflows.ts

@@ -372,14 +372,6 @@ export interface CopyWorkflowStateParams {
    * the source block rather than deleting the node — see {@link remapForkBlockType}.
    */
   transformBlockType?: (blockType: string, block: { id: string; name: string }) => string
-  /**
-   * Per TARGET block id, the inputs the user configured for a custom block whose type this
-   * sync repoints. Applied ONLY when the type actually changes: the source's inputs are keyed
-   * by the source block's field ids and mean nothing against the new config, so they are
-   * dropped and these written in their place. Already allowlisted to the target block's
-   * declared field ids by the planner, which is the only side that can resolve that config.
-   */
-  customBlockInputsByBlockId?: ReadonlyMap<string, ReadonlyMap<string, string>>
   /**
    * The target workflow's current draft subBlocks (block id -> subBlocks), for
    * `replace` mode only. When present, required dependents that the sync left empty
@@ -441,7 +433,6 @@ export async function copyWorkflowStateIntoTarget(
     folderIdMap,
     transformSubBlocks,
     transformBlockType,
-    customBlockInputsByBlockId,
     targetCurrentBlocks,
     dependentOverrides,
     nameRegistry,
@@ -566,9 +557,12 @@ export async function copyWorkflowStateIntoTarget(
       : block.type
     if (nextBlockType !== block.type) {
       // Only a custom block can change type, and once it does its stored inputs describe the
-      // OLD block's fields. Replace them with what the user configured for the target rather
-      // than leaving the serializer to drop them silently.
-      subBlocks = replaceCustomBlockInputs(subBlocks, customBlockInputsByBlockId?.get(newBlockId))
+      // OLD block's fields. Replace them with what the user configured for the target — the
+      // same stored dependent values every other reconfigurable field uses, just applied
+      // wholesale because ALL of a custom block's inputs are reconfigurable, not a `dependsOn`
+      // subset. `applyDependentOverrides` above is a no-op for them: it allowlists on
+      // `dependsOn` + `selectorKey`, which no custom-block input has.
+      subBlocks = replaceCustomBlockInputs(subBlocks, blockOverrides)
     }
 
     newBlocks[newBlockId] = {

apps/sim/ee/workspace-forking/lib/mapping/custom-block-reconfigs.test.ts

@@ -0,0 +1,143 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ForkReferenceResolver } from '@/ee/workspace-forking/lib/remap/remap-references'
+import type { WorkflowState } from '@/stores/workflows/workflow/types'
+
+const { mockResolveBinding } = vi.hoisted(() => ({ mockResolveBinding: vi.fn() }))
+
+vi.mock('@/lib/workflows/custom-blocks/operations', () => ({
+  resolveCustomBlockToolBinding: mockResolveBinding,
+}))
+
+import { collectForkCustomBlockReconfigs } from '@/ee/workspace-forking/lib/mapping/custom-block-reconfigs'
+
+const PROD = 'custom_block_prod01'
+const UAT = 'custom_block_uat0001'
+
+function stateWith(blocks: Record<string, { type: string; name: string }>): WorkflowState {
+  return {
+    blocks: Object.fromEntries(
+      Object.entries(blocks).map(([id, b]) => [
+        id,
+        { id, type: b.type, name: b.name, position: { x: 0, y: 0 }, subBlocks: {}, outputs: {} },
+      ])
+    ),
+    edges: [],
+    loops: {},
+    parallels: {},
+  } as unknown as WorkflowState
+}
+
+const baseParams = {
+  items: [{ sourceWorkflowId: 'wf-src', targetWorkflowId: 'wf-tgt' }],
+  sourceStates: new Map([
+    ['wf-src', stateWith({ 'blk-cb': { type: UAT, name: 'Invoice Parser' } })],
+  ]),
+  resolveTargetBlockId: (_t: string, sourceBlockId: string) => `tgt-${sourceBlockId}`,
+  targetWorkspaceId: 'ws-parent',
+}
+
+/** Maps the placed UAT block onto the PROD block, i.e. a real repoint. */
+const swapResolver: ForkReferenceResolver = (kind, sourceId) =>
+  kind === 'custom-block' && sourceId === UAT ? PROD : null
+
+describe('collectForkCustomBlockReconfigs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockResolveBinding.mockResolvedValue({
+      workflowId: 'wf-prod-impl',
+      inputFields: [
+        { id: 'field-a', name: 'Invoice URL', type: 'string' },
+        { id: 'field-b', name: 'Options', type: 'object' },
+      ],
+      requiredInputIds: ['field-a'],
+    })
+  })
+
+  it('offers every input of the target block, keyed by the field id the canvas reads', async () => {
+    const out = await collectForkCustomBlockReconfigs({ ...baseParams, resolve: swapResolver })
+
+    expect(out).toHaveLength(2)
+    expect(out.map((f) => f.subBlockKey)).toEqual(['field-a', 'field-b'])
+    expect(out[0]).toMatchObject({
+      parentKind: 'custom-block',
+      // Joined to its own mapping row on (parentKind, parentSourceId) — the SOURCE type is
+      // exactly what the mapping entry's sourceId is.
+      parentSourceId: UAT,
+      targetWorkflowId: 'wf-tgt',
+      targetBlockId: 'tgt-blk-cb',
+      title: 'Invoice URL',
+      fieldType: 'string',
+      required: true,
+    })
+    expect(out[1].required).toBe(false)
+  })
+
+  it('never seeds the source value — it belongs to a different block', async () => {
+    const out = await collectForkCustomBlockReconfigs({ ...baseParams, resolve: swapResolver })
+
+    expect(out.every((f) => f.currentValue === '' && f.sourceValue === '')).toBe(true)
+  })
+
+  it('offers nothing when the type does not change', async () => {
+    // No mapping, or an explicit identity mapping: the field ids still describe this block, so
+    // its values carry across and there is nothing to re-pick.
+    expect(
+      await collectForkCustomBlockReconfigs({ ...baseParams, resolve: () => null })
+    ).toHaveLength(0)
+    expect(
+      await collectForkCustomBlockReconfigs({ ...baseParams, resolve: (_k, id) => id })
+    ).toHaveLength(0)
+    expect(mockResolveBinding).not.toHaveBeenCalled()
+  })
+
+  it('ignores non-custom blocks entirely', async () => {
+    const out = await collectForkCustomBlockReconfigs({
+      ...baseParams,
+      sourceStates: new Map([['wf-src', stateWith({ a: { type: 'agent', name: 'Agent 1' } })]]),
+      resolve: swapResolver,
+    })
+
+    expect(out).toHaveLength(0)
+  })
+
+  it('resolves each distinct target type once, not once per placement', async () => {
+    const out = await collectForkCustomBlockReconfigs({
+      ...baseParams,
+      sourceStates: new Map([
+        [
+          'wf-src',
+          stateWith({
+            'blk-1': { type: UAT, name: 'Parse A' },
+            'blk-2': { type: UAT, name: 'Parse B' },
+          }),
+        ],
+      ]),
+      resolve: swapResolver,
+    })
+
+    // Two placements, each independently configurable, but one schema lookup.
+    expect(mockResolveBinding).toHaveBeenCalledTimes(1)
+    expect(new Set(out.map((f) => f.targetBlockId))).toEqual(new Set(['tgt-blk-1', 'tgt-blk-2']))
+  })
+
+  it('drops the fields rather than failing the whole diff when a target will not resolve', async () => {
+    // An unresolvable target is already a sync blocker via the mapping's own existence check;
+    // throwing here would hide every other finding in the diff.
+    mockResolveBinding.mockResolvedValue(null)
+
+    expect(
+      await collectForkCustomBlockReconfigs({ ...baseParams, resolve: swapResolver })
+    ).toHaveLength(0)
+  })
+
+  it('survives a binding lookup that throws', async () => {
+    mockResolveBinding.mockRejectedValue(new Error('deployment read failed'))
+
+    expect(
+      await collectForkCustomBlockReconfigs({ ...baseParams, resolve: swapResolver })
+    ).toHaveLength(0)
+  })
+})