macro ccall proc,[arg]
{
common
       local   ..next
      push    edi
 mov     edi, esp
    ccall   proc,arg
    cmp     edi, esp
    jz      ..next
      int3
..next:
 pop     edi
}

macro stdcall proc, [arg]
{
common
  local   ..next
      push    edi
 mov     edi, esp
    stdcall proc,arg
    cmp     edi, esp
    jz      ..next
      int3
..next:
 pop     edi
}

macro cinvoke proc,[arg]
{
common
   ccall   [proc], arg
}

macro invoke proc, [arg]
{
common
   stdcall [proc], arg
}
    

it would be not bad to make this safe int3 inserting conditional, depending on presence of DEBUG_VERSION or so

match any,DEBUG_ME {include 'my_safe_calls.inc'}    

If function returns, it's too late to check for stack balance (it supposedly ret using address put on stack with call, at least for common case)

*I'm assuming here that stack imbalance is the only violation expected, EDI preservation is assumed.

macro ccall proc,[arg]
{
common
        local   ..next,..ohshit
        push    edi esi ebx ebp
        mov     edi, esp
        mov     esi, esp
        mov     ebx, esp
        mov     ebp, esp
        not     ebx
        not     ebp
        ccall   proc,arg
        not     ebx
        not     ebp
        cmp     edi, esp
        jnz     ..ohshit
        cmp     esi, esp
        jnz     ..ohshit
        cmp     ebx, esp
        jnz     ..ohshit
        cmp     ebp, esp
        jz      ..next
..ohshit:
        int3
..next:
        pop     ebp ebx esi edi
}    

If you can't even assume that it will at least respect register preservation then I think that using a global variable to store ESP would be better.

Globals are a killer for multi-threading. Just say no to globals.