1. single client failed to connect with single large image.
2. client eventually connected initially under uid+c.
3. server had no errors and no auth block for standard uid.
4. server/client event logs malformed. init event replaced with image:

• client: init e[0]: time, value, id, init:false
• server: init e[0] same as client, also init e[1]: time, id, init:false

session otherwise receives fetch until:

• successive push log to master has no event.indexOf

general issues

• reconnect
• purge
• pull_hard: new peer auth prior peers: events prior to connect HEAD (unless blocked)
• revlist: timestamp, prune, auths, timeout intervals
• client onload race condition where sm undefined

server should order by timestamp event commits:

• asynchronous
• head timestamp minus n deviations of fetch interval

honor that client may prune revlist

• flat, sort timestamp ASC
• remove duplicates

• server master log does not replace image with tiny thumbnail, but only stores a link id. This is good... but the function should return the base64, not null, when required (async/await or function parameter reference lost). 9374536
• file extension honors type cb060aa
• improve compression technique: c28aa5a

sm.img = function( img, token, opts={} ){
  let pass = opts.pass || (1/2);

  // initially resize image/canvas to max dimension
  // canvas.width, canvas.height, ctx.drawImage

  let file, inc = 0.1;
  let types = opts.type ? [opts.type] : [ "image/jpeg", "image/png", "image/webp" ];
  for( let i=0; i<types.length; i++ ){
    let type = types[i];
    for( let j=1; j>=0; j-=inc ){
      // increment (dimension/quality) until within max filesize
      // canvas.width, canvas.height, ctx.drawImage
      let thumb = canvas.toDataURL(type, j);
      if( thumb.length <= 19_200 ){
        // use additional iteration if > 25% reduction
        let thumberer = canvas.toDataURL(type, j-inc);
        thumb = (thumberer.length/thumb.length<0.75) ? thumberer : thumb;
        // return smallest filesize of filetypes
        file = (thumb.length<file.length) ? thumb : file;
        break;
      }
    }
  }
 
}

• #9

// server fetch or interval
if( !image.archive && ( uid.blocked || (time - image.time) >= 60_000*15 ) ){
  sm.img( image, image.id, { archive:true, serve:image } )
}

// prioritize degrade of archive, non-cumulative
if( opts.archive ){
  pass *= (1/2);
  opts.serve.archive = true;
}

Client onbeforeunload (despite partial browser support) used to consistently block the uid. Several feature updates have affected this, unless the condition was preexisting and went unnoticed. Is inconsistent behavior of auth uid block due to server state(s)... parallel instance, sleep, or...?

Auth was expanded from a generic uid array to an object. This allowed a connect handshake, queue, and pull_hard for events prior to connect event timestamp. Blocked uid is no longer assured, thanks to this change among others (code refactor, reconnect, multi-part, pull_hard).

Possibly related to maximum URL parameter length or timestamp.
It could be a quirk of the language compile engine, such as named functions are eagerly evaluated.

fatal

• server exceptions to own uid as client
• queue: host crashes if client in queue and unloads + (host connect as client)
• user (without events?) is blocked on timeout and reconnects. mutated uid key mismanaged in master log lookup.

non-fatal

• revlist: duplicate event send... (several images) for clients who connect later

feature

• fetch Promise.all: avoid missed sends in excess of limit
• exposing code to client publicly

limit duplicate or unnecessary fetch data, with respect to code bloat:

• client multi-part (user info)
• server with no update (empty peers)

• pull_hard should include denied uid OR log events should be pruned?
• reduce quality of archived images

// server fetch or interval
if( !image.archive && ( uid.blocked || (time - image.time) >= 60_000*15 ) ){
  sm.img( image, image.id, { archive:true, serve:image } )
}

// prioritize degrade of archive, non-cumulative
if( opts.archive ){
  pass *= (1/2);
  opts.serve.archive = true;
}