fix(table): clearing a workflow output cell also clears its exec record

When the user wipes a workflow output column value, the auto-fire reactor
needs to be re-armed for that group. Previously, a stale cancelled / error
exec record blocked the eligibility predicate (gate at line 79 hard-rejects
those statuses on auto-fire) and the cell stayed stuck in its old terminal
state — visible as "Cancelled" cells that wouldn't re-run no matter what.

Both updateRow and batchUpdateRows now derive an `executionsPatch[gid] = null`
for any output column the patch sets to empty. The data clear and the exec
clear ride the same SQL transaction, so the row never lands in a stale-
status-with-empty-data state.

Symmetric to how `completed` already worked via `areOutputsFilled` in the
predicate — clearing the cell wins over the prior exec status, regardless of
what that status was.

(Also revert typewriter-trigger experiment from a parallel session that was
in-progress on this branch.)

Author: TheodoreSpeaks

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-content.tsx

@@ -1,10 +1,9 @@
 'use client'
 
-import { useRef } from 'react'
 import type { RowExecutionMetadata } from '@/lib/table'
 import type { SaveReason } from '../../../types'
 import type { DisplayColumn } from '../types'
-import { CellRender, type CellRenderKind, resolveCellRender } from './cell-render'
+import { CellRender, resolveCellRender } from './cell-render'
 import { InlineEditor } from './inline-editors'
 
 interface CellContentProps {
@@ -40,10 +39,7 @@ export function CellContent({
   onCancel,
   waitingOnLabels,
 }: CellContentProps) {
-  const kind = useTypewriterTrigger(
-    resolveCellRender({ value, exec, column, waitingOnLabels }),
-    column
-  )
+  const kind = resolveCellRender({ value, exec, column, waitingOnLabels })
 
   return (
     <>
@@ -62,29 +58,3 @@ export function CellContent({
     </>
   )
 }
-
-/**
- * Sets `animateMount: true` on a workflow-output `value` kind when the cell
- * just transitioned into the value state from a non-value one (queued /
- * running / waiting / error / cancelled / empty) — i.e., the worker just
- * filled it in — or when an existing value's text changed. Stays `false` on
- * initial page load (cell mounts already filled) and on no-op refetches.
- */
-function useTypewriterTrigger(kind: CellRenderKind, column: DisplayColumn): CellRenderKind {
-  const mountedRef = useRef(false)
-  const lastKindRef = useRef<CellRenderKind['kind'] | null>(null)
-  const lastValueTextRef = useRef<string | null>(null)
-  if (!column.workflowGroupId) return kind
-  const isFirstRender = !mountedRef.current
-  mountedRef.current = true
-  const prevKind = lastKindRef.current
-  const prevText = lastValueTextRef.current
-  lastKindRef.current = kind.kind
-  if (kind.kind === 'value') lastValueTextRef.current = kind.text
-  if (kind.kind !== 'value') return kind
-  if (isFirstRender) return kind
-  // Just transitioned into value from a non-value state, or text changed.
-  const justTransitioned = prevKind !== 'value' || prevText !== kind.text
-  if (!justTransitioned) return kind
-  return { ...kind, animateMount: true }
-}

apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/cells/cell-render.tsx

@@ -1,7 +1,6 @@
 'use client'
 
 import type React from 'react'
-import { useEffect, useRef, useState } from 'react'
 import { Badge, Checkbox, Tooltip } from '@/components/emcn'
 import { cn } from '@/lib/core/utils/cn'
 import type { RowExecutionMetadata } from '@/lib/table'
@@ -27,7 +26,7 @@ import type { DisplayColumn } from '../types'
  */
 export type CellRenderKind =
   // Workflow-output cells
-  | { kind: 'value'; text: string; animateMount?: boolean }
+  | { kind: 'value'; text: string }
   | { kind: 'block-error' }
   | { kind: 'running' }
   | { kind: 'pending-upstream' }
@@ -132,7 +131,7 @@ export function CellRender({ kind, isEditing }: CellRenderProps): React.ReactEle
             isEditing && 'invisible'
           )}
         >
-          <Typewriter text={kind.text} animateMount={kind.animateMount ?? false} />
+          {kind.text}
         </span>
       )
 
@@ -254,54 +253,3 @@ function Wrap({ isEditing, children }: { isEditing: boolean; children: React.Rea
   if (!isEditing) return <>{children}</>
   return <div className='invisible'>{children}</div>
 }
-
-const TYPEWRITER_MS_PER_CHAR = 18
-const TYPEWRITER_TOTAL_MS_CAP = 600
-
-/**
- * Reveals `text` one character at a time. The caller controls whether to
- * animate on mount via `animateMount` — true when this Typewriter just
- * appeared because the cell transitioned from a non-value state (queued /
- * running / error) to a value, false on the first render of an already-filled
- * cell. Subsequent text changes always animate. Caps total runtime at
- * `TYPEWRITER_TOTAL_MS_CAP` so long values still finish fast.
- */
-function Typewriter({ text, animateMount }: { text: string; animateMount: boolean }) {
-  const [shown, setShown] = useState(animateMount ? 1 : text.length)
-  // Track the last text we animated for so StrictMode's effect double-invoke
-  // (and Fast Refresh remounts) don't re-trigger the animation for an
-  // already-shown value.
-  const lastAnimatedTextRef = useRef<string | null>(animateMount ? null : text)
-  useEffect(() => {
-    if (lastAnimatedTextRef.current === text) {
-      setShown(text.length)
-      return
-    }
-    lastAnimatedTextRef.current = text
-    if (text.length <= 1) {
-      setShown(text.length)
-      return
-    }
-    setShown(1)
-    const msPerChar = Math.max(
-      4,
-      Math.min(TYPEWRITER_MS_PER_CHAR, Math.floor(TYPEWRITER_TOTAL_MS_CAP / text.length))
-    )
-    let cancelled = false
-    let i = 1
-    let timeoutId = window.setTimeout(function tick() {
-      if (cancelled) return
-      i++
-      setShown(i)
-      if (i < text.length) timeoutId = window.setTimeout(tick, msPerChar)
-    }, msPerChar)
-    return () => {
-      cancelled = true
-      window.clearTimeout(timeoutId)
-    }
-    // animateMount is consulted only via the lazy init of `lastAnimatedTextRef`;
-    // changing it later is meaningless.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [text])
-  return <>{text.slice(0, shown)}</>
-}

apps/sim/lib/table/service.ts

@@ -1519,6 +1519,39 @@ export async function getRowById(
   }
 }
 
+/**
+ * When a user edit clears a workflow output column to empty, also clear the
+ * exec record for that group. Without this, a `cancelled` (or `error`) exec
+ * sticks on the row even after the user wipes the output, blocking the
+ * auto-fire reactor (which respects terminal states). Treating the cleared
+ * cell as "user wants this re-armed" matches the rule that cells are the
+ * source of truth — we already do this for `completed` via
+ * `areOutputsFilled` in the eligibility predicate; this extends the same
+ * behavior to error/cancelled by making the data clear remove the exec.
+ *
+ * Returns a merged `executionsPatch` (caller's patch + null for groups whose
+ * outputs were cleared), or the caller's patch unchanged if nothing applies.
+ */
+function deriveExecClearsForDataPatch(
+  dataPatch: RowData,
+  schema: TableSchema,
+  callerPatch: Record<string, RowExecutionMetadata | null> | undefined
+): Record<string, RowExecutionMetadata | null> | undefined {
+  const groupsToClear = new Set<string>()
+  for (const [columnName, value] of Object.entries(dataPatch)) {
+    const cleared = value === null || value === undefined || value === ''
+    if (!cleared) continue
+    const col = schema.columns.find((c) => c.name === columnName)
+    if (col?.workflowGroupId) groupsToClear.add(col.workflowGroupId)
+  }
+  if (groupsToClear.size === 0) return callerPatch
+  const merged: Record<string, RowExecutionMetadata | null> = { ...(callerPatch ?? {}) }
+  for (const gid of groupsToClear) {
+    if (!(gid in merged)) merged[gid] = null
+  }
+  return merged
+}
+
 /** Merges an `executionsPatch` into the row's existing executions blob. */
 function applyExecutionsPatch(
   existing: RowExecutions,
@@ -1590,7 +1623,14 @@ export async function updateRow(
     ...(existingRow.data as RowData),
     ...data.data,
   }
-  const mergedExecutions = applyExecutionsPatch(existingRow.executions, data.executionsPatch)
+  // Auto-clear exec records for workflow output columns the user just wiped,
+  // so the auto-fire reactor sees no exec and re-arms the cell.
+  const effectiveExecutionsPatch = deriveExecClearsForDataPatch(
+    data.data,
+    table.schema,
+    data.executionsPatch
+  )
+  const mergedExecutions = applyExecutionsPatch(existingRow.executions, effectiveExecutionsPatch)
 
   // Validate size
   const sizeValidation = validateRowSize(mergedData)
@@ -1653,7 +1693,7 @@ export async function updateRow(
   // in-memory snapshot and the last writer wins, clobbering the other's
   // exec keys. The data field still does last-writer-wins because that's
   // the user's edit, but exec records are independently keyed by groupId.
-  const executionsExpr = buildExecutionsSqlPatch(data.executionsPatch)
+  const executionsExpr = buildExecutionsSqlPatch(effectiveExecutionsPatch)
   const updated = await db
     .update(userTableRows)
     .set({
@@ -1913,7 +1953,14 @@ export async function batchUpdateRows(
   for (const update of data.updates) {
     const existing = existingMap.get(update.rowId)!
     const merged = { ...existing.data, ...update.data }
-    const mergedExecutions = applyExecutionsPatch(existing.executions, update.executionsPatch)
+    // Auto-clear exec records for workflow output columns the user just
+    // wiped — same rationale as `updateRow`.
+    const effectiveExecutionsPatch = deriveExecClearsForDataPatch(
+      update.data,
+      table.schema,
+      update.executionsPatch
+    )
+    const mergedExecutions = applyExecutionsPatch(existing.executions, effectiveExecutionsPatch)
 
     const sizeValidation = validateRowSize(merged)
     if (!sizeValidation.valid) {
@@ -1929,7 +1976,7 @@ export async function batchUpdateRows(
       rowId: update.rowId,
       mergedData: merged,
       mergedExecutions,
-      executionsPatch: update.executionsPatch,
+      executionsPatch: effectiveExecutionsPatch,
     })
   }