remove hotpath serialiazation

Author: icecrasher321

apps/sim/executor/orchestrators/loop.test.ts

@@ -37,10 +37,10 @@ function createContext(scope: Record<string, unknown>): ExecutionContext {
   } as ExecutionContext
 }
 
-function createOrchestrator() {
+function createOrchestrator(loopConfigs = new Map<string, any>()) {
   const setBlockOutput = vi.fn()
   const orchestrator = new LoopOrchestrator(
-    { loopConfigs: new Map(), parallelConfigs: new Map(), nodes: new Map() } as any,
+    { loopConfigs, parallelConfigs: new Map(), nodes: new Map() } as any,
     { setBlockOutput, unmarkExecuted: vi.fn() } as any,
     { resolveSingleReference: vi.fn() } as any
   )
@@ -75,6 +75,28 @@ describe('LoopOrchestrator', () => {
     })
   })
 
+  it('does not treat doWhile iterations of zero as an immediate configured cap', async () => {
+    const { orchestrator } = createOrchestrator(
+      new Map([
+        [
+          'loop-1',
+          {
+            loopType: 'doWhile',
+            iterations: 0,
+            doWhileCondition: 'true',
+            nodes: ['block-1'],
+          },
+        ],
+      ])
+    )
+    const ctx = createContext({})
+
+    const scope = await orchestrator.initializeLoopScope(ctx, 'loop-1')
+
+    expect(scope.maxIterations).toBeUndefined()
+    expect(scope.condition).toBe('true')
+  })
+
   it('compacts current iteration outputs before retaining them', async () => {
     const { orchestrator, setBlockOutput } = createOrchestrator()
     const ctx = createContext({

apps/sim/executor/orchestrators/loop.ts

@@ -163,7 +163,7 @@ export class LoopOrchestrator {
 
       case 'doWhile': {
         scope.loopType = 'doWhile'
-        if (loopConfig.iterations !== undefined) {
+        if (loopConfig.iterations) {
           scope.maxIterations = loopConfig.iterations
         }
         if (loopConfig.doWhileCondition) {

apps/sim/lib/execution/payloads/large-array-manifest-metadata.ts

@@ -29,22 +29,8 @@ function isValidByteSize(value: unknown): value is number {
   return typeof value === 'number' && Number.isFinite(value) && value >= 0
 }
 
-function measureJsonSize(value: unknown): number | undefined {
-  try {
-    const json = JSON.stringify(value)
-    return json === undefined ? undefined : new TextEncoder().encode(json).length
-  } catch {
-    return undefined
-  }
-}
-
 function isValidPreview(value: unknown): value is unknown[] {
-  if (!Array.isArray(value) || value.length > 3) {
-    return false
-  }
-
-  const size = measureJsonSize(value)
-  return size !== undefined && size <= LARGE_ARRAY_MANIFEST_PREVIEW_MAX_BYTES
+  return Array.isArray(value) && value.length <= 3
 }
 
 export function isLargeArrayManifest(value: unknown): value is LargeArrayManifest {

apps/sim/lib/execution/payloads/large-array-manifest.test.ts

@@ -167,14 +167,17 @@ describe('large array manifests', () => {
     )
   })
 
-  it('rejects manifests with oversized preview metadata', async () => {
+  it('does not serialize preview metadata during hot type-guard checks', async () => {
     const manifest = await createLargeArrayManifest([{ id: 1 }], TEST_CONTEXT)
+    const stringifySpy = vi.spyOn(JSON, 'stringify')
 
     expect(
       isLargeArrayManifest({
         ...manifest,
         preview: [{ payload: 'x'.repeat(20 * 1024) }],
       })
-    ).toBe(false)
+    ).toBe(true)
+    expect(stringifySpy).not.toHaveBeenCalled()
+    stringifySpy.mockRestore()
   })
 })

apps/sim/lib/execution/payloads/serializer.test.ts

@@ -11,7 +11,7 @@ import {
   getLargeValueMaterializationError,
   isLargeValueRef,
 } from '@/lib/execution/payloads/large-value-ref'
-import { compactExecutionPayload } from '@/lib/execution/payloads/serializer'
+import { compactExecutionPayload, compactSubflowResults } from '@/lib/execution/payloads/serializer'
 import type { UserFile } from '@/executor/types'
 
 const TEST_EXECUTION_CONTEXT = {
@@ -150,6 +150,77 @@ describe('compactExecutionPayload', () => {
     expect(isLargeValueRef(compacted)).toBe(true)
   })
 
+  it('bounds oversized manifest preview metadata during compaction', async () => {
+    const forgedManifest = {
+      __simLargeArrayManifest: true,
+      version: LARGE_ARRAY_MANIFEST_VERSION,
+      kind: 'array',
+      totalCount: 1,
+      chunkCount: 1,
+      byteSize: 1,
+      chunks: [
+        {
+          ref: {
+            __simLargeValueRef: true,
+            version: 1,
+            id: 'lv_ABCDEFGHIJKL',
+            kind: 'array',
+            size: 1,
+            executionId: TEST_EXECUTION_CONTEXT.executionId,
+          },
+          count: 1,
+          byteSize: 1,
+        },
+      ],
+      preview: [{ payload: 'x'.repeat(20 * 1024) }],
+    }
+
+    expect(isLargeArrayManifest(forgedManifest)).toBe(true)
+
+    const compacted = await compactExecutionPayload(forgedManifest, {
+      thresholdBytes: 128,
+      preserveRoot: true,
+      ...TEST_EXECUTION_CONTEXT,
+    })
+
+    expect(isLargeValueRef(compacted)).toBe(true)
+  })
+
+  it('does not re-wrap manifests when forcing oversized subflow result entries', async () => {
+    const manifest = {
+      __simLargeArrayManifest: true,
+      version: LARGE_ARRAY_MANIFEST_VERSION,
+      kind: 'array',
+      totalCount: 1,
+      chunkCount: 1,
+      byteSize: 1,
+      chunks: [
+        {
+          ref: {
+            __simLargeValueRef: true,
+            version: 1,
+            id: 'lv_ABCDEFGHIJKL',
+            kind: 'array',
+            size: 1,
+            executionId: TEST_EXECUTION_CONTEXT.executionId,
+          },
+          count: 1,
+          byteSize: 1,
+        },
+      ],
+      preview: [],
+    }
+    const thresholdBytes = Buffer.byteLength(JSON.stringify(manifest), 'utf8') + 8
+
+    const compacted = await compactSubflowResults([manifest, manifest], {
+      thresholdBytes,
+      ...TEST_EXECUTION_CONTEXT,
+    })
+
+    expect(compacted).toEqual([manifest, manifest])
+    expect(compacted.every(isLargeArrayManifest)).toBe(true)
+  })
+
   it('rejects durable compaction when storage context is incomplete', async () => {
     await expect(
       compactExecutionPayload(

apps/sim/lib/execution/payloads/serializer.ts

@@ -114,7 +114,7 @@ async function forceStoreValue(
   value: unknown,
   options: CompactExecutionPayloadOptions
 ): Promise<unknown> {
-  if (isLargeValueRef(value)) {
+  if (isLargeValueRef(value) || isLargeArrayManifest(value)) {
     return value
   }
   const measured = getJsonAndSize(value)