@daugasauron/dolly-host-upload 0.0.0-stage → 0.1.4-rc.1

package/README.md

@@ -1,3 +1,4 @@
-# Temporary Holding Version
+# @daugasauron/dolly-host-upload
 
-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 `upload@0` host module: ask for a file; the user picks it. Give the URL of its
+`module.json` to `boot()`'s `modules`; @daugasauron/dolly's README says how.

package/abi.mjs

@@ -0,0 +1,17 @@
+// Generated from host/upload/dolly-upload-0.wat, host/upload/upload.h, include/dolly/process.h.
+export const DOLLY_UPLOAD_HEADER_SIZE = 64;
+export const DOLLY_UPLOAD_WORD_REQUEST = 0;
+export const DOLLY_UPLOAD_WORD_CANCELLED = 1;
+export const DOLLY_UPLOAD_WORD_COMPLETED = 2;
+export const DOLLY_UPLOAD_WORD_CHUNK = 3;
+export const DOLLY_UPLOAD_WORD_CONSUMED = 4;
+export const DOLLY_UPLOAD_WORD_LENGTH = 5;
+export const DOLLY_UPLOAD_WORD_ERROR = 6;
+export const DOLLY_UPLOAD_WORD_EOF = 7;
+export const DOLLY_UPLOAD_WORD_ENABLED = 8;
+export const DOLLY_UPLOAD_WORD_SIZE = 9;
+export const DOLLY_UPLOAD_CHUNK_CAPACITY = 1048576;
+export const DOLLY_UPLOAD_MAX_SIZE = 1073741824;
+export const DOLLY_UPLOAD_FILE = 57;
+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_UPLOAD_ABI_DIGEST = "31e7e9d53cf59e23fc88b4d3d283cb4d9f1a85498628a9137065a476245029fc";

package/module.json

@@ -0,0 +1,14 @@
+{
+  "name": "upload",
+  "version": 0,
+  "gives": "ask for a file; the user picks it",
+  "dependencies": ["runtime@0"],
+  "phase": "image",
+  "imports": [],
+  "host": "upload.mjs",
+  "contracts": ["dolly-upload-0.wat"],
+  "process": [],
+  "headers": ["upload.h", "upload-abi.h"],
+  "kernel": ["kernel.c"],
+  "client": ["client.c"]
+}

package/package.json

@@ -1,6 +1,14 @@
 {
+  "version": "0.1.4-rc.1",
+  "type": "module",
   "name": "@daugasauron/dolly-host-upload",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "license": "MIT",
+  "dependencies": {
+    "@daugasauron/dolly": "0.1.4-rc.1"
+  },
+  "description": "Dolly's upload@0 host module: ask for a file; the user picks it.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daugasauron/dolly.git"
+  }
+}

package/transport.mjs

@@ -0,0 +1,158 @@
+import { DOLLY_ERRNO as errno } from "./abi.mjs";
+import { DOLLY_UPLOAD_CHUNK_CAPACITY as chunkCapacity, DOLLY_UPLOAD_MAX_SIZE, DOLLY_UPLOAD_HEADER_SIZE as headerSize,
+  DOLLY_UPLOAD_WORD_REQUEST as REQUEST, DOLLY_UPLOAD_WORD_CANCELLED as CANCELLED, DOLLY_UPLOAD_WORD_COMPLETED as COMPLETED,
+  DOLLY_UPLOAD_WORD_CHUNK as CHUNK, DOLLY_UPLOAD_WORD_CONSUMED as CONSUMED, DOLLY_UPLOAD_WORD_LENGTH as LENGTH,
+  DOLLY_UPLOAD_WORD_ERROR as ERROR, DOLLY_UPLOAD_WORD_EOF as EOF, DOLLY_UPLOAD_WORD_ENABLED as ENABLED,
+  DOLLY_UPLOAD_WORD_SIZE as SIZE } from "./abi.mjs";
+
+// After the user cancels, requests are refused briefly so the page stays usable.
+export const UPLOAD_CANCEL_QUIET_MILLISECONDS = 2000;
+const mebibytes = bytes => (bytes / 1048576).toFixed(1);
+
+// Mailbox words as dolly-upload-0.wat names them, the Worker's end: user-selected
+// bytes only, one chunk at a time. The browser never receives a path.
+// chooseFile(controller) resolves to the file or null; the user's Cancel aborts
+// the controller, before or during the transfer.
+export class UploadTransport {
+  constructor(buffer, address, chooseFile, showProgress = () => {}) {
+    if (!(buffer instanceof SharedArrayBuffer) || !Number.isSafeInteger(address) ||
+        address <= 0 || address % 4 || address > buffer.byteLength - headerSize - chunkCapacity) {
+      throw new TypeError("invalid upload mailbox");
+    }
+    this.words = new Int32Array(buffer, address, 16);
+    this.bytes = new Uint8Array(buffer, address + headerSize, chunkCapacity);
+    this.chooseFile = chooseFile;
+    this.showProgress = showProgress;
+    this.active = null;
+    this.quietUntil = 0;
+    Atomics.store(this.words, ENABLED, 1);
+  }
+
+  async poll() {
+    const words = this.words;
+    const sequence = Atomics.load(words, REQUEST);
+    if (this.active || sequence === Atomics.load(words, COMPLETED)) return;
+    const controller = new AbortController();
+    // The kernel retired this request (its process ended or a new one began):
+    // the Worker reports it through retire(), which ends any chunk wait.
+    let retire;
+    const retirement = new Promise(resolve => { retire = resolve; });
+    this.active = { sequence, controller, retire };
+    const retired = () => this.retired(sequence);
+    let size = 0;
+    const publish = async (bytes, eof, error = 0) => {
+      // The kernel notifies the consumed word after writing each chunk.
+      for (let consumed; (consumed = Atomics.load(words, CONSUMED)) !== Atomics.load(words, CHUNK);) {
+        if (retired()) return;
+        await Promise.race([Atomics.waitAsync(words, CONSUMED, consumed).value, retirement]);
+      }
+      if (retired()) return;
+      this.bytes.set(bytes);
+      Atomics.store(words, LENGTH, bytes.length);
+      Atomics.store(words, ERROR, error);
+      Atomics.store(words, EOF, eof ? 1 : 0);
+      Atomics.store(words, SIZE, size);
+      Atomics.add(words, CHUNK, 1);
+    };
+    // The user's Cancel, in the picker or during the transfer.
+    const cancel = () => {
+      if (!retired()) this.quietUntil = performance.now() + UPLOAD_CANCEL_QUIET_MILLISECONDS;
+      return publish(new Uint8Array(), true, errno.ECANCELED);
+    };
+    try {
+      if (retired()) return;
+      if (performance.now() < this.quietUntil) {
+        await publish(new Uint8Array(), true, errno.ECANCELED);
+        return;
+      }
+      const file = await this.chooseFile(controller);
+      if (!file) await cancel();
+      else if (!(file instanceof Blob) || file.size > DOLLY_UPLOAD_MAX_SIZE) {
+        await publish(new Uint8Array(), true, errno.EFBIG);
+      } else {
+        // One reused staging buffer: reading allocates nothing per chunk.
+        const reader = file.stream().getReader({ mode: "byob" });
+        let staging = new ArrayBuffer(chunkCapacity), sent = 0;
+        size = file.size;
+        do {
+          const length = Math.min(chunkCapacity, size - sent);
+          for (let filled = 0; filled < length;) {
+            const { value, done } = await reader.read(new Uint8Array(staging, filled, length - filled));
+            if (done) throw new Error("the file changed while uploading");
+            staging = value.buffer;
+            filled += value.length;
+          }
+          if (controller.signal.aborted) {
+            void reader.cancel().catch(() => {});
+            break;
+          }
+          sent += length;
+          await publish(new Uint8Array(staging, 0, length), sent === size);
+          this.showProgress(sent, size);
+        } while (sent < size);
+        if (sent < size) await cancel();
+      }
+    } catch {
+      await publish(new Uint8Array(), true, errno.EIO);
+    } finally {
+      controller.abort();
+      Atomics.store(words, COMPLETED, sequence);
+      this.active = null;
+    }
+  }
+
+  retired(sequence) {
+    return Atomics.load(this.words, REQUEST) !== sequence || Atomics.load(this.words, CANCELLED) === sequence;
+  }
+  retire() {
+    const active = this.active;
+    if (!active || !this.retired(active.sequence)) return;
+    active.retire();
+    active.controller.abort();
+  }
+  close() { Atomics.store(this.words, ENABLED, 0); this.active?.controller.abort(); }
+}
+
+// One modal dialog per request: the picker, then progress until the transfer ends.
+export function chooseUploadFile(controller) {
+  return new Promise(resolve => {
+    const { signal } = controller;
+    if (signal.aborted) { resolve(null); return; }
+    const dialog = document.createElement("dialog");
+    dialog.id = "file-upload";
+    dialog.innerHTML = `<style>#file-upload { color: #e8e3d7; background: #262626; border: 1px solid #77736c;
+        max-width: calc(100vw - 2rem); font: inherit; } #file-upload::backdrop { background: #0008; }
+      #file-upload input, #file-upload button { font: inherit; }</style>
+      <form method="dialog"><p>Upload one file into Dolly</p>
+      <p>Up to ${DOLLY_UPLOAD_MAX_SIZE / 1073741824} GiB. Only the file you choose enters the sandbox.</p>
+      <input type="file" aria-label="Choose file to upload"><progress hidden></progress>
+      <output></output><button>Cancel</button></form>`;
+    const cancel = event => { event?.preventDefault(); controller.abort(); };
+    dialog.addEventListener("cancel", cancel);
+    dialog.querySelector("form").addEventListener("submit", cancel);
+    const [title, note] = dialog.querySelectorAll("p");
+    const input = dialog.querySelector("input");
+    input.addEventListener("cancel", cancel);
+    input.addEventListener("change", () => {
+      const file = input.files[0];
+      if (!file) { cancel(); return; }
+      title.textContent = `Uploading ${file.name}`;
+      note.hidden = input.hidden = true;
+      dialog.querySelector("progress").hidden = false;
+      showUploadProgress(0, file.size);
+      resolve(file);
+    });
+    signal.addEventListener("abort", () => { dialog.close(); dialog.remove(); resolve(null); }, { once: true });
+    document.body.append(dialog);
+    if (document.pointerLockElement) document.exitPointerLock();
+    dialog.showModal();
+  });
+}
+
+export function showUploadProgress(sent, size) {
+  const progress = document.querySelector("#file-upload progress");
+  if (!progress) return;
+  progress.max = size;
+  progress.value = sent;
+  document.querySelector("#file-upload output").textContent = `${mebibytes(sent)} of ${mebibytes(size)} MiB`;
+}

package/upload.mjs

@@ -0,0 +1,65 @@
+import { UploadTransport, chooseUploadFile, showUploadProgress } from "./transport.mjs";
+import { DOLLY_UPLOAD_WORD_REQUEST, DOLLY_UPLOAD_WORD_CANCELLED } from "./abi.mjs";
+export { DOLLY_UPLOAD_ABI_DIGEST as digest } from "./abi.mjs";
+
+// The page shows the picker and the progress; the Worker asks for a file,
+// reads it and writes it into the mailbox. The user's Cancel reaches the
+// Worker, and the Worker's end of a transfer closes the dialog.
+export function browser({ send }) {
+  let controller = null;
+  return {
+    messages: {
+      "upload-choose"() {
+        const current = controller = new AbortController();
+        current.signal.addEventListener("abort", () => {
+          if (controller !== current) return;
+          controller = null;
+          send({ type: "upload-cancel" });
+        }, { once: true });
+        return chooseUploadFile(current);
+      },
+      "upload-progress"({ sent, size }) { showUploadProgress(sent, size); },
+      "upload-close"() {
+        const current = controller;
+        controller = null;
+        current?.abort();
+      },
+    },
+    // The open dialog takes every key; the interrupt key still interrupts the program that asked.
+    claimsKey: () => document.querySelector("#file-upload[open]") ? "interrupt" : false,
+    dispose() { controller?.abort(); },
+  };
+}
+
+// The kernel's mailbox reports each new request and each retired one (its
+// process ended or cancelled) at the service tick.
+export function worker({ send, ask }) {
+  let transport, reported, retired;
+  function choose(controller) {
+    controller.signal.addEventListener("abort", () => send({ type: "upload-close" }), { once: true });
+    return ask({ type: "upload-choose" });
+  }
+  return {
+    messages: { "upload-cancel"() { transport?.active?.controller.abort(); } },
+    service() {
+      if (!transport) return;
+      const { words } = transport;
+      const request = Atomics.load(words, DOLLY_UPLOAD_WORD_REQUEST), cancelled = Atomics.load(words, DOLLY_UPLOAD_WORD_CANCELLED);
+      if (request !== reported) {
+        reported = request;
+        void transport.poll();
+      }
+      if (cancelled !== retired) {
+        retired = cancelled;
+        transport.retire();
+      }
+    },
+    start({ kernel, memory }) {
+      transport = new UploadTransport(memory.buffer, Number(kernel.dolly_upload_mailbox_address()), choose,
+        (sent, size) => send({ type: "upload-progress", sent, size }));
+      reported = Atomics.load(transport.words, DOLLY_UPLOAD_WORD_REQUEST);
+      retired = Atomics.load(transport.words, DOLLY_UPLOAD_WORD_CANCELLED);
+    },
+    dispose() { transport?.close(); },
+  };
+}