u8-mqtt 0.5.2 → 0.6.0

package/cjs/basic-v5.cjs

@@ -163,10 +163,18 @@ let mqtt_reader_v5$1 = class mqtt_reader_v5 extends mqtt_reader_v4 {
 
     let res={}, fork = this.of(buf.subarray(vi, step.k|0));
     while (fork.has_more()) {
-      let pt = mqtt_props.get( fork.u8() )
-        , value = fork[pt.type]();
-      res[pt.name] = ! pt.op ? value
-        : fork[pt.op](res[pt.name], value);
+      let v, pk = fork.u8(), pt = mqtt_props.get( pk );
+
+      if (!pt) {
+        res.error = `Unknown mqtt_prop enum ${pk}`;
+        return res
+      }
+
+      v = fork[pt.type]();
+      if (pt.op) // accumulate operation
+        v = fork[pt.op](res[pt.name], v);
+
+      res[pt.name] = v;
     }
     return res
   }
@@ -300,6 +308,8 @@ class mqtt_writer_v5 extends mqtt_writer_v4 {
     let fork = this.of();
     for (let [name, value] of props) {
       let pt = mqtt_props.get(name);
+      if (!pt)
+        throw new Error(`Unknown mqtt_prop "${name}"`)
       fork[pt.op || 'one'](value, pt);
     }
     this.push(fork.pack());
@@ -862,6 +872,9 @@ function mqtt_pkt_ctx(mqtt_level, opts, pkt_ctx) {
       return _encode_by_type[type]( mqtt_level, pkt ) },
 
     decode_pkt(b0, u8_body) {
+      if (b0.map) // Uint8Array in first arg
+        return mqtt_raw_dispatch(this)(b0)[0]
+
       let fn_decode = _decode_by_id[b0>>>4] || _decode_by_id[0];
       return fn_decode?.({__proto__: this.pkt_ctx, b0}, u8_body) },
 
@@ -874,88 +887,15 @@ function mqtt_pkt_ctx(mqtt_level, opts, pkt_ctx) {
   }
 }
 
-function ao_defer_ctx(as_res = (...args) => args) {
-  let y,n,_pset = (a,b) => { y=a, n=b; };
-  return p =>(
-    p = new Promise(_pset)
-  , as_res(p, y, n)) }
-
-const ao_defer_v = /* #__PURE__ */
-  ao_defer_ctx();
-
-Promise.resolve({type:'init'});
-
-function _mqtt_conn(client, [on_mqtt, pkt_future]) {
-  let _q_init = ao_defer_v(), _q_ready = ao_defer_v();
-  let _send_ready = async (...args) => (await _q_ready[0])(...args);
-  let _send_mqtt_pkt, _has_connected;
-  client._send = _send_ready;
-
-  return {
-    async when_ready() {await _q_ready[0];}
-
-  , ping: _ping_interval (() =>_send_mqtt_pkt?.('pingreq'))
-
-  , reset(err) {
-      if (! _send_mqtt_pkt) {return}
-
-      if (err) {
-        _q_init[2](err);}
+const _isfn = v => typeof v === 'function';
+const _isstr = v => typeof v === 'string';
 
-      _send_mqtt_pkt = null;
-      _q_init = ao_defer_v();
-      client._send = _send_ready;
-
-      // call client.on_conn_reset in next promise microtask
-      client.conn_emit('on_disconnect', false===err, err);}
-
-  , async send_connect(... args) {
-      if (! _send_mqtt_pkt) {
-        await _q_init[0]; }// _send_mqtt_pkt is set before fulfilled
-
-      // await connack response
-      let res = await _send_mqtt_pkt(...args);
-      if (0 == res[0].reason) {
-        _has_connected = true;
-        // resolve _q_ready[0] with _send_mqtt_pkt closure
-        _q_ready[1](client._send = _send_mqtt_pkt);
-        _q_ready = ao_defer_v();
-        client.conn_emit('on_ready');}
-
-      return res}
-
-  , is_set: (() =>!! _send_mqtt_pkt)
-  , set(mqtt_ctx, send_u8_pkt) {
-      if (_send_mqtt_pkt) {
-        throw new Error('Already connected')}
-
-      mqtt_ctx = mqtt_ctx.mqtt_stream();
-      let sess_ctx = {mqtt: client};
-      let on_mqtt_chunk = u8_buf =>
-        on_mqtt(mqtt_ctx.decode(u8_buf), sess_ctx);
-
-      _send_mqtt_pkt = async (type, pkt, key) => {
-        let res = undefined !== key
-          ? pkt_future(key) : true;
-
-        await send_u8_pkt(
-          mqtt_ctx.encode_pkt(type, pkt));
-
-        return res};
-
-      _q_init[1](_send_mqtt_pkt); // resolve _q_init with _send_mqtt_pkt closure
-
-      // call client.on_live in next promise microtask
-      client.conn_emit('on_live', _has_connected);
-      return on_mqtt_chunk} } }
-
-
-function _ping_interval(send_ping) {
+function _interval(fn_callback) {
   let tid;
   return (( td ) => {
     tid = clearInterval(tid);
     if (td) {
-      tid = setInterval(send_ping, 1000 * td);
+      tid = setInterval(fn_callback, 1000 * td);
       
         
         
@@ -964,172 +904,129 @@ function _ping_interval(send_ping) {
         tid.unref?.();
       return true} }) }
 
-const _mqtt_cmdid_dispatch ={
-  create(target) {
-    return {__proto__: this, target, hashbelt: [new Map()]} }
+async function _mqtt_cmd_evt(target, answer, pkt, ctx) {
+  /* target : on_mqtt_type = {
+        mqtt_pkt(pkt, ctx) {}, // generic
+
+        mqtt_auth(pkt, ctx) {},
+        mqtt_connect(pkt, ctx) {},
+        mqtt_connack(pkt, ctx) {},
+        mqtt_disconnect(pkt, ctx) {},
+
+        mqtt_publish(pkt, ctx) {},
+        mqtt_subscribe(pkt, ctx) {},
+        mqtt_unsubscribe(pkt, ctx) {},
+
+        mqtt_pingreq(pkt, ctx) {},
+        mqtt_pingresp(pkt, ctx) {},
+    } */
+
+  let pkt_fn = target[`mqtt_${pkt.type}`] || target.mqtt_pkt;
+  await pkt_fn?.call(target, pkt, ctx);}
+
+function _mqtt_cmd_type(target, answer, pkt, ctx) {
+  answer(pkt.type, pkt);
+  _mqtt_cmd_evt(target, answer, pkt, ctx);}
+
+function _mqtt_cmd_id(target, answer, pkt) {
+  answer(pkt.pkt_id, pkt);}
+
+
+const _mqtt_cmdids =[
+  _ => {}    // 0x0 reserved
+, _mqtt_cmd_evt   // 0x1 connect
+, _mqtt_cmd_type  // 0x2 connack
+, _mqtt_cmd_evt   // 0x3 publish
+, _mqtt_cmd_id    // 0x4 puback
+, _mqtt_cmd_id    // 0x5 pubrec
+, _mqtt_cmd_id    // 0x6 pubrel
+, _mqtt_cmd_id    // 0x7 pubcomp
+, _mqtt_cmd_evt   // 0x8 subscribe
+, _mqtt_cmd_id    // 0x9 suback
+, _mqtt_cmd_evt   // 0xa unsubscribe
+, _mqtt_cmd_id    // 0xb unsuback
+, _mqtt_cmd_type  // 0xc pingreq
+, _mqtt_cmd_type  // 0xd pingresp
+, _mqtt_cmd_evt   // 0xe disconnect
+, _mqtt_cmd_type  ];// 0xf auth
 
-, bind_pkt_future(_pkt_id=100) {
-    let {hashbelt} = this;
+function _mqtt_dispatch(opt, target) {
+  let hashbelt=[], rotate_ts=0;
+  // default rotate at 1s across 5 buckets
+  let { td: rotate_td=1000, n: rotate_n=5 } = opt?.rotate || {};
+
+  // Promise / future scaffolding
+  let _pkt_id=100, _ftr_key; // use _ftr_key to reuse _by_key closure
+  let _ftr_by_key = fn_answer => hashbelt[0].set(_ftr_key, fn_answer);
 
-    let _tmp_; // use _tmp_ to reuse _by_key closure
-    let _by_key = answer_monad =>
-      hashbelt[0].set(_tmp_, answer_monad);
+  on_mqtt([]); // init hashbelt and rotate_ts
+  return [on_mqtt, pkt_future]
 
-    return (( pkt_or_key ) => {
-      if ('string' === typeof pkt_or_key) {
-        _tmp_ = pkt_or_key;}
-      else {
-        _pkt_id = (_pkt_id + 1) & 0xffff;
-        _tmp_ = pkt_or_key.pkt_id = _pkt_id;}
 
-      return new Promise(_by_key)}) }
+  function pkt_future(pkt_or_key) {
+    if (! _isstr(pkt_or_key)) {
+      _pkt_id = (_pkt_id + 1) & 0xffff; // 16-bit unsigned short
+      _ftr_key = pkt_or_key.pkt_id = _pkt_id;}
+    else _ftr_key = pkt_or_key;
 
-, answer(key, pkt) {
-    for (let map of this.hashbelt) {
-      let answer_monad = map.get(key);
-      if (undefined !== answer_monad) {
+    return new Promise(_ftr_by_key)}
+
+  function answer(key, pkt) {
+    for (let map of hashbelt) {
+      let fn_answer = map.get(key);
+      if (fn_answer) {
         map.delete(key);
 
-        answer_monad([pkt, /*err*/]); // option/maybe monad
+        fn_answer([pkt, /*err*/]); // option/maybe monad
         return true} }
     return false}
 
-, rotate_belt(n) {
-    let {hashbelt} = this;
-    hashbelt.unshift(new Map());
-    for (let old of hashbelt.splice(n || 5)) {
-      for (let answer_monad of old.values()) {
-        answer_monad([/*pkt*/, 'expired']); } } }// option/maybe monad
-
-, cmdids: ((() => {
-    return [
-      (() =>{}    )// 0x0 reserved
-    , by_evt   // 0x1 connect
-    , by_type  // 0x2 connack
-    , by_evt   // 0x3 publish
-    , by_id    // 0x4 puback
-    , by_id    // 0x5 pubrec
-    , by_id    // 0x6 pubrel
-    , by_id    // 0x7 pubcomp
-    , by_evt   // 0x8 subscribe
-    , by_id    // 0x9 suback
-    , by_evt   // 0xa unsubscribe
-    , by_id    // 0xb unsuback
-    , by_type  // 0xc pingreq
-    , by_type  // 0xd pingresp
-    , by_evt   // 0xe disconnect
-    , by_type  ]// 0xf auth
-
-
-    function by_id(disp, pkt) {
-      disp.answer(pkt.pkt_id, pkt); }
-
-    function by_type(disp, pkt, ctx) {
-      disp.answer(pkt.type, pkt);
-      by_evt(disp, pkt, ctx);}
-
-    async function by_evt({target}, pkt, ctx) {
-      let fn = target[`mqtt_${pkt.type}`]
-        || target.mqtt_pkt;
-
-      await fn?.call(target, pkt, ctx);} })()) };
-
-/*
-on_mqtt_type = {
-  mqtt_auth(pkt, ctx) ::
-  mqtt_connect(pkt, ctx) ::
-  mqtt_connack(pkt, ctx) ::
-  mqtt_disconnect(pkt, ctx) ::
-
-  mqtt_publish(pkt, ctx)
-  mqtt_subscribe(pkt, ctx) ::
-  mqtt_unsubscribe(pkt, ctx) ::
-
-  mqtt_pingreq(pkt, ctx) ::
-  mqtt_pingresp(pkt, ctx) ::
-}
-*/
-
-function _mqtt_dispatch(opt, target) {
-  let _disp_ = _mqtt_cmdid_dispatch.create(target);
-  let { cmdids } = _disp_;
-
-  // default rotate at 1s across 5 buckets
-  let { td: rotate_td=1000, n: rotate_n=5 } =
-    opt && opt.rotate || {};
-
-  let rotate_ts = rotate_td + Date.now();
-
-  return [on_mqtt,
-    _disp_.bind_pkt_future()]
-
   function on_mqtt(pkt_list, ctx) {
     for (let pkt of pkt_list) {
-      cmdids[pkt.id](_disp_, pkt, ctx); }
+      _mqtt_cmdids[pkt.id](target, answer, pkt, ctx);}
 
-    if (Date.now() > rotate_ts) {
-      _disp_.rotate_belt(rotate_n);
-      rotate_ts = rotate_td + Date.now();} } }
+    // rotate after rotate_ts
+    let now = Date.now();
+    if (now > rotate_ts) {
+      rotate_ts = rotate_td + now;
+      hashbelt.unshift(new Map());
+      while (hashbelt.length > rotate_n) {
+        for (let fn_answer of hashbelt.pop().values()) {
+          fn_answer([/*pkt*/, 'expired']); } } } } }// option/maybe monad
 
 class MQTTError extends Error {
   constructor(mqtt_pkt, reason=mqtt_pkt.reason) {
+    // use hex-encoded reasons to match MQTT spec documentation
     super(`[0x${reason.toString(16)}] ${reason.reason}`);
     this.mqtt_pkt = mqtt_pkt;
     this.reason = reason;} }
 
 class MQTTBase {
-  constructor(opt={}) {
-    this.with(opt);
-    this._conn_ = _mqtt_conn(this,
-      this._init_dispatch(opt, this)); }
-
-  with(fns_ns) {
-    for (let [k,v] of Object.entries(fns_ns)) {
-      if ('function' === typeof v) {this[k] = v;} }
-    return this}
-
-  async conn_emit(evt, arg, err_arg) {
-    this.log_conn?.(evt, arg, err_arg);
-    try {
-      let fn_evt = this[await evt]; // microtask break using `await evt`
-      if (fn_evt) {
-        await fn_evt.call(this, this, arg, err_arg);}
-      else if (err_arg) {throw err_arg} }
-    catch (err) {
-      this.on_error(err, evt);} }
-
-  on_error(err, evt) {
-    console.warn('[[u8-mqtt error: %s]]', evt, err); }
-
   // Handshaking Packets
-
   async connect(pkt={}) {
-    let cid = pkt.client_id || this.client_id;
-    if ('string' !== typeof cid) {
+    let cid = pkt.client_id;
+    if (! _isstr(cid)) {
       // see init_client_id implementation in core.jsy
-      pkt.client_id = cid = this.init_client_id(cid);}
+      pkt.client_id = cid = this.client_id || this.init_client_id(cid);}
     this.client_id = cid;
 
     if (null == pkt.keep_alive) {
       pkt.keep_alive = 60;}
 
-    let res = await this._conn_
-      .send_connect('connect', pkt, 'connack');
-
-    if (0 != res[0].reason) {
-      throw new this.MQTTError(res[0])}
-
-    // TODO: merge with server's keep_alive frequency
-    this._conn_.ping(pkt.keep_alive);
-    return res}
+    let response = await this._send0('connect', pkt, 'connack');
+    if (0 != response[0].reason) {// compare to 0 to coerce to number
+      throw new this.MQTTError(response[0])}
+    return this.conn.on_conn(pkt, response)}
 
   async disconnect(pkt={}) {
-    let res = await this._send('disconnect', pkt);
-    this._conn_.reset(false);
-    return res}
+    let response = await this._send0('disconnect', pkt);
+    return this.conn.on_dis(pkt, response)}
 
-  auth(pkt={}) {
-    return this._send('auth', pkt, 'auth')}
+  async auth(pkt={}) {
+    let response = await this._send0('auth', pkt, 'auth');
+    if (response[0].reason) {
+      throw new this.MQTTError(response[0])}
+    return this.conn.on_auth(pkt, response)}
 
   ping() {return this._send('pingreq', null, 'pingresp')}
   puback({pkt_id}) {return this._send('puback', {pkt_id})}
@@ -1166,20 +1063,18 @@ class MQTTBase {
   // alias: publish -- because 'pub' is shorter for semantic aliases above
   async pub(pkt, pub_opt) {
     if (undefined === pkt.payload) {
-      if ('function' === typeof pub_opt) {
+      if (_isfn(pub_opt)) {
+        // pub_opt as a function is fn_encode value
         pub_opt = {fn_encode: pub_opt};}
 
-      let {msg} = pkt;
-      switch (typeof msg) {
-        case 'function':
-          pub_opt = {...pub_opt, fn_encode: msg};
-          // flow into 'undefined' case
-        case 'undefined':
-          // return a single-value closure to publish packets
-          return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)}
+      let msg = pkt.msg, fn_encode = pub_opt?.fn_encode;
+      if (null == msg || _isfn(msg)) {
+        // when msg is a function, return closure using fn_encode
+        if (msg) {pub_opt = {...pub_opt, fn_encode: msg};}
+        // return a single-value closure to publish packets
+        return v => this.pub({...pkt, [pkt.arg || 'payload']: v}, pub_opt)}
 
       // Encode payload from msg; fn_encode allows alternative to JSON.stringify
-      let {fn_encode} = pub_opt || {};
       pkt.payload = fn_encode
         ? await fn_encode(msg)
         : JSON.stringify(msg);}
@@ -1191,31 +1086,31 @@ class MQTTBase {
         pkt = pub_opt.xform(pkt) || pkt;} }
 
     return this._send('publish', pkt,
-      pkt.qos ? pkt : void 0 ) }// key
+      pkt.qos ? pkt : null ) }// key
 
 
   // Internal API
 
-  /* async _send(type, pkt) -- provided by _conn_ and transport */
+  /* async _send0(type, pkt) -- provided by conn and transport */
+  /* async _send(type, pkt) -- provided by conn and transport */
 
   _init_dispatch(opt) {
     this.constructor?._once_();
     let target ={__proto__: opt.on_mqtt_type};
     target.mqtt_publish ||=
       this._init_router?.(opt, this, target);
-    return _mqtt_dispatch(this, target)}
+    return _mqtt_dispatch(opt, target)}
 
   static _aliases() {
     return ' publish:pub sub:subscribe unsub:unsubscribe json_post:obj_post json_send:obj_send json_store:obj_store'}
 
-  static _once_(self=this) {
-    self._once_ = _=>0;
-    let p = self.prototype;
+  static _once_(klass=this) {
+    klass._once_ = _=>0;
+    var alias, name, p = klass.prototype;
     p.MQTTError = MQTTError;
-    for (let alias of self._aliases().split(/\s+/)) {
-      alias = alias.split(':');
-      let fn = alias[1] && p[alias[1]];
-      if (fn) {p[alias[0]] = fn;} } } }
+    for (alias of klass._aliases().split(/\s+/)) {
+      [alias, name] = alias.split(':');
+      p[alias] = p[name];} } }
 
 
 function _as_topics(pkt, ex, topic_prefix) {
@@ -1240,43 +1135,177 @@ function _as_topics(pkt, ex, topic_prefix) {
     pkt.topics = pkt.topics.map(_prefix_topics);}
   return pkt}
 
-const pkt_api = {
-  utf8(u8) { return new TextDecoder('utf-8').decode(u8 || this.payload ) },
-  json(u8) { return JSON.parse( this.utf8(u8) || null ) },
-  text(u8) { return this.utf8(u8) },
-};
+const _defer_obj = o =>(
+  o.p = new Promise((a,e) => { o.a=a; o.e=e; })
+  , o);
+
+function _dfn_reset(client, attr, fn_after) {
+  // a resetable deferred for a function
+  let self = {set}, afn = async (...args) => (await self.p)(...args);
+  return set()
+
+  function set() {
+    if (afn !== client[attr]) {
+      _defer_obj(self).p.then(fn_after, _=>0);
+      client[attr] = afn;}
+    return self} }
+
+function _mqtt_conn(opt, client, [on_mqtt, pkt_future]) {
+  let _abort;
+  let _dfn_send0 = _dfn_reset(client, '_send0', // client._send0 getter/setter
+    _=> client.conn_emit('on_live', conn.has_connected));
+  let _dfn_ready = _dfn_reset(client, '_send', // client._send getter/setter
+    _=> client.conn_emit('on_ready'));
+  let _keep_alive_ival = _interval (() =>client._send0('pingreq') );// resettable interval for keep_alive ping
+
+  let conn = Object.create({
+    ping: (td=conn.keep_alive) => _keep_alive_ival(td)
+
+  , on_conn(pkt, response) {
+      conn.has_connected = true;
+      conn.keep_alive = opt.keep_alive || response[0].props?.server_keep_alive || pkt.keep_alive;
+      client.conn_emit('on_conn');
+      return opt.use_auth
+        ? response // wait on enhanced authentication step
+        : conn.on_auth(null, response) }// otherwise, connect is also auth
+
+  , on_auth(pkt, response) {
+      _dfn_ready.a(_dfn_send0.p);
+      if (0 != opt.keep_alive) {
+        conn.ping();}
+      client.conn_emit('on_auth', !pkt);
+      return response}
+
+  , on_dis(pkt, response) {
+      conn.reset(false);
+      return response}
+
+  , reset(err) {
+      if (err) {
+        _dfn_send0.e(err); }// send error to uses of _send0 (connect, auth)
+      _abort.e(err); // abort in-progress connections
+
+      delete conn.is_set;
+      conn.ready = handshake();
+      client.conn_emit('on_disconnect', false===err, err);}
+
+  , abort() {
+      _dfn_ready.e(err); // abort all messages awaiting ready state
+      return conn.reset(err)}
+
+  , async setup(gate, send_u8_pkt, init_msg_loop) {
+      if (conn.is_set) {
+        throw new Error() }// already in-progress
+
+      conn.is_set = true;
+      await gate;
+
+      // setup send/recv MQTT parsing context
+      let mqtt_ctx = client.mqtt_ctx.mqtt_stream();
+
+       {// setup inbound message loop
+        let sess_ctx = {mqtt: client}; // mutable session context
+        let on_mqtt_chunk = u8 => on_mqtt(mqtt_ctx.decode(u8), sess_ctx);
+        init_msg_loop(on_mqtt_chunk, conn);}
+
+      // setup outbound message path and transport connection
+      send_u8_pkt = await send_u8_pkt;
+      _dfn_send0.a(
+        async (type, pkt, key) => {
+          let res = undefined !== key
+            ? pkt_future(key) : true;
+
+          await send_u8_pkt(
+            mqtt_ctx.encode_pkt(type, pkt));
+          return res} ); } });
+
+  conn.ready = handshake();
+  return conn
+
+  async function handshake() {
+    _abort = _defer_obj({});
+
+    _keep_alive_ival(0); // clearInterval on keep alive ping
+    _dfn_send0.set(); // reset client._send0 if necessary
+    _dfn_ready.set(); // reset client._send if necessary
+
+    try {
+      // set client._send0 as passtrhough after transport connection
+      client._send0 = await Promise.race([_dfn_send0.p, _abort.p]);
+
+      // set client._send as passtrhough after ready
+      client._send = await Promise.race([_dfn_ready.p, _abort.p]);
+      return true}
+    catch (err) {
+      return false} } }
+
+const pkt_api ={
+  utf8(u8) {return new TextDecoder('utf-8').decode(u8 || this.payload )}
+, json(u8) {return JSON.parse( this.utf8(u8) || null )}
+, text(u8) {return this.utf8(u8)} };
+
+const opt_default ={
+  sess_stg: globalThis.sessionStorage};
 
 class MQTTCore extends MQTTBase {
+  constructor(opt) {
+    super();
+    this.with(opt);
+    opt ={...opt_default, ...opt};
+    // settings for MQTTCore
+    this.sess_stg = opt.sess_stg;
+    // setup connection and dispatch
+    this.conn = _mqtt_conn(opt, this,
+      this._init_dispatch(opt)); }
+
+  with(fns_ns) {
+    for (let [k,v] of Object.entries(fns_ns)) {
+      if (_isfn(v)) {this[k] = v;} }
+    return this}
+
+
   static mqtt_ctx(mqtt_level, mqtt_opts, pkt_ctx=pkt_api) {
-    let self = class extends this {};
-    self.prototype.mqtt_ctx =
+    let klass = class extends this {};
+    klass.prototype.mqtt_ctx =
       mqtt_pkt_ctx(mqtt_level, mqtt_opts, pkt_ctx);
-    return self}
+    return klass}
+
+
+  async conn_emit(evt, arg, err_arg) {
+    this.log_conn?.(evt, arg, err_arg);
+    try {
+      let fn_evt = this[await evt]; // microtask break using `await evt`
+      if (fn_evt) {
+        await fn_evt.call(this, this, arg, err_arg);}
+      else if (err_arg) {throw err_arg} }
+    catch (err) {
+      this.on_error(err, evt);} }
+
+  on_error(err, evt) {
+    console.warn('[[u8-mqtt error: %s]]', evt, err); }
+  log_conn(evt, arg, err_arg) {
+    console.info('[[u8-mqtt conn: %s]]', evt, arg, err_arg); }
 
 
   // automatic Client Id for connect()
   init_client_id(parts=['u8-mqtt--','']) {
-    let sess_stg=this.sess_stg;
+    let sess_stg = this.sess_stg;
     let key, cid = sess_stg?.getItem(key=parts.join(' '));
     if (! cid) {
       cid = parts.join(Math.random().toString(36).slice(2));
       sess_stg?.setItem(key, cid);}
     return cid}
 
-  get sess_stg() {return globalThis.sessionStorage}
-
-
-  //on_error(err, evt) ::
-  //  console.warn @ '[[u8-mqtt error: %s]]', evt, err
-
-  //log_conn(evt, arg, err_arg) ::
-  //  console.info @ '[[u8-mqtt log: %s]]', evt, arg, err_arg
 
   on_live(client, is_reconnect) {
     if (is_reconnect) {
       return client.connect()} }
 
-  //on_reconnect(client) ::
+  // on_ready(client) ::
+  // on_reconnect(client) ::
+  on_disconnect(client, intentional) {
+    if (! intentional) {
+      return client.on_reconnect?.()} }
 
   _use_conn(fn_reconnect) {
     return (this.reconnect = fn_reconnect)?.()}
@@ -1288,27 +1317,20 @@ class MQTTCore extends MQTTBase {
           .then(this.reconnect)
           .then(opt.reconnect, opt.error);} }) }
 
-  on_disconnect(client, intentional) {
-    if (! intentional) {
-      return client.on_reconnect?.()} }
-
   delay(ms) {
     return new Promise(done => setTimeout(done, ms)) }
 
   with_async_iter(async_iter, write_u8_pkt) {
-    let on_mqtt_chunk = this._conn_.set(
-      this.mqtt_ctx,
-      write_u8_pkt);
-
-    this._msg_loop = ((async () => {
-      try {
-        async_iter = await async_iter;
-        for await (let chunk of async_iter)
-          on_mqtt_chunk(chunk);
-        this._conn_.reset();}
-      catch (err) {
-        this._conn_.reset(err);} })());
-
+    this.conn.setup(async_iter,
+      write_u8_pkt,
+      async (on_mqtt_chunk, conn) => {
+        try {
+          async_iter = await async_iter;
+          for await (let chunk of async_iter)
+            on_mqtt_chunk(chunk);
+          conn.reset();}
+        catch (err) {
+          conn.reset(err);} } );
     return this}
 
 
@@ -1379,33 +1401,30 @@ class MQTTCore extends MQTTBase {
 
     websock.binaryType = 'arraybuffer';
 
-    let ready, {readyState} = websock;
+    let ws_ready, readyState = websock.readyState;
     if (1 !== readyState) {
       if (0 !== readyState) {
-        throw new Error('Invalid WebSocket readyState') }
-
-      ready = new Promise(fn => websock.onopen = fn); }
+        throw new Error('WS readyState') }
 
+      ws_ready = new Promise(ready => websock.onopen = ready); }
 
-    let {_conn_} = this;
-    let on_mqtt_chunk = _conn_.set(
-      this.mqtt_ctx,
-      async u8_pkt =>(
-        await ready
-      , websock.send(u8_pkt)) );
+    this.conn.setup(ws_ready,
+      u8_pkt => websock.send(u8_pkt),
+      (on_mqtt_chunk, conn) => {
+        websock.onmessage = evt =>(
+          on_mqtt_chunk(new Uint8Array(evt.data)) );
 
-    websock.onmessage = evt =>(on_mqtt_chunk(new Uint8Array(evt.data)));
-    websock.onclose = evt => {
-      if (! evt.wasClean) {
-        var err = new Error('websocket connection close');
-        err.code = evt.code;
-        err.reason = evt.reason;}
+        websock.onclose = evt => {
+          if (! evt.wasClean) {
+            var err = new Error('websocket close');
+            err.code = evt.code;
+            err.reason = evt.reason;}
 
-      _conn_.reset(err);};
+          conn.reset(err);}; } );
 
     return this} }
 
-const version = '0.5.2-node';
+const version = '0.6.0-node';
 
 const MQTTClient_v4 = /* #__PURE__ */
   MQTTCore.mqtt_ctx(4, mqtt_opts_v5);