beam.com 0.1.0-rc.1

package/runtime/page/ws-shim.js

@@ -0,0 +1,143 @@
+// The service worker of the page (sw.js) adds this script to each HTML page
+// of the VM. It does four things:
+// - A service worker cannot take a WebSocket. So a socket to this site goes
+//   to the VM through the tab of index.html (a message port), and the VM
+//   runs its upgrade. The message goes to the top window, the tab of
+//   index.html. Another socket is a real one.
+// - A service worker cannot open the SharedWorker of the VM. So it gives a
+//   request of this frame to this frame, and this frame gives it to its
+//   tab, which gives it to the VM.
+// - A link or a form of the app with a path outside the frame (for
+//   example href="/", which an app writes without its base path) goes to
+//   the same path in the frame. Without this, the browser leaves the scope
+//   of the service worker, and the site gives a 404.
+// - The frame of the app gives its path to its tab at each load and after
+//   each change of its history (a navigation of LiveView). The tab keeps it
+//   in the fragment of its URL, so a reload and a link keep the page.
+(() => {
+  // The same rule as scope.js, which a classic script cannot import.
+  // The scope of the frame: data-app of sw.js (this script can come from
+  // a CDN), else app/ next to this script (the sw.js of an older site).
+  const script = document.currentScript;
+  const APP = script?.dataset.app ? new URL(script.dataset.app, location.href)
+    : new URL('./app/', script?.src ?? location.href);
+  const outside = (u) => u.origin === location.origin && !`${u.pathname}/`.startsWith(APP.pathname);
+  const inApp = (u) => new URL(APP.pathname.replace(/\/$/, '') + u.pathname + u.search + u.hash, u).href;
+
+  addEventListener('click', (e) => {
+    const a = e.target instanceof Element ? e.target.closest('a[href]') : null;
+    if (!a || a.hasAttribute('download') || (a.target && a.target !== '_self')) return;
+    const u = new URL(a.href);
+    if (outside(u)) a.href = inApp(u);
+  }, true);
+  addEventListener('submit', (e) => {
+    const form = e.target;
+    if (!(form instanceof HTMLFormElement)) return;
+    const u = new URL(form.action);
+    if (outside(u)) form.action = inApp(u);
+  }, true);
+
+  const Native = window.WebSocket;
+  const top = window.top;
+  if (!top || top === window) return;
+
+  // Only the frame of the app (not a frame in it) gives its path.
+  if (window.parent === top && location.pathname.startsWith(APP.pathname)) {
+    const report = () => top.postMessage({
+      type: 'path',
+      path: location.pathname.slice(APP.pathname.length - 1) + location.search + location.hash,
+    }, location.origin);
+    for (const name of ['pushState', 'replaceState']) {
+      const native = history[name];
+      history[name] = function (...args) {
+        const result = native.apply(this, args);
+        report();
+        return result;
+      };
+    }
+    addEventListener('popstate', report);
+    addEventListener('hashchange', report);
+    report();
+  }
+
+  const sw = navigator.serviceWorker;
+  if (sw) {
+    sw.addEventListener('message', (e) => {
+      if (e.data?.type === 'fetch') top.postMessage(e.data, location.origin, [...e.ports]);
+    });
+    sw.startMessages();
+    sw.controller?.postMessage({ type: 'frame' });
+  }
+
+  class VmSocket extends EventTarget {
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+
+    constructor(url, protocols) {
+      super();
+      this.url = url.href;
+      this.readyState = 0;
+      this.protocol = '';
+      this.extensions = '';
+      this.bufferedAmount = 0;
+      this.binaryType = 'blob';
+      this.onopen = this.onmessage = this.onclose = this.onerror = null;
+      const { port1, port2 } = new MessageChannel();
+      this.port = port1;
+      port1.onmessage = (e) => this.receive(e.data);
+      const list = protocols === undefined ? [] : [].concat(protocols);
+      top.postMessage({ type: 'ws', path: url.pathname + url.search, protocols: list }, location.origin, [port2]);
+    }
+
+    receive(m) {
+      if (m.open) {
+        this.readyState = 1;
+        this.protocol = m.protocol ?? '';
+        this.emit(new Event('open'));
+      } else if (m.message !== undefined) {
+        let data = m.message;
+        if (data instanceof ArrayBuffer && this.binaryType === 'blob') data = new Blob([data]);
+        this.emit(new MessageEvent('message', { data, origin: location.origin }));
+      } else if (m.close) {
+        if (this.readyState === 3) return;
+        const wasOpen = this.readyState === 1;
+        this.readyState = 3;
+        this.port.close();
+        if (!wasOpen || m.error) this.emit(new Event('error'));
+        this.emit(new CloseEvent('close', { code: m.code ?? 1006, reason: m.reason ?? '', wasClean: !m.error }));
+      }
+    }
+
+    send(data) {
+      if (this.readyState === 0) throw new DOMException('Still in CONNECTING state.', 'InvalidStateError');
+      if (this.readyState !== 1) return;
+      if (data instanceof Blob) {
+        data.arrayBuffer().then((b) => this.port.postMessage({ message: b }, [b]));
+      } else if (ArrayBuffer.isView(data)) {
+        this.port.postMessage({ message: data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) });
+      } else {
+        this.port.postMessage({ message: data });
+      }
+    }
+
+    close(code = 1000, reason = '') {
+      if (this.readyState >= 2) return;
+      this.readyState = 2;
+      this.port.postMessage({ close: true, code, reason });
+    }
+
+    emit(event) {
+      this.dispatchEvent(event);
+      this[`on${event.type}`]?.(event);
+    }
+  }
+
+  window.WebSocket = function WebSocket(url, protocols) {
+    const u = new URL(url, location.href);
+    if (u.host === location.host) return new VmSocket(u, protocols);
+    return protocols === undefined ? new Native(url) : new Native(url, protocols);
+  };
+  Object.assign(window.WebSocket, { CONNECTING: 0, OPEN: 1, CLOSING: 2, CLOSED: 3, prototype: Native.prototype });
+})();

package/runtime/release/app.js

@@ -0,0 +1,17 @@
+// A Worker that holds only a release (release.bin of beam_com_wasm), for a runtime
+// Worker (worker.js with a service binding APP) to boot; and, if there is
+// one, a snapshot of the booted VM (snapshot.bin).
+import release from './release.bin';
+
+async function snapshot() {
+  try { return (await import('./snapshot.bin')).default; } catch { return null; }
+}
+
+export default {
+  async fetch(request) {
+    const path = new URL(request.url).pathname;
+    const data = path === '/release.bin' ? release : path === '/snapshot.bin' ? await snapshot() : null;
+    if (!data) return new Response('not found', { status: 404 });
+    return new Response(data, { headers: { 'content-type': 'application/octet-stream' } });
+  },
+};

package/runtime/release.json

@@ -0,0 +1 @@
+{"version": "0.1.0-rc.1", "sha256": "910a07163cdfd74ab8534af7613104f3b84ea4ffda7b495b9be86d9359d8519d"}

package/runtime/runtime-id.js

@@ -0,0 +1,3 @@
+// The identity of this runtime (beam_com_wasm:runtime_id/1): the SHA-256 of
+// the output of "sha256sum app-com.js beam.mjs beam.wasm worker.js".
+export default '8f7af69ef48fc70da056a5684afc43055a33cfd9efb3099d858b0f75b33e351b';

package/runtime/tcp-proxy.mjs

@@ -0,0 +1,30 @@
+// A client proxy for incoming TCP on Workers: each connection to a local
+// port becomes a WebSocket to /.tcp/PORT of the Worker (worker.js), which
+// gives it to the listener of PORT in Erlang (gen_tcp:listen).
+//
+//   node tcp-proxy.mjs LOCAL_PORT wss://app.example.com/.tcp/PORT
+//   ssh -p LOCAL_PORT localhost
+import net from 'node:net';
+import { WebSocket } from 'ws';
+
+const [localPort, url] = process.argv.slice(2);
+if (!localPort || !url) {
+  console.error('usage: node tcp-proxy.mjs LOCAL_PORT WS_URL');
+  process.exit(2);
+}
+
+net.createServer((sock) => {
+  sock.pause();
+  sock.setNoDelay(true);
+  const ws = new WebSocket(url);
+  ws.binaryType = 'nodebuffer';
+  ws.on('open', () => {
+    sock.on('data', (d) => ws.send(d, { binary: true }));
+    sock.resume();
+  });
+  ws.on('message', (d) => sock.write(d));
+  ws.on('close', () => sock.end());
+  ws.on('error', (e) => { console.error(`tcp-proxy: ${e.message}`); sock.destroy(); });
+  sock.on('close', () => ws.close());
+  sock.on('error', () => ws.close());
+}).listen(Number(localPort), '127.0.0.1', () => console.error(`tcp-proxy: 127.0.0.1:${localPort} -> ${url}`));