chore: import upstream snapshot with attribution

apps/sim/lib/execution/payloads/large-execution-value.ts

@@ -0,0 +1,130 @@
+import {
+  isLargeArrayManifest,
+  type LargeArrayManifest,
+} from '@/lib/execution/payloads/large-array-manifest-metadata'
+import { isLargeValueRef, type LargeValueRef } from '@/lib/execution/payloads/large-value-ref'
+
+export type LargeExecutionValue = LargeValueRef | LargeArrayManifest
+
+/**
+ * Parses execution values that must survive type coercion as refs.
+ */
+export function parseLargeExecutionValue(value: unknown): LargeExecutionValue | undefined {
+  if (isLargeValueRef(value) || isLargeArrayManifest(value)) {
+    return value
+  }
+
+  if (typeof value !== 'string' || !value.trim()) {
+    return undefined
+  }
+
+  try {
+    const parsed = JSON.parse(value)
+    return isLargeValueRef(parsed) || isLargeArrayManifest(parsed) ? parsed : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Finds execution IDs referenced by large values embedded in persisted execution state.
+ */
+export function collectLargeValueExecutionIds(value: unknown): string[] {
+  const executionIds = new Set<string>()
+  collectLargeValueExecutionIdsInto(value, executionIds, new WeakSet<object>())
+  return Array.from(executionIds)
+}
+
+export function collectLargeValueKeys(value: unknown): string[] {
+  const keys = new Set<string>()
+  collectLargeValueKeysInto(value, keys, new WeakSet<object>())
+  return Array.from(keys)
+}
+
+function collectLargeValueExecutionIdsInto(
+  value: unknown,
+  executionIds: Set<string>,
+  seen: WeakSet<object>
+): void {
+  if (!value || typeof value !== 'object') {
+    return
+  }
+
+  if (seen.has(value)) {
+    return
+  }
+  seen.add(value)
+
+  if (isLargeValueRef(value)) {
+    addExecutionId(value, executionIds)
+    collectLargeValueExecutionIdsInto(value.preview, executionIds, seen)
+    return
+  }
+
+  if (isLargeArrayManifest(value)) {
+    for (const chunk of value.chunks) {
+      addExecutionId(chunk.ref, executionIds)
+    }
+    collectLargeValueExecutionIdsInto(value.preview, executionIds, seen)
+    return
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectLargeValueExecutionIdsInto(item, executionIds, seen)
+    }
+    return
+  }
+
+  for (const item of Object.values(value)) {
+    collectLargeValueExecutionIdsInto(item, executionIds, seen)
+  }
+}
+
+function addExecutionId(ref: LargeValueRef, executionIds: Set<string>): void {
+  if (ref.executionId) {
+    executionIds.add(ref.executionId)
+  }
+}
+
+function collectLargeValueKeysInto(value: unknown, keys: Set<string>, seen: WeakSet<object>): void {
+  if (!value || typeof value !== 'object') {
+    return
+  }
+
+  if (seen.has(value)) {
+    return
+  }
+  seen.add(value)
+
+  if (isLargeValueRef(value)) {
+    addKey(value, keys)
+    collectLargeValueKeysInto(value.preview, keys, seen)
+    return
+  }
+
+  if (isLargeArrayManifest(value)) {
+    for (const chunk of value.chunks) {
+      addKey(chunk.ref, keys)
+    }
+    collectLargeValueKeysInto(value.preview, keys, seen)
+    return
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectLargeValueKeysInto(item, keys, seen)
+    }
+    return
+  }
+
+  for (const item of Object.values(value)) {
+    collectLargeValueKeysInto(item, keys, seen)
+  }
+}
+
+function addKey(ref: LargeValueRef, keys: Set<string>): void {
+  if (ref.key) {
+    keys.add(ref.key)
+  }
+}