code: function (buf, cb) {
        //write to the end of the file.
        //if successful, copy into cache.
        if(writing++) throw new Error('already appending to this file')
        file.offset.once(function (_offset) {
  
          var start = _offset
          var b_start = 0
          var i = Math.floor(start/block_size)
          if(i*block_size < _offset) //usually true, unless file length is multiple of block_size
            get(i, function (err) { //this will add the last block to the cache.
              if(err) cb(explain(err, 'precache before append failed'))
              else next()
            })
          else next()
  
          function next () {
            while(b_start < buf.length) { //start < _offset+buf.length) {
              var block_start = i*block_size
              var b = cache.get(i)
              if(null == b) {
                b = Buffer.alloc(block_size)
                cache.set(i, b)
              }
              //including if set in above if...
              if(Buffer.isBuffer(b)) {
                  var len = Math.min(block_size - (start - block_start), block_size)
                  buf.copy(b, start - block_start, b_start, b_start + len)
                  start += len
                  b_start += len
              }
              else if(Array.isArray(cbs[i]))
                throw new Error('should never happen: new block should be initialized, before a read ever happens')
              else {
                start += block_size
              }
  
              i++
            }
  
            file.append(buf, function (err, offset) {
              if(err) return cb(err)
              writing = 0
              cb(null, offset)
            })
          }
        })
      }
docs: starting to realize: what I really need is just a lib for relative copies between two arrays of buffers, with a given offset.