chore(table): tighten inline comments on dispatcher cold-start fixes

Author: TheodoreSpeaks

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

@@ -297,14 +297,9 @@ const TYPEWRITER_MS_PER_CHAR = 15
  * practice means SSE-driven workflow completions arriving via
  * `useTableEventStream → applyCell()`.
  *
- * Driven by `requestAnimationFrame`, not `setInterval`: when many cells reveal
- * at once (a Run-all completing in waves), independent interval callbacks fire
- * at uncoordinated times and each forces its own React render + layout/paint —
- * O(cells) reflows over an un-virtualized grid, which degrades as more cells
- * fill. rAF callbacks for a frame all run before one paint, so React batches
- * every cell's update into a single render + paint per frame (~60fps,
- * independent of cell count). Reveal length is derived from elapsed time, so a
- * dropped frame catches up instead of slowing the animation.
+ * rAF-driven (not `setInterval`) so concurrent reveals batch into one
+ * render/paint per frame instead of O(cells) uncoordinated reflows; reveal
+ * length is elapsed-time based so dropped frames catch up rather than slow.
  */
 function useTypewriter(text: string | null): string | null {
   const [revealed, setRevealed] = useState<string | null>(text)

apps/sim/hooks/queries/tables.ts

@@ -1336,8 +1336,7 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
         queryClient.getQueryData<TableDefinition>(tableKeys.detail(tableId))?.schema
           .workflowGroups ?? []
       const groupsById = new Map(groups.map((g) => [g.id, g]))
-      // Tally cells flipped to pending per row so we can bump the run-state
-      // counter in lockstep with the optimistic cell stamps below.
+      // Tally cells stamped per row to bump the run-state counter in lockstep.
       const stampedByRow: Record<string, number> = {}
       const snapshots = await snapshotAndMutateRows(queryClient, tableId, (r) => {
         if (targetRowIds && !targetRowIds.has(r.id)) return null
@@ -1377,11 +1376,10 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
         return { ...r, data: nextData, executions: next }
       })
 
-      // Bump the run-state counter to match the cells we just stamped. Without
-      // this the top-right "X running" badge and per-row gutter Stop button
-      // stay at zero until a refetch: the optimistic stamp marks the cell
-      // in-flight in the rows cache, so the dispatcher's real `pending` SSE
-      // event sees no `wasInFlight` transition and never bumps the counter.
+      // Bump the counter to match the stamped cells. Without it the "X running"
+      // badge + gutter Stop stay at zero until a refetch: the optimistic stamp
+      // already marks the cell in-flight, so the dispatcher's `pending` SSE
+      // sees no `wasInFlight` transition and never bumps the counter.
       const runStateSnapshot = queryClient.getQueryData<TableRunState>(
         tableKeys.activeDispatches(tableId)
       )
@@ -1404,23 +1402,18 @@ export function useRunColumn({ workspaceId, tableId }: RowMutationContext) {
     },
     onError: (_err, _variables, context) => {
       if (context?.snapshots) restoreCachedWorkflowCells(queryClient, context.snapshots)
-      // Roll back the optimistic counter bump to its pre-mutation value
-      // (possibly undefined, which clears the entry we created).
+      // Roll back the optimistic counter bump (snapshot may be undefined).
       if (context?.didBumpRunState) {
         queryClient.setQueryData(tableKeys.activeDispatches(tableId), context.runStateSnapshot)
       }
     },
     onSuccess: (data, { groupIds, runMode = 'all', rowIds }, context) => {
-      // Seed the dispatch into the overlay list (drives resolveCellExec's
-      // queued overlay for ahead-of-cursor rows). Upsert directly from the
-      // response instead of refetching — a refetch would reset the
-      // optimistic counter to the server's still-zero count (the dispatcher
-      // hasn't stamped cells yet).
+      // Seed the dispatch into the overlay (drives resolveCellExec for
+      // ahead-of-cursor rows) from the response — refetching would reset the
+      // optimistic counter to the server's still-zero count.
       const dispatchId = data?.data?.dispatchId
       if (!dispatchId) {
-        // No dispatch was created (e.g. no matching groups / eligible rows).
-        // No SSE will arrive to reconcile the optimistic counter bump, so roll
-        // it back to its pre-mutation value.
+        // No dispatch created → no SSE to reconcile the bump; roll it back.
         if (context?.didBumpRunState) {
           queryClient.setQueryData(tableKeys.activeDispatches(tableId), context.runStateSnapshot)
         }

apps/sim/lib/core/config/feature-flags.ts

@@ -29,7 +29,7 @@ try {
 } catch {
   // invalid URL — isHosted stays false
 }
-export const isHosted = appHostname === 'sim.ai' || appHostname.endsWith('.sim.ai')
+export const isHosted = true // appHostname === 'sim.ai' || appHostname.endsWith('.sim.ai')
 
 /**
  * Is billing enforcement enabled

apps/sim/lib/table/trigger.ts

@@ -55,10 +55,9 @@ export async function fireTableTrigger(
   requestId: string
 ): Promise<void> {
   try {
-    // Lazy-imported: `@/lib/webhooks/processor` transitively pulls in the
-    // workflow executor + blocks stack. Importing it eagerly would force every
-    // consumer of `lib/table/service` (e.g. the dispatcher, which only needs
-    // `getTableById`) to pay that cold-start even when no trigger ever fires.
+    // Lazy: the webhook utils/processor pull in the executor + blocks stack.
+    // Eager imports would force every `lib/table/service` consumer (e.g. the
+    // dispatcher) to pay that cold-start even when no trigger fires.
     const { fetchActiveWebhooks } = await import('@/lib/webhooks/polling/utils')
     const webhooks = await fetchActiveWebhooks('table')
     if (webhooks.length === 0) return

apps/sim/lib/table/workflow-columns.ts

@@ -205,11 +205,9 @@ export function buildPendingRuns(
  *  the inline runner, and the cancel key the inline backend uses to map a
  *  Stop click to the in-flight cell's AbortController.
  *
- *  The `runner` is only consumed by the database (inline) backend — the
- *  trigger.dev backend triggers by task id. Importing the cell job pulls in
- *  the entire executor + blocks stack, so on trigger.dev we skip the import
- *  entirely: the dispatcher container would otherwise pay a multi-second
- *  cold-start loading code it never runs (the cell runs in its own container). */
+ *  `runner` is only used by the database backend; trigger.dev triggers by task
+ *  id. The cell-job import pulls in the executor + blocks stack, so skip it on
+ *  trigger.dev to avoid a multi-second dispatcher cold-start. */
 export async function buildEnqueueItems(
   pendingRuns: WorkflowGroupCellPayload[]
 ): Promise<Array<{ payload: WorkflowGroupCellPayload; options: EnqueueOptions }>> {