html_messaging={
  gpio=0x5f80,
  pins={
    send_req=1, -- output
    read_req=3, -- input
    clk_out=5, --input
    data_out=7, -- output
    data_in=8 -- input
  },
  send_message=function(self, message)
    if #message == 0 then return end

    poke(self.gpio + self.pins.send_req, 0xFF)

    for i=1,#message do
      poke(self.gpio + self.pins.data_out, ord(message, i))
    end

    poke(self.gpio + self.pins.send_req, 0x00)
  end,

  _listeners={},
  add_listener=function(self, listener)
    add(self._listeners, listener)
  end,
  remove_listener=function(self, listener)
    del(self._listeners, listener)
  end,
  update=function(self)
    local message = __messaging_receive_message()
    if not message then return end
    for listener in all(self._listeners) do
      listener(message)
    end
  end
}

function __messaging_receive_message()
  local gpio = html_messaging.gpio
  local pins = html_messaging.pins

  local is_sending = peek(gpio + pins.read_req) == 0xff

  if not is_sending then return false end

  local input_buffer = ""
  while peek(gpio + pins.read_req) == 0xff do
    input_buffer = input_buffer..chr(peek(gpio + pins.data_in))
    poke(gpio + pins.clk_out, 0xff)
    poke(gpio + pins.clk_out, 0x00)
  end
  return input_buffer
end

(function () {
  class GPIO extends EventTarget {
    static READ = 'read';
    static WRITE = 'write';
    pins = new Array(128);

    get interruptPins() {
      return new Proxy(this, {
        get: (object, prop) => {
          const evt = new ReadEvent(prop);
          this.dispatchEvent(evt);

          return object.pins[prop];
        },
        set: (object, prop, value) => {
          object.pins[prop] = value;

          const evt = new WriteEvent(prop, value);
          this.dispatchEvent(evt);
        }
      });
    }
  }
  window.P8GPIO = GPIO;
  class ReadEvent extends Event {
    pin = 0;

    constructor(pin) {
      super(GPIO.READ);
      this.pin = Number.parseInt(pin);
    }
  }
  class WriteEvent extends Event {
    pin = 0;
    payload = '';

    constructor(pin, payload) {
      super(GPIO.WRITE);
      this.pin = Number.parseInt(pin);
      this.payload = payload;
    }
  }

  const gpio = new GPIO();
  window.pico8_gpioBus = gpio;
  window.pico8_gpio = gpio.interruptPins;

  const HIGH = 0xFF;
  const LOW = 0x00;
  const PINS = {
    sendReq: 1, // input
    readReq: 3, // output
    clkIn: 5, // output
    dataIn: 7, // input
    dataOut: 8 // output
  }

  class GPIOMessaging extends EventTarget {
    static MESSAGE = 'message';

    constructor() {
      super();
      gpio.addEventListener(GPIO.WRITE, event => {
        if (event.pin === PINS.sendReq && event.payload === HIGH) {
          this._receiveMessage();
        }
      })
    }

    _messageQueue = new Array();
    sendMessage(message) {
      const { resolve, promise } = destructPromise();
      this._messageQueue.push({
        resolve,
        message
      });
      this._flushMessages();

      return promise;
    }

    _isSending = false;
    _flushMessages() {
      if (this._isSending || this._messageQueue.length === 0) return;

      const { resolve, message } = this._messageQueue.shift();
      if(message.length === 0) {
        return resolve();
      }
      this._isSending = true;

      let idx = 0;
      const self = this;
      function handleWrite({ pin, payload }) {
        if(pin === PINS.clkIn && payload === LOW) {
          idx++;
          if (message.length <= idx) {
            gpio.removeEventListener(GPIO.WRITE, handleWrite);
            gpio.pins[PINS.readReq] = LOW
            resolve();
            self._isSending = false;
            self._flushMessages();
          } else {
            gpio.pins[PINS.dataOut] = message.charCodeAt(idx)
          }
        }
      }
      gpio.addEventListener(GPIO.WRITE, handleWrite);

      gpio.pins[PINS.dataOut] = message.charCodeAt(idx)
      gpio.pins[PINS.readReq] = HIGH
    }

    _receiveMessage() {
      let buffer = "";
      const _self = this;
      function handleWrite({ pin, payload }) {
        switch (pin) {
          case PINS.dataIn:
            buffer += String.fromCharCode(payload);
            break;
          case PINS.sendReq:
            if (payload === LOW) {
              gpio.removeEventListener(GPIO.WRITE, handleWrite);
              const event = new MessageEvent(buffer);
              _self.dispatchEvent(event);
            }
            break;
        }
      }
      gpio.addEventListener(GPIO.WRITE, handleWrite);
      // In here we told pico8 we were ready to receive
      // Now that's not needed anymore, as p8 assumes interrupts are synchronous
      // gpio.pins[2] = HIGH
    }
  }
  window.P8GPIOMessaging = GPIOMessaging;
  class MessageEvent extends Event {
    message = ''
    constructor(message) {
      super(GPIOMessaging.MESSAGE)
      this.message = message;
    }
  }
  window.pico8_gpioMessaging = new GPIOMessaging();

  function destructPromise() {
    let resolve, reject
    const promise = new Promise((res, rej) => {
      resolve = res;
      reject = rej;
    });
    return { resolve, reject, promise };
  }
})();

-- requires html_messaging.lua

http_request={
  _cid=0,
  get=function(self,url,cb)
    local cid = self._cid
    self._cid = self._cid + 1
    local handle_message = function(message)
      local match_header = "HTTP RES "..cid
      local msg_header = sub(message, 1, #match_header)
      if match_header != msg_header then return end
      local response = sub(message, #match_header + 2)
      cb(response)
      html_messaging:remove_listener(handle_message)
    end
    html_messaging:add_listener(handle_message)
    html_messaging:send_message("HTTP REQ "..cid.." GET "..url)
  end
}

// Requires gpio_messaging.js

pico8_gpioMessaging.addEventListener('message', ({ message }) => {
  if (message.startsWith("HTTP REQ")) {
    const [http, req, cid, method, url] = message.split(" ");
    fetch(url, {
      method
    })
      .then(result => result.text())
      .then(result => pico8_gpioMessaging.sendMessage(`HTTP RES ${cid} ${result}`))
  }
})