Function materializeLargeValueRef

apps/sim/lib/execution/payloads/store.ts:204–274

(
  ref: LargeValueRef,
  context?: LargeValueStoreContext
)

}

export async function materializeLargeValueRef(
  ref: LargeValueRef,
  context?: LargeValueStoreContext
): Promise<unknown> {
  if (!context?.executionId) {
    return undefined
  }

  assertLargeValueRefAccess(ref, context)
  assertInlineMaterializationSize(ref.size, context.maxBytes)

  if (!ref.key || !isValidLargeValueKey(ref)) {
    return materializeLargeValueRefSync(ref, context)
  }

  if (context.trackReference !== false) {
    const { addLargeValueReference } = await import('@/lib/execution/payloads/large-value-metadata')
    // Reference tracking is GC-critical: if it fails, fail the read rather than
    // return a value whose reference was never recorded (it could later be
    // garbage-collected out from under a live consumer). Read-only consumers
    // that don't need a reference set trackReference: false to skip this.
    await addLargeValueReference(
      {
        workspaceId: context.workspaceId,
        workflowId: context.workflowId,
        executionId: context.executionId,
        source: 'execution_log',
      },
      ref.key
    )
  }

  try {
    const cached = materializeLargeValueRefSync(ref, context)
    if (cached !== undefined) {
      return cached
    }

    const value = await readLargeValueRefFromStorage(ref, {
      workspaceId: context.workspaceId,
      workflowId: context.workflowId,
      executionId: context.executionId,
      largeValueExecutionIds: context.largeValueExecutionIds,
      largeValueKeys: context.largeValueKeys,
      allowLargeValueWorkflowScope: context.allowLargeValueWorkflowScope,
      userId: context.userId,
      maxBytes: context.maxBytes ?? ref.size,
    })
    if (value === undefined) {
      return undefined
    }
    cacheLargeValue(
      ref.id,
      value,
      ref.size,
      {
        ...context,
        executionId: ref.executionId ?? context.executionId,