@daugasauron/dolly-host-touch 0.0.0-stage → 0.1.4-rc.0

package/README.md

@@ -1,3 +1,4 @@
-# Temporary Holding Version
+# @daugasauron/dolly-host-touch
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Dolly's `touch@0` host module: fingers on a touchscreen: every one that is down, each with its id. Give the URL of its
+`module.json` to `boot()`'s `modules`; @daugasauron/dolly's README says how.

package/abi.mjs

@@ -0,0 +1,19 @@
+// Generated from host/touch/dolly-touch-0.wat, host/touch/touch.h, include/dolly/process.h.
+export const DOLLY_TOUCH_HEADER_SIZE = 16;
+export const DOLLY_TOUCH_RECORD_SIZE = 32;
+export const DOLLY_TOUCH_CAPACITY = 512;
+export const DOLLY_TOUCH_WORD_READ = 0;
+export const DOLLY_TOUCH_WORD_WRITE = 1;
+export const DOLLY_TOUCH_WORD_LEASE = 2;
+export const DOLLY_TOUCH_WORD_ENABLED = 3;
+export const DOLLY_TOUCH_DOWN = 1;
+export const DOLLY_TOUCH_MOVE = 2;
+export const DOLLY_TOUCH_UP = 3;
+export const DOLLY_TOUCH_CANCEL = 4;
+export const DOLLY_TOUCH_FINGERS = 10;
+export const DOLLY_TOUCH_ACQUIRE = 92;
+export const DOLLY_TOUCH_READ = 93;
+export const DOLLY_TOUCH_RELEASE = 94;
+export const DOLLY_TOUCH_READ_RECORDS = 64;
+export const DOLLY_ERRNO = Object.freeze({ E2BIG: 1, EACCES: 2, EADDRINUSE: 3, EADDRNOTAVAIL: 4, EAFNOSUPPORT: 5, EAGAIN: 6, EALREADY: 7, EBADF: 8, EBADMSG: 9, EBUSY: 10, ECANCELED: 11, ECHILD: 12, ECONNABORTED: 13, ECONNREFUSED: 14, ECONNRESET: 15, EDEADLK: 16, EDESTADDRREQ: 17, EDOM: 18, EDQUOT: 19, EEXIST: 20, EFAULT: 21, EFBIG: 22, EHOSTUNREACH: 23, EIDRM: 24, EILSEQ: 25, EINPROGRESS: 26, EINTR: 27, EINVAL: 28, EIO: 29, EISCONN: 30, EISDIR: 31, ELOOP: 32, EMFILE: 33, EMLINK: 34, EMSGSIZE: 35, EMULTIHOP: 36, ENAMETOOLONG: 37, ENETDOWN: 38, ENETRESET: 39, ENETUNREACH: 40, ENFILE: 41, ENOBUFS: 42, ENODEV: 43, ENOENT: 44, ENOEXEC: 45, ENOLCK: 46, ENOLINK: 47, ENOMEM: 48, ENOMSG: 49, ENOPROTOOPT: 50, ENOSPC: 51, ENOSYS: 52, ENOTCONN: 53, ENOTDIR: 54, ENOTEMPTY: 55, ENOTRECOVERABLE: 56, ENOTSOCK: 57, ENOTTY: 59, ENXIO: 60, EOVERFLOW: 61, EOWNERDEAD: 62, EPERM: 63, EPIPE: 64, EPROTO: 65, EPROTONOSUPPORT: 66, EPROTOTYPE: 67, ERANGE: 68, EROFS: 69, ESPIPE: 70, ESRCH: 71, ESTALE: 72, ETIMEDOUT: 73, ETXTBSY: 74, EXDEV: 75, ENODATA: 116, ENOTSUP: 138 });
+export const DOLLY_TOUCH_ABI_DIGEST = "515bdcabf63b7396d485abded3a066c0c55771b0eedf4de824f3f728e645cf1c";

package/module.json

@@ -0,0 +1,15 @@
+{
+  "name": "touch",
+  "version": 0,
+  "gives": "fingers on a touchscreen: every one that is down, each with its id",
+  "dependencies": ["runtime@0"],
+  "phase": "image",
+  "imports": [],
+  "host": "touch.mjs",
+  "contracts": ["dolly-touch-0.wat"],
+  "process": [],
+  "headers": ["touch.h", "touch-abi.h"],
+  "kernel": ["kernel.c"],
+  "client": ["client.c"],
+  "package": "libdolly-touch"
+}

package/package.json

@@ -1,6 +1,14 @@
 {
+  "version": "0.1.4-rc.0",
+  "type": "module",
   "name": "@daugasauron/dolly-host-touch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "license": "MIT",
+  "dependencies": {
+    "@daugasauron/dolly": "0.1.4-rc.0"
+  },
+  "description": "Dolly's touch@0 host module: fingers on a touchscreen: every one that is down, each with its id.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daugasauron/dolly.git"
+  }
+}

package/touch.mjs

@@ -0,0 +1,166 @@
+import * as T from "./abi.mjs";
+export { DOLLY_TOUCH_ABI_DIGEST as digest } from "./abi.mjs";
+
+const word = { read: T.DOLLY_TOUCH_WORD_READ, write: T.DOLLY_TOUCH_WORD_WRITE,
+  lease: T.DOLLY_TOUCH_WORD_LEASE, enabled: T.DOLLY_TOUCH_WORD_ENABLED };
+// Moves leave room for every finger's down and its end.
+const moveReserve = 2 * T.DOLLY_TOUCH_FINGERS;
+
+// The Worker's end of the touch mailbox, the one producer of its records: the
+// page sends it the fingers it took. A finger is delivered under the lease its
+// down was written for; the fingers of an earlier lease, and those refused,
+// are nobody's until they end.
+export class TouchTransport {
+  // The ring's size is the contract's; a test may shrink it.
+  constructor(buffer, address, { capacity = T.DOLLY_TOUCH_CAPACITY } = {}) {
+    if (!(buffer instanceof SharedArrayBuffer)) throw new Error("Dolly touch transport requires shared Wasm memory");
+    if (!Number.isSafeInteger(address) || address <= 0 || address % 4 !== 0 || !Number.isSafeInteger(capacity) ||
+        capacity <= moveReserve || (capacity & (capacity - 1)) !== 0 ||
+        address > buffer.byteLength - T.DOLLY_TOUCH_HEADER_SIZE - capacity * T.DOLLY_TOUCH_RECORD_SIZE) {
+      throw new Error("Dolly supplied an invalid touch mailbox");
+    }
+    this.view = new DataView(buffer);
+    this.words = new Int32Array(buffer);
+    this.address = address;
+    this.capacity = capacity;
+    this.fingers = new Map();
+    this.ignored = new Set();
+    this.heldLease = 0;
+    this.nextId = 1;
+    this.dropped = 0;
+  }
+
+  load(name) { return Atomics.load(this.words, this.address / 4 + word[name]) >>> 0; }
+
+  // The holder's lease word: zero while no program holds the lease.
+  lease() { return this.load("lease"); }
+
+  free() { return this.capacity - ((this.load("write") - this.load("read")) >>> 0); }
+
+  write(id, phase, { x, y, pressure, time }) {
+    const write = this.load("write");
+    const offset = this.address + T.DOLLY_TOUCH_HEADER_SIZE + (write & (this.capacity - 1)) * T.DOLLY_TOUCH_RECORD_SIZE;
+    [id, phase, x, y, pressure, this.dropped, time, this.heldLease]
+      .forEach((value, index) => this.view.setUint32(offset + index * 4, value >>> 0, true));
+    this.dropped = 0;
+    Atomics.store(this.words, this.address / 4 + word.write, (write + 1) | 0);
+  }
+
+  // One Pointer Event of a finger as samples ({ x, y, pressure, time }, the
+  // coalesced moves of a pointermove). Returns whether the finger is this
+  // module's, so that it is not also the pointer.
+  finger(phase, pointerId, samples) {
+    const lease = this.lease();
+    if (lease !== this.heldLease) {
+      for (const pointer of this.fingers.keys()) this.ignored.add(pointer);
+      this.fingers.clear();
+      this.heldLease = lease;
+    }
+    const id = this.fingers.get(pointerId), ends = phase === T.DOLLY_TOUCH_UP || phase === T.DOLLY_TOUCH_CANCEL;
+    if (id === undefined) {
+      if (this.ignored.has(pointerId)) {
+        if (ends) this.ignored.delete(pointerId);
+        return true;
+      }
+      if (phase !== T.DOLLY_TOUCH_DOWN || !lease) return false;
+      // The ring keeps room for this down and the end of every finger that is down.
+      if (this.fingers.size === T.DOLLY_TOUCH_FINGERS || this.free() < this.fingers.size + 2) {
+        this.dropped++;
+        this.ignored.add(pointerId);
+        return true;
+      }
+      const assigned = this.nextId;
+      this.nextId = assigned === 0xffffffff ? 1 : assigned + 1;
+      this.fingers.set(pointerId, assigned);
+      this.write(assigned, phase, samples.at(-1));
+    } else if (ends) {
+      this.fingers.delete(pointerId);
+      this.write(id, phase, samples.at(-1));
+    } else {
+      for (const sample of samples) {
+        if (this.free() > moveReserve) this.write(id, T.DOLLY_TOUCH_MOVE, sample);
+        else this.dropped++;
+      }
+    }
+    Atomics.notify(this.words, this.address / 4 + word.write);
+    return true;
+  }
+
+  // Tells the kernel whether this page listens: without it no lease is given.
+  enable(enabled) {
+    Atomics.store(this.words, this.address / 4 + word.enabled, enabled ? 1 : 0);
+  }
+}
+
+const phases = { pointerdown: T.DOLLY_TOUCH_DOWN, pointermove: T.DOLLY_TOUCH_MOVE,
+  pointerup: T.DOLLY_TOUCH_UP, pointercancel: T.DOLLY_TOUCH_CANCEL };
+
+// The page's fingers on the canvas. They are taken before input@0's listeners
+// on the canvas see them, and only while a program holds the lease, as the
+// Worker last reported it: without one the terminal's scroll and pinch are
+// input@0's. A finger taken stays this module's until it ends.
+export function browser({ canvas, surfaceSize, send }) {
+  let started = false, lease = 0;
+  const taken = new Set();
+  // Positions are pixels of the frame the canvas shows, as input@0's pointer records are.
+  function sample(event) {
+    const bounds = canvas.getBoundingClientRect(), { width, height } = surfaceSize() ?? canvas;
+    return { x: Math.round(bounds.width === 0 ? 0 : (event.clientX - bounds.left) * width / bounds.width),
+      y: Math.round(bounds.height === 0 ? 0 : (event.clientY - bounds.top) * height / bounds.height),
+      pressure: Math.round(event.pressure * 1000), time: Math.floor(event.timeStamp) };
+  }
+  function listen(event) {
+    if (!started || event.pointerType !== "touch" || event.target !== canvas) return;
+    const phase = phases[event.type], { pointerId } = event;
+    if (phase === T.DOLLY_TOUCH_DOWN) {
+      if (!lease) return;
+      taken.add(pointerId);
+    } else if (!taken.has(pointerId)) return;
+    else if (phase !== T.DOLLY_TOUCH_MOVE) taken.delete(pointerId);
+    const coalesced = phase === T.DOLLY_TOUCH_MOVE ? event.getCoalescedEvents?.() ?? [] : [];
+    send({ type: "touch-finger", phase, pointerId, samples: (coalesced.length ? coalesced : [event]).map(sample) });
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  // A finger held still is a long press, the program's to read, not the page's menu.
+  function menu(event) {
+    if (lease) event.preventDefault();
+  }
+  for (const type of Object.keys(phases)) window.addEventListener(type, listen, { capture: true });
+  canvas.addEventListener("contextmenu", menu);
+  return {
+    page: { get touchTransport() { return started ? { lease: () => lease } : undefined; } },
+    messages: { "touch-lease"(message) { lease = message.lease; } },
+    start() { started = true; },
+    dispose() {
+      for (const type of Object.keys(phases)) window.removeEventListener(type, listen, { capture: true });
+      canvas.removeEventListener("contextmenu", menu);
+      started = false;
+    },
+  };
+}
+
+// The holder's lease is read at each service tick and reported when it changes.
+export function worker({ get, send }) {
+  let transport, stop, reported = 0;
+  return {
+    messages: { "touch-finger"({ phase, pointerId, samples }) { transport?.finger(phase, pointerId, samples); } },
+    service() {
+      const lease = transport?.lease() ?? 0;
+      if (transport && lease !== reported) send({ type: "touch-lease", lease: reported = lease });
+    },
+    start({ kernel, memory }) {
+      const address = Number(kernel.dolly_touch_mailbox_address());
+      transport = new TouchTransport(memory.buffer, address);
+      transport.enable(true);
+      // The finger's records notify the write word: a program waiting for a finger resumes then.
+      stop = get("runtime").serviceOnNotify(transport.words, address / 4 + word.write);
+      return {};
+    },
+    dispose() {
+      transport?.enable(false);
+      transport = undefined;
+      stop?.();
+    },
+  };
+}