update UX nits

Author: icecrasher321

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/fork-activity-panel/fork-activity-panel.tsx

@@ -247,9 +247,9 @@ function ForkJobRow({ job }: { job: BackgroundWorkItem }) {
           {report.groups.map((group) => (
             <ReportGroupRow key={group.label} group={group} />
           ))}
-          {report.notes.map((note) => (
+          {report.notes.map((note, index) => (
             <span
-              key={note.value}
+              key={`${index}:${note.value}`}
               className={cn(
                 'text-caption',
                 note.warning ? 'text-[var(--text-error)]' : 'text-[var(--text-tertiary)]'

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/fork-resource-picker/fork-resource-picker.tsx

@@ -22,7 +22,8 @@ interface ResourceKindRowProps {
   label: string
   items: ForkResourcePickerItem[]
   selected: Set<string>
-  onToggleAll: (selectAll: boolean) => void
+  /** Toggle the given ids on/off. Used for select-all over the currently-VISIBLE (filtered) subset. */
+  onToggleMany: (ids: string[], checked: boolean) => void
   onToggleItem: (id: string, checked: boolean) => void
   disabled?: boolean
 }
@@ -38,32 +39,39 @@ export function ResourceKindRow({
   label,
   items,
   selected,
-  onToggleAll,
+  onToggleMany,
   onToggleItem,
   disabled = false,
 }: ResourceKindRowProps) {
   const [expanded, setExpanded] = useState(false)
   const [query, setQuery] = useState('')
   const fieldId = useId()
 
-  const total = items.length
-  const selectedCount = selected.size
-  const headerState = selectedCount === 0 ? false : selectedCount === total ? true : 'indeterminate'
-
   const filtered = useMemo(() => {
     const trimmed = query.trim().toLowerCase()
     if (!trimmed) return items
     return items.filter((item) => item.label.toLowerCase().includes(trimmed))
   }, [items, query])
 
+  // Count + header state + select-all are scoped to the VISIBLE (filtered) items so a search never
+  // selects or counts hidden ones. With no filter, `filtered === items`, so behavior is unchanged.
+  const total = filtered.length
+  const selectedCount = filtered.reduce((count, item) => count + (selected.has(item.id) ? 1 : 0), 0)
+  const headerState = selectedCount === 0 ? false : selectedCount === total ? true : 'indeterminate'
+
   return (
     <div className='flex flex-col gap-1'>
       <div className='flex items-center gap-2 text-[var(--text-body)] text-sm'>
         <Checkbox
           size='sm'
           aria-label={`Copy all ${label}`}
           checked={headerState}
-          onCheckedChange={() => onToggleAll(headerState !== true)}
+          onCheckedChange={() =>
+            onToggleMany(
+              filtered.map((item) => item.id),
+              headerState !== true
+            )
+          }
           disabled={disabled}
         />
         <button

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/fork-workspace-modal/fork-workspace-modal.tsx

@@ -316,15 +316,15 @@ export function ForkWorkspaceModal({
                             label={kind.label}
                             items={resources.data?.[kind.key] ?? []}
                             selected={selected[kind.key]}
-                            onToggleAll={(selectAll) =>
-                              setSelected((prev) => ({
-                                ...prev,
-                                [kind.key]: selectAll
-                                  ? new Set(
-                                      (resources.data?.[kind.key] ?? []).map((item) => item.id)
-                                    )
-                                  : new Set<string>(),
-                              }))
+                            onToggleMany={(ids, checked) =>
+                              setSelected((prev) => {
+                                const next = new Set(prev[kind.key])
+                                for (const id of ids) {
+                                  if (checked) next.add(id)
+                                  else next.delete(id)
+                                }
+                                return { ...prev, [kind.key]: next }
+                              })
                             }
                             onToggleItem={(id, checked) =>
                               setSelected((prev) => {

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/promote-workspace-modal/cleared-refs-list.test.ts

@@ -5,36 +5,54 @@ import { describe, expect, it } from 'vitest'
 import type { ForkClearedRef } from '@/lib/api/contracts/workspace-fork'
 import { selectVisibleClearedRefs } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/promote-workspace-modal/cleared-refs-list'
 
-const ref = (overrides: Partial<ForkClearedRef>): ForkClearedRef => ({
+type ReferenceRef = Extract<ForkClearedRef, { cause: 'reference' }>
+type WorkflowRef = Extract<ForkClearedRef, { cause: 'workflow' }>
+type DependentRef = Extract<ForkClearedRef, { cause: 'dependent' }>
+
+const base = {
   targetWorkflowId: 'wf-tgt',
   workflowName: 'Workflow',
   blockId: 'block-1',
   blockLabel: 'Block',
-  fieldLabel: 'Field',
-  kind: 'credential',
-  sourceId: 'src-1',
   sourceLabel: 'Source',
-  cause: 'reference',
-  parentKind: null,
-  parentSourceId: null,
-  ...overrides,
+}
+
+const referenceRef = (
+  kind: ReferenceRef['kind'],
+  sourceId: string,
+  fieldLabel = 'Field'
+): ReferenceRef => ({ ...base, fieldLabel, cause: 'reference', kind, sourceId })
+
+const workflowRef = (sourceId: string, fieldLabel = 'Workflow'): WorkflowRef => ({
+  ...base,
+  fieldLabel,
+  cause: 'workflow',
+  kind: 'workflow',
+  sourceId,
 })
 
-// The modal's predicate is `mapped || copied`; here we model each disposition separately so the
-// document-under-KB case is exercised for BOTH a copied parent and a mapped parent.
+const dependentRef = (
+  parentKind: DependentRef['parentKind'],
+  parentSourceId: string,
+  fieldLabel = 'Field'
+): DependentRef => ({
+  ...base,
+  fieldLabel,
+  cause: 'dependent',
+  kind: parentKind,
+  sourceId: parentSourceId,
+  parentKind,
+  parentSourceId,
+})
+
+// The modal's predicate is `mapped || copied`; here we model each disposition as a resolved key so
+// the document-under-KB case is exercised for both a copied parent and a mapped parent.
 const resolvedKeys = (...keys: string[]) => {
   const set = new Set(keys)
   return (kind: string, sourceId: string) => set.has(`${kind}:${sourceId}`)
 }
 
-const documentDependent = ref({
-  cause: 'dependent',
-  fieldLabel: 'Document',
-  kind: 'knowledge-base',
-  sourceId: 'kb-1',
-  parentKind: 'knowledge-base',
-  parentSourceId: 'kb-1',
-})
+const documentDependent = dependentRef('knowledge-base', 'kb-1', 'Document')
 
 describe('selectVisibleClearedRefs', () => {
   it('drops a document dependent when its parent KB is selected for copy', () => {
@@ -57,14 +75,7 @@ describe('selectVisibleClearedRefs', () => {
   })
 
   it('keeps a credential-anchored dependent even when the credential is mapped (label still clears)', () => {
-    const labelDependent = ref({
-      cause: 'dependent',
-      fieldLabel: 'Label',
-      kind: 'credential',
-      sourceId: 'cred-1',
-      parentKind: 'credential',
-      parentSourceId: 'cred-1',
-    })
+    const labelDependent = dependentRef('credential', 'cred-1', 'Label')
     // A mapped credential remaps to a different account, so the account-scoped label is cleared
     // regardless - the entry must stay even though the parent is "resolved".
     expect(selectVisibleClearedRefs([labelDependent], resolvedKeys('credential:cred-1'))).toEqual([
@@ -74,26 +85,14 @@ describe('selectVisibleClearedRefs', () => {
   })
 
   it('keeps a table-anchored dependent even when the table is copied/mapped (column still clears)', () => {
-    const columnDependent = ref({
-      cause: 'dependent',
-      fieldLabel: 'Column',
-      kind: 'table',
-      sourceId: 'tbl-1',
-      parentKind: 'table',
-      parentSourceId: 'tbl-1',
-    })
+    const columnDependent = dependentRef('table', 'tbl-1', 'Column')
     expect(selectVisibleClearedRefs([columnDependent], resolvedKeys('table:tbl-1'))).toEqual([
       columnDependent,
     ])
   })
 
   it('drops the parent KB reference AND its child document together when the KB is resolved', () => {
-    const kbReference = ref({
-      cause: 'reference',
-      fieldLabel: 'Knowledge Base',
-      kind: 'knowledge-base',
-      sourceId: 'kb-1',
-    })
+    const kbReference = referenceRef('knowledge-base', 'kb-1', 'Knowledge Base')
     expect(
       selectVisibleClearedRefs(
         [kbReference, documentDependent],
@@ -103,7 +102,7 @@ describe('selectVisibleClearedRefs', () => {
   })
 
   it('applies the same predicate to a reference entry (drops resolved, keeps unresolved)', () => {
-    const credentialReference = ref({ cause: 'reference', kind: 'credential', sourceId: 'cred-1' })
+    const credentialReference = referenceRef('credential', 'cred-1')
     expect(
       selectVisibleClearedRefs([credentialReference], resolvedKeys('credential:cred-1'))
     ).toEqual([])
@@ -113,14 +112,9 @@ describe('selectVisibleClearedRefs', () => {
   })
 
   it('always keeps a workflow reference (it cannot be resolved in the modal)', () => {
-    const workflowReference = ref({ cause: 'workflow', kind: 'workflow', sourceId: 'wf-other' })
+    const workflowReference = workflowRef('wf-other')
     expect(
       selectVisibleClearedRefs([workflowReference], resolvedKeys('workflow:wf-other'))
     ).toEqual([workflowReference])
   })
-
-  it('keeps a dependent missing its parent identity (defensive)', () => {
-    const orphanDependent = ref({ cause: 'dependent', parentKind: null, parentSourceId: null })
-    expect(selectVisibleClearedRefs([orphanDependent], resolvedKeys())).toEqual([orphanDependent])
-  })
 })

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/workspace-header/components/promote-workspace-modal/cleared-refs-list.ts

@@ -18,8 +18,8 @@ const PARENT_KINDS_THAT_PRESERVE_CHILD: ReadonlySet<string> = new Set(['knowledg
  *  - `reference`: drops off once its own resource is resolved (mapped or copied).
  *  - `dependent`: drops off once its PARENT resource (`parentKind`/`parentSourceId`) is resolved -
  *    using the SAME predicate as `reference` - but ONLY when the child follows that parent (a
- *    document under a KB). A credential- or table-anchored dependent is cleared on any parent
- *    remap, so it stays even after the parent is mapped. A dependent missing its parent stays.
+ *    document under a KB). A credential- or table-anchored dependent is cleared on any parent remap,
+ *    so it stays even after the parent is mapped.
  *  - `workflow`: always stays - a cross-workflow reference cannot be resolved in the modal.
  *
  * Pure so the reactive list is unit-testable independent of the modal's selection state.
@@ -30,12 +30,8 @@ export function selectVisibleClearedRefs(
 ): ForkClearedRef[] {
   return clearedRefs.filter((ref) => {
     if (ref.cause === 'reference') return !isResolved(ref.kind, ref.sourceId)
-    if (
-      ref.cause === 'dependent' &&
-      ref.parentKind &&
-      ref.parentSourceId &&
-      PARENT_KINDS_THAT_PRESERVE_CHILD.has(ref.parentKind)
-    ) {
+    // The discriminated union guarantees `parentKind`/`parentSourceId` on a `dependent` variant.
+    if (ref.cause === 'dependent' && PARENT_KINDS_THAT_PRESERVE_CHILD.has(ref.parentKind)) {
       return !isResolved(ref.parentKind, ref.parentSourceId)
     }
     return true