Having said that, I must admit that it took me a good day or so to actually wrap my head around what's actually going on here. I'm still not sure if I'm doing things oddly, but I thought I'd share the function call descriptor generator that I find most natural:

Function.prototype.result = function() { 
    var self=this; 
    var wrapper = function(func_args, cb) { 
        func_args = Array.prototype.slice.call(func_args); 
        func_args = func_args.slice(); 
        func_args.push(cb); 
        async(self).apply(this, func_args); 
    } 
    return [wrapper, arguments]; 
}

this allows me to just have all my functions be regular (non-async-aware) functions that expect one more argument than they're called with (the callback argument). Sample usage:

function add_one(arg, cb) { 
    cb(arg + 1); 
} 
 
function main() { 
    alert("1 + 1 = " + (yield add_one.result(1))); 
} 
 
async(main)();

The to function-call-description generator does feel less awkward to write with, but it seems to require functions be available in the global scope, which wouldn't work for me. And this way, I don't have to write wrapper functions for everything that just uses a callback without being async-aware. it also wrapps everything in as async() call as it goes, so that it should correctly deal with a yield wherever in the stack it occurs.