fix(copilot): report dispatch from the block handler itself

I claimed last round that nothing could precede the signal. That was
wrong: `executeNode` returns early on a cache hit, initializes loop and
parallel scopes, and handles a sentinel that never reaches a handler — all
after the point it fired. Both reviewers found the same thing.

Move it to the line before `blockExecutor.execute`, which is the handler
call. Nothing separates the two, so unlike every previous position this
one cannot have something in front of it. Fired per block rather than
once, since observers record a boolean and repeats cost nothing.

Also accept functions as carriers of the run markers. They key a WeakMap
exactly as objects do, so excluding them dropped the record for a thrown
function and lost the distinction the markers exist to make.

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

Author: icecrasher321

apps/sim/executor/execution/engine.ts

@@ -38,7 +38,6 @@ export class ExecutionEngine {
   private cancellationController = new AbortController()
   private abortSignalListener: (() => void) | null = null
   private cancellationUnsubscribe: (() => void) | null = null
-  private reportedBlocksMayRun = false
   private execLogger: Logger
 
   constructor(
@@ -63,13 +62,6 @@ export class ExecutionEngine {
     this.initializeAbortHandler()
   }
 
-  /** Fires the caller's dispatch observer exactly once, however many nodes follow. */
-  private reportBlocksMayRun(): void {
-    if (this.reportedBlocksMayRun) return
-    this.reportedBlocksMayRun = true
-    this.context.onBlocksMayRun?.()
-  }
-
   private async subscribeToCancellationSignal(): Promise<void> {
     if (!this.context.executionId) return
     const executionId = this.context.executionId
@@ -429,14 +421,6 @@ export class ExecutionEngine {
   private async executeNodeAsync(nodeId: string): Promise<void> {
     try {
       const wasAlreadyExecuted = this.context.executedBlocks.has(nodeId)
-      /**
-       * The single moment a side effect becomes possible: the last statement before a block
-       * handler runs. Every earlier candidate was a proxy that a reviewer could then find a
-       * fallible step in front of — startup, the cancellation subscription, queue and
-       * subflow initialization all reject having run nothing. There is nothing between here
-       * and the handler, so there is nothing left to be in front of.
-       */
-      this.reportBlocksMayRun()
       const result = await this.nodeOrchestrator.executeNode(this.context, nodeId)
 
       if (!wasAlreadyExecuted) {

apps/sim/executor/orchestrators/node.ts

@@ -95,6 +95,16 @@ export class NodeExecutionOrchestrator {
       }
     }
 
+    /**
+     * The block handler, and therefore the first moment a side effect is possible. Every
+     * earlier position was a proxy with something in front of it — engine startup, the
+     * cancellation subscription, queue setup, and above this line a cache hit, loop and
+     * parallel scope initialization, and a sentinel that returns without reaching a handler.
+     * Nothing separates this call from the handler, so nothing can precede it.
+     *
+     * Fired per block rather than once; observers record a boolean, so repeats are free.
+     */
+    ctx.onBlocksMayRun?.()
     const output = await this.blockExecutor.execute(ctx, node, node.block)
     const isFinalOutput = node.outgoingEdges.size === 0
     return {

apps/sim/executor/utils/errors.ts

@@ -102,7 +102,8 @@ export function readAttemptedExecutionId(error: unknown): string | undefined {
  * costs nothing today because every throw site past the dispatch boundary raises an `Error`.
  */
 function isRecordedThrown(value: unknown): value is object {
-  return typeof value === 'object' && value !== null
+  /** Functions key a WeakMap as well as objects do, so excluding them would drop the record. */
+  return (typeof value === 'object' || typeof value === 'function') && value !== null
 }
 
 export interface BlockExecutionErrorDetails {