fix(workspace-forking): stop double-labelling a custom block's inputs, and derive their controls from the canvas

Two problems with how a repointed custom block's inputs render in the sync modal.

The field title printed twice. The row wrapper already draws the label and its
required marker for every dependent field — `DependentFieldSelector` takes a
`title` only to phrase its placeholder and renders a bare combobox. The
custom-block branch used `ChipModalField`, which owns a label of its own, so every
input showed its name twice. It now renders bare controls like its sibling does.

The control was chosen by re-reading the raw field type instead of asking the
function that already answers this. `subBlockTypeForField` decides what a Start
field becomes on the canvas; the modal had a parallel switch that had already
drifted, rendering a `file[]` input — an upload on the canvas — as a plain text
box, which would write a bare string into a field expecting file references.

`subBlockTypeForField` is now exported and the modal derives from it, so the two
cannot disagree about what a field IS; the modal only decides how that kind draws.
A file input is explicitly `unsupported` rather than falling through: it renders
disabled, saying it is set in the workflow, instead of inviting a value that
cannot work. A test walks every type a Start field can declare and asserts the
modal's choice follows the canvas's, so a type added later surfaces here rather
than silently becoming a text box.

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

Author: icecrasher321

apps/sim/blocks/custom/build-config.ts

@@ -96,7 +96,13 @@ export function assembleCustomBlockInputMapping(params: Record<string, unknown>)
 }
 
 /** Map a Start input field type to the editor sub-block type used to collect it. */
-function subBlockTypeForField(fieldType: string): SubBlockType {
+/**
+ * The sub-block a Start input field becomes on the canvas. Exported so any surface that has to
+ * render or reason about a custom block's inputs derives the field's KIND from here instead of
+ * re-deriving it — the fork sync modal renders its own controls but must agree with this about
+ * what each field is.
+ */
+export function subBlockTypeForField(fieldType: string): SubBlockType {
   switch (fieldType) {
     case 'boolean':
       return 'switch'

apps/sim/ee/workspace-forking/components/fork-sync/custom-block-input-control.test.ts

@@ -2,6 +2,7 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
+import { subBlockTypeForField } from '@/blocks/custom/build-config'
 import {
   CUSTOM_BLOCK_BOOLEAN_FALSE,
   CUSTOM_BLOCK_BOOLEAN_TRUE,
@@ -21,6 +22,28 @@ describe('customBlockInputControl', () => {
     expect(customBlockInputControl('number')).toBe('input')
   })
 
+  it('refuses to offer a file input rather than rendering a text box for it', () => {
+    // `file[]` is an upload on the canvas. A text box would write a plain string into a field
+    // that expects file references — worse than not offering it, because it looks configured.
+    expect(customBlockInputControl('file[]')).toBe('unsupported')
+  })
+
+  it('stays in step with the canvas mapping for every declared field type', () => {
+    // The union a Start field can declare. Deriving from `subBlockTypeForField` means a type
+    // added there surfaces here instead of silently falling through to a text box — which is
+    // exactly how `file[]` came to be mis-rendered.
+    const byCanvasKind = {
+      switch: 'switch',
+      code: 'textarea',
+      'file-upload': 'unsupported',
+    } as const
+
+    for (const fieldType of ['string', 'number', 'boolean', 'object', 'array', 'file[]']) {
+      const canvasKind = subBlockTypeForField(fieldType) as keyof typeof byCanvasKind
+      expect(customBlockInputControl(fieldType)).toBe(byCanvasKind[canvasKind] ?? 'input')
+    }
+  })
+
   it('falls back to a plain input for an unknown or absent type', () => {
     expect(customBlockInputControl('something-new')).toBe('input')
     expect(customBlockInputControl(undefined)).toBe('input')

apps/sim/ee/workspace-forking/components/fork-sync/custom-block-input-control.ts

@@ -1,23 +1,32 @@
+import { subBlockTypeForField } from '@/blocks/custom/build-config'
+
 /**
- * Which control the sync modal renders for a repointed custom block's input, derived from the
- * field type its Start block declares.
+ * Which control the sync modal renders for a repointed custom block's input.
+ *
+ * Derived from `subBlockTypeForField` — the same function that decides what the field becomes
+ * on the canvas — rather than re-reading the raw field type. The modal cannot reuse the canvas
+ * sub-block renderer (that one is bound to the workflow store, by workflow and block id), so it
+ * draws its own controls; taking the field's KIND from one place is what stops the two drifting
+ * when a field type is added. Re-deriving it is how `file[]` came to render as a text box.
  *
- * Mirrors `subBlockTypeForField` in `@/blocks/custom/build-config`, which decides the same thing
- * for the canvas — a field the user configures here must read and behave the way it will once
- * the block is open in the editor.
+ * `unsupported` is a real outcome, not a fallback: a `file[]` input is an upload on the canvas,
+ * and there is nothing meaningful to type for it here. A text box would write a plain string
+ * into a field that expects file references.
  */
-export type CustomBlockInputControl = 'switch' | 'textarea' | 'input'
+export type CustomBlockInputControl = 'switch' | 'textarea' | 'input' | 'unsupported'
 
 export function customBlockInputControl(fieldType: string | undefined): CustomBlockInputControl {
-  switch (fieldType) {
-    // Stored as a real boolean on the canvas (its sub-block is a `switch`), so it must be
-    // toggled here rather than typed — a text field would persist the string `'true'`.
-    case 'boolean':
+  switch (subBlockTypeForField(fieldType ?? '')) {
+    // Stored as a real boolean on the canvas, so it must be toggled rather than typed — a text
+    // field would persist the string `'true'`.
+    case 'switch':
       return 'switch'
-    // Authored as JSON and parsed by the executor before the child receives it.
-    case 'object':
-    case 'array':
+    // A JSON editor on the canvas. The modal has no editor, but the value is the same JSON
+    // string either way and the executor parses it before the child receives it.
+    case 'code':
       return 'textarea'
+    case 'file-upload':
+      return 'unsupported'
     default:
       return 'input'
   }
@@ -58,3 +67,6 @@ const BOOLEAN_OPTIONAL_OPTIONS = [
 export function customBlockBooleanOptions(required: boolean) {
   return required ? BOOLEAN_VALUE_OPTIONS : BOOLEAN_OPTIONAL_OPTIONS
 }
+
+/** Shown in place of a control for a field the sync modal cannot configure. */
+export const CUSTOM_BLOCK_UNSUPPORTED_HINT = 'Set in the workflow — files cannot be configured here'

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

@@ -6,8 +6,9 @@ import {
   ChevronDown,
   Chip,
   ChipCombobox,
-  ChipModalField,
+  ChipInput,
   ChipSwitch,
+  ChipTextarea,
   CollapsibleCard,
   cn,
   FieldDivider,
@@ -34,6 +35,7 @@ import {
 } from '@/ee/workspace-forking/components/fork-sync/cleared-refs-list'
 import { forkRefKey } from '@/ee/workspace-forking/components/fork-sync/copy-reconciliation'
 import {
+  CUSTOM_BLOCK_UNSUPPORTED_HINT,
   customBlockBooleanOptions,
   customBlockInputControl,
 } from '@/ee/workspace-forking/components/fork-sync/custom-block-input-control'
@@ -221,33 +223,54 @@ function DependentSelector({
   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.
+    // target block's own declared input. Renders a BARE control, like `DependentFieldSelector`
+    // does — the row wrapper above already draws the field's label and required marker, so a
+    // labelled `ChipModalField` printed the title twice.
     const setValue = (value: string) =>
       setReconfig((current) => ({ ...current, [dependentKey(field)]: value }))
     const value = effectiveValue(field)
-    const shared = { title: field.title, required: field.required }
     switch (customBlockInputControl(field.fieldType)) {
       case 'switch':
         return (
-          <ChipModalField {...shared} type='custom'>
-            <ChipSwitch
-              options={customBlockBooleanOptions(field.required)}
-              // Passed through unmapped: an unset field is `''`, which matches neither
-              // segment, so the switch renders with nothing selected. Coercing it to False
-              // would show a required flag as configured while the Sync gate still reads it
-              // as empty — the display-versus-gate split this whole carve-out exists to avoid.
-              value={value}
-              onChange={setValue}
-              aria-label={field.title}
-            />
-          </ChipModalField>
+          <ChipSwitch
+            options={customBlockBooleanOptions(field.required)}
+            // Passed through unmapped: an unset field is `''`, which matches neither segment,
+            // so the switch renders with nothing selected. Coercing it to False would show a
+            // required flag as configured while the Sync gate still reads it as empty.
+            value={value}
+            onChange={setValue}
+            aria-label={field.title}
+          />
         )
       case 'textarea':
-        return <ChipModalField {...shared} type='textarea' value={value} onChange={setValue} />
+        return (
+          <ChipTextarea
+            className='w-full'
+            value={value}
+            onChange={(event) => setValue(event.target.value)}
+            rows={3}
+            placeholder={`Enter ${field.title} as JSON`}
+          />
+        )
+      case 'unsupported':
+        return (
+          <ChipInput
+            className='w-full'
+            value=''
+            onChange={() => {}}
+            disabled
+            placeholder={CUSTOM_BLOCK_UNSUPPORTED_HINT}
+          />
+        )
       default:
-        return <ChipModalField {...shared} type='input' value={value} onChange={setValue} />
+        return (
+          <ChipInput
+            className='w-full'
+            value={value}
+            onChange={(event) => setValue(event.target.value)}
+            placeholder={`Enter ${field.title}`}
+          />
+        )
     }
   }