remove build files, harden edge cases

Author: icecrasher321

apps/sim/executor/handlers/variables/variables-handler.test.ts

@@ -81,6 +81,67 @@ describe('VariablesBlockHandler', () => {
     expect(mockUploadFile).not.toHaveBeenCalled()
   })
 
+  it('includes unmatched assignments in block output without mutating workflow variables', async () => {
+    const handler = new VariablesBlockHandler()
+    const ctx = createContext()
+    const value = [{ key: 'SIM-1', summary: 'Transient issue' }]
+
+    const output = await handler.execute(ctx, createBlock(), {
+      variables: [
+        {
+          variableName: 'transientIssues',
+          type: 'array',
+          value,
+        },
+      ],
+    })
+
+    expect(ctx.workflowVariables).not.toHaveProperty('transientIssues')
+    expect(output).toEqual({ transientIssues: value })
+  })
+
+  it('keeps special unmatched assignment names as own output fields', async () => {
+    const handler = new VariablesBlockHandler()
+    const ctx = createContext()
+    const value = { polluted: true }
+
+    const output = await handler.execute(ctx, createBlock(), {
+      variables: [
+        {
+          variableName: '__proto__',
+          type: 'object',
+          value,
+        },
+      ],
+    })
+
+    expect(Object.hasOwn(output, '__proto__')).toBe(true)
+    expect(output.__proto__).toEqual(value)
+    expect(Object.getPrototypeOf(output)).toBe(Object.prototype)
+  })
+
+  it('does not treat inherited prototype keys as existing workflow variable IDs', async () => {
+    const handler = new VariablesBlockHandler()
+    const ctx = createContext()
+    const value = { safe: true }
+    const originalPrototype = Object.getPrototypeOf(ctx.workflowVariables)
+
+    const output = await handler.execute(ctx, createBlock(), {
+      variables: [
+        {
+          variableId: '__proto__',
+          variableName: 'prototypeAssignment',
+          type: 'object',
+          value,
+        },
+      ],
+    })
+
+    expect(Object.getPrototypeOf(ctx.workflowVariables)).toBe(originalPrototype)
+    expect(ctx.workflowVariables).not.toHaveProperty('__proto__')
+    expect(output).toEqual({ prototypeAssignment: value })
+  })
+
   it('stores oversized array assignments as durable manifests in variables and block output', async () => {
     const handler = new VariablesBlockHandler()
     const ctx = createContext()

apps/sim/executor/handlers/variables/variables-handler.ts

@@ -9,6 +9,38 @@ import type { SerializedBlock } from '@/serializer/types'
 
 const logger = createLogger('VariablesBlockHandler')
 
+function setOutputValue(output: Record<string, any>, key: string, value: any): void {
+  Object.defineProperty(output, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  })
+}
+
+function getWorkflowVariableEntry(
+  workflowVariables: Record<string, any>,
+  variableId: string | undefined
+): [string, any] | undefined {
+  if (!variableId || !Object.hasOwn(workflowVariables, variableId)) {
+    return undefined
+  }
+  return [variableId, workflowVariables[variableId]]
+}
+
+function setWorkflowVariableEntry(
+  workflowVariables: Record<string, any>,
+  id: string,
+  value: any
+): void {
+  Object.defineProperty(workflowVariables, id, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  })
+}
+
 export class VariablesBlockHandler implements BlockHandler {
   canHandle(block: SerializedBlock): boolean {
     const canHandle = block.metadata?.id === BlockType.VARIABLES
@@ -30,23 +62,21 @@ export class VariablesBlockHandler implements BlockHandler {
       const output: Record<string, any> = {}
 
       for (const assignment of assignments) {
-        const existingEntry = assignment.variableId
-          ? [assignment.variableId, ctx.workflowVariables[assignment.variableId]]
-          : Object.entries(ctx.workflowVariables).find(
-              ([_, v]) => v.name === assignment.variableName
-            )
+        const existingEntry =
+          getWorkflowVariableEntry(ctx.workflowVariables, assignment.variableId) ??
+          Object.entries(ctx.workflowVariables).find(([_, v]) => v.name === assignment.variableName)
         const value = await this.compactAssignmentValue(ctx, assignment.value)
 
         if (existingEntry?.[1]) {
           const [id, variable] = existingEntry
-          ctx.workflowVariables[id] = {
+          setWorkflowVariableEntry(ctx.workflowVariables, id, {
             ...variable,
             value,
-          }
-          output[assignment.variableName] = value
+          })
         } else {
           logger.warn(`Variable "${assignment.variableName}" not found in workflow variables`)
         }
+        setOutputValue(output, assignment.variableName, value)
       }
 
       return output

apps/sim/executor/orchestrators/loop.ts

@@ -22,8 +22,8 @@ import {
   emitEmptySubflowEvents,
   emitSubflowSuccessEvents,
   extractBaseBlockId,
-  resolveArrayInputAsync,
 } from '@/executor/utils/subflow-utils'
+import { resolveArrayInputAsync } from '@/executor/utils/subflow-utils.server'
 import type { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedLoop } from '@/serializer/types'
 

apps/sim/executor/orchestrators/parallel.ts

@@ -13,8 +13,8 @@ import {
   emitEmptySubflowEvents,
   emitSubflowSuccessEvents,
   extractBranchIndex,
-  resolveArrayInputAsync,
 } from '@/executor/utils/subflow-utils'
+import { resolveArrayInputAsync } from '@/executor/utils/subflow-utils.server'
 import type { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedParallel } from '@/serializer/types'
 

apps/sim/executor/utils/output-filter.test.ts

@@ -0,0 +1,42 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
+import { filterOutputForLog } from '@/executor/utils/output-filter'
+
+vi.mock('@/blocks', () => ({
+  getBlock: () => undefined,
+}))
+
+describe('output filtering', () => {
+  it('preserves special top-level output keys as own fields', () => {
+    const rawOutput: Record<string, unknown> = {}
+    Object.defineProperty(rawOutput, 'constructor', {
+      value: { safe: true },
+      enumerable: true,
+    })
+
+    const output = filterOutputForLog('', rawOutput)
+
+    expect(Object.hasOwn(output, 'constructor')).toBe(true)
+    expect(output.constructor).toEqual({ safe: true })
+    expect(Object.getPrototypeOf(output)).toBe(Object.prototype)
+  })
+
+  it('preserves special nested output keys as own fields', () => {
+    const nested: Record<string, unknown> = {}
+    Object.defineProperty(nested, '__proto__', {
+      value: { safe: true },
+      enumerable: true,
+    })
+
+    const filtered = filterHiddenOutputKeys({
+      nested,
+    }) as { nested: Record<string, unknown> }
+
+    expect(Object.hasOwn(filtered.nested, '__proto__')).toBe(true)
+    expect(filtered.nested.__proto__).toEqual({ safe: true })
+    expect(Object.getPrototypeOf(filtered.nested)).toBe(Object.prototype)
+  })
+})

apps/sim/executor/utils/output-filter.ts

@@ -6,6 +6,19 @@ import { isTriggerBehavior, isTriggerInternalKey } from '@/executor/constants'
 import type { NormalizedBlockOutput } from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 
+function setFilteredOutputValue(
+  output: Record<string, unknown>,
+  key: string,
+  value: unknown
+): void {
+  Object.defineProperty(output, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true,
+  })
+}
+
 /**
  * Filters block output for logging/display purposes.
  * Removes internal fields and fields marked with hiddenFromDisplay.
@@ -54,7 +67,7 @@ export function filterOutputForLog(
     }
 
     // Recursively filter globally hidden keys from nested objects
-    filtered[key] = filterHiddenOutputKeys(value)
+    setFilteredOutputValue(filtered, key, filterHiddenOutputKeys(value))
   }
 
   return filtered

apps/sim/executor/utils/subflow-utils.server.ts

@@ -0,0 +1,118 @@
+import { toError } from '@sim/utils/errors'
+import {
+  isLargeArrayManifest,
+  LARGE_ARRAY_MANIFEST_MARKER,
+  materializeLargeArrayManifest,
+} from '@/lib/execution/payloads/large-array-manifest'
+import { isLargeValueRef, LARGE_VALUE_REF_MARKER } from '@/lib/execution/payloads/large-value-ref'
+import { MAX_DURABLE_LARGE_VALUE_BYTES } from '@/lib/execution/payloads/materialization.server'
+import { materializeLargeValueRef } from '@/lib/execution/payloads/store'
+import { REFERENCE } from '@/executor/constants'
+import type { ExecutionContext } from '@/executor/types'
+import type { VariableResolver } from '@/executor/variables/resolver'
+
+async function normalizeCollectionValue(ctx: ExecutionContext, value: unknown): Promise<any[]> {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  if (isLargeArrayManifest(value)) {
+    return materializeLargeArrayManifest(value, {
+      workspaceId: ctx.workspaceId,
+      workflowId: ctx.workflowId,
+      executionId: ctx.executionId,
+      largeValueExecutionIds: ctx.largeValueExecutionIds,
+      allowLargeValueWorkflowScope: ctx.allowLargeValueWorkflowScope,
+      userId: ctx.userId,
+      maxBytes: MAX_DURABLE_LARGE_VALUE_BYTES,
+    })
+  }
+
+  if (isLargeValueRef(value)) {
+    const materialized = await materializeLargeValueRef(value, {
+      workspaceId: ctx.workspaceId,
+      workflowId: ctx.workflowId,
+      executionId: ctx.executionId,
+      largeValueExecutionIds: ctx.largeValueExecutionIds,
+      allowLargeValueWorkflowScope: ctx.allowLargeValueWorkflowScope,
+      userId: ctx.userId,
+      maxBytes: MAX_DURABLE_LARGE_VALUE_BYTES,
+    })
+    if (materialized === undefined) {
+      throw new Error('Large execution value is unavailable.')
+    }
+    return normalizeCollectionValue(ctx, materialized)
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    if ((value as Record<string, unknown>)[LARGE_ARRAY_MANIFEST_MARKER] === true) {
+      throw new Error('Invalid large array manifest.')
+    }
+    if ((value as Record<string, unknown>)[LARGE_VALUE_REF_MARKER] === true) {
+      throw new Error('Invalid large value ref.')
+    }
+    return Object.entries(value)
+  }
+
+  if (value === null) {
+    return []
+  }
+
+  throw new Error('Value did not resolve to an array or object')
+}
+
+/**
+ * Resolves loop/parallel collection inputs on the server, including durable
+ * execution values that cannot be imported into client-reachable utilities.
+ */
+export async function resolveArrayInputAsync(
+  ctx: ExecutionContext,
+  items: any,
+  resolver: VariableResolver | null
+): Promise<any[]> {
+  if (typeof items !== 'string') {
+    if (items === null) {
+      return []
+    }
+    if (!Array.isArray(items) && typeof items !== 'object') {
+      if (!resolver) {
+        return []
+      }
+      try {
+        const resolved = (await resolver.resolveInputs(ctx, 'subflow_items', { items })).items
+        return normalizeCollectionValue(ctx, resolved)
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith('Resolved items')) {
+          throw error
+        }
+        throw new Error(`Failed to resolve items: ${toError(error).message}`)
+      }
+    }
+    return normalizeCollectionValue(ctx, items)
+  }
+
+  if (items.startsWith(REFERENCE.START) && items.endsWith(REFERENCE.END) && resolver) {
+    try {
+      const resolved = await resolver.resolveSingleReference(ctx, '', items, undefined, {
+        allowLargeValueRefs: true,
+      })
+      return normalizeCollectionValue(ctx, resolved)
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('Reference "')) {
+        throw error
+      }
+      throw new Error(`Failed to resolve reference "${items}": ${toError(error).message}`)
+    }
+  }
+
+  try {
+    const normalized = items.replace(/'/g, '"')
+    const parsed = JSON.parse(normalized)
+    return normalizeCollectionValue(ctx, parsed)
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('Parsed value')) {
+      throw error
+    }
+    throw new Error(`Failed to parse items as JSON: "${items}"`)
+  }
+}