substrate-lang 0.10.0 → 0.10.2

package/substrate/host/subhost.mjs

@@ -42,7 +42,10 @@ try {
   if (request.inherit.size > 0) fail('inherit is only for workers');
   setup.grants = joinedGrants(setup.grants, request.grants);
   for (const [name, at] of request.fakes) setup.fakes.set(name, at);
-  if (request.tls) setup.tls = { cert: read(request.tls.cert), key: read(request.tls.key) };
+  if (request.tls) {
+    const files = [request.tls.cert, request.tls.key];
+    setup.tls = { cert: read(files[0]), key: read(files[1]), files };
+  }
 } catch (e) {
   fail(e.message);
 }

package/substrate/host/web/audio.mjs

@@ -14,7 +14,13 @@ export function audio() {
   let started = 0;
 
   const sounds = new Map();
-  let loading = 0;
+  let nextSound = 1;
+  const loading = new Map();
+  const counted = (tag, n) => {
+    const k = (loading.get(tag) || 0) + n;
+    if (k === 0) loading.delete(tag);
+    else loading.set(tag, k);
+  };
   let decoder = null;
 
   const voices = new Map();
@@ -60,35 +66,37 @@ export function audio() {
 
   const module = (caller, app) => ({
     source: SOURCE,
-    load(id, ptr, length) {
+    load(ptr, length, tag) {
+      const id = nextSound++;
       const name = caller.string(ptr, length);
       const bytes = app.files.get(resolvePath(app.cwd, name));
       if (!decoder) decoder = new OfflineAudioContext(1, 1, 44100);
-      loading++;
+      counted(tag, 1);
       const data = bytes
         ? Promise.resolve(bytes.slice().buffer)
-        : fetch(name).then((response) => {
+        : fetch(app.url(name)).then((response) => {
           if (!response.ok) throw new Error(`the server answered ${response.status}`);
           return response.arrayBuffer();
         });
       data.then((buffer) => decoder.decodeAudioData(buffer)).then(
         (decoded) => {
           sounds.set(id, decoded);
-          loading--;
+          counted(tag, -1);
           startWaiting();
-          caller.event(LOADED, id, 0, 0);
+          caller.event(LOADED, id, tag, 0);
         },
         (e) => {
           console.error(`audio: cannot load the sound ${name}: ${e.message}`);
-          loading--;
+          counted(tag, -1);
           startWaiting();
-          caller.event(FAILED, id, 0, e.name === 'EncodingError' ? errors.invalid : errors.missing,
+          caller.event(FAILED, id, tag, e.name === 'EncodingError' ? errors.invalid : errors.missing,
             utf8.encode(`cannot load the sound ${name}: ${e.message}`));
         },
       );
+      return id;
     },
-    loading() {
-      return loading;
+    loading(tag) {
+      return loading.get(tag) || 0;
     },
     play(id, volume, rate, loop) {
       played++;

package/substrate/host/web/audio.sub

@@ -1,4 +1,5 @@
-;; Sound: the host module "audio".
+;; Sound: the host module "audio". audio-load gives the sound's number, and its loaded or failed event goes to tag.
+;; audio-loading counts the sounds loading for a tag.
 (provide audio-source audio-loaded audio-failed audio-tone audio-load audio-loading audio-play audio-stop)
 
 (const audio-source u32 4)
@@ -6,7 +7,12 @@
 (const audio-failed u32 2)
 
 (import audio-tone "audio" "tone" (i32 f64 f64 f64 f64 ->))
-(import audio-load "audio" "load" (i32 i32 i32 ->))
-(import audio-loading "audio" "loading" (-> i32))
+(import load "audio" "load" (i32 i32 i32 -> i32))
+(import loading "audio" "loading" (i32 -> i32))
 (import audio-play "audio" "play" (i32 f64 f64 i32 -> i32))
 (import audio-stop "audio" "stop" (i32 ->))
+
+(define (audio-load [path string] [tag (ptr void)]) -> u32
+  (cast u32 (load (cast i32 (-> path bytes)) (cast i32 (-> path length)) (cast i32 tag))))
+
+(define (audio-loading [tag (ptr void)]) -> u32 (cast u32 (loading (cast i32 tag))))

package/substrate/host/web/dom.mjs

@@ -1,4 +1,4 @@
-// The host module "dom": applies a program's patches to the page, and sends it the page's events.
+// The host module "dom": applies a program's patches to the document, and sends it the document's events.
 import { resolvePath } from './fs.mjs';
 import { errors } from '../errors.mjs';
 
@@ -10,6 +10,9 @@ const HEARD = 1;
 const IMAGE_LOADED = 2;
 const IMAGE_FAILED = 3;
 
+// The document's node number (std/web/patches.sub).
+const DOCUMENT = 1;
+
 const imageTypes = {
   png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp',
   avif: 'image/avif', bmp: 'image/bmp', svg: 'image/svg+xml',
@@ -17,9 +20,14 @@ const imageTypes = {
 
 export function dom(root) {
   const templates = new Map();
-  const nodes = new Map([[0, root]]);
+  const nodes = new Map([[0, root], [DOCUMENT, root.ownerDocument]]);
   const images = new Map();
-  let loading = 0;
+  const loading = new Map();
+  const counted = (tag, n) => {
+    const k = (loading.get(tag) || 0) + n;
+    if (k === 0) loading.delete(tag);
+    else loading.set(tag, k);
+  };
   let app = null;
   let caller = null;
 
@@ -30,6 +38,73 @@ export function dom(root) {
     return e && e.source === SOURCE ? e.data : null;
   };
 
+  const kinds = ['Node', 'Event', 'NodeList', 'HTMLCollection', 'DOMRectReadOnly', 'DOMTokenList',
+    'CSSStyleDeclaration', 'DOMStringMap', 'ValidityState', 'FileList', 'Blob', 'DataTransfer', 'TouchList', 'Touch',
+    'IntersectionObserverEntry'].map((name) => globalThis[name]).filter((kind) => kind !== undefined);
+  const reachable = (x) => kinds.some((kind) => x instanceof kind);
+
+  function guarded(path, f) {
+    try {
+      return f();
+    } catch (e) {
+      caller.trap(`dom: ${path}: ${e.message}`);
+    }
+  }
+
+  function step(x, name, path) {
+    if (!(name in Object(x))) caller.trap(`dom: ${path}: there is no ${name}`);
+    return guarded(path, () => x[name]);
+  }
+
+  function owner(root, path) {
+    const parts = path.split('.');
+    const last = parts.pop();
+    let x = root;
+    for (let k = 0; k < parts.length; k++) {
+      x = step(x, parts[k], path);
+      if (x === null || x === undefined) return [null, last];
+      if (!reachable(x)) {
+        caller.trap(`dom: ${path}: ${parts.slice(0, k + 1).join('.')} is not one of the document's objects`);
+      }
+    }
+    return [x, last];
+  }
+
+  function walk(root, path) {
+    const [x, last] = owner(root, path);
+    return x === null ? null : step(x, last, path);
+  }
+
+  function read(root, path) {
+    const v = walk(root, path);
+    const plain = v === null || v === undefined || ['number', 'string', 'boolean'].includes(typeof v);
+    if (!plain) caller.trap(`dom: ${path} is not a number, text, or true or false`);
+    return v;
+  }
+
+  function write(root, path, value) {
+    const [x, last] = owner(root, path);
+    if (x === null || !(last in x)) caller.trap(`dom: ${path}: there is no ${last} to set`);
+    guarded(path, () => { x[last] = value; });
+  }
+
+  function call(root, path, args) {
+    const [x, last] = owner(root, path);
+    if (x === null || typeof x[last] !== 'function') caller.trap(`dom: ${path} is not a method`);
+    const result = guarded(path, () => x[last](...args));
+    if (result && typeof result.catch === 'function') result.catch(() => {});
+  }
+
+  const numberOf = (v) => (v === null || v === undefined ? 0 : Number(v));
+  const textOf = (v) => (v === null || v === undefined ? '' : String(v));
+
+  const bits = new DataView(new ArrayBuffer(8));
+  const float64 = (low, high) => {
+    bits.setUint32(0, low, true);
+    bits.setUint32(4, high, true);
+    return bits.getFloat64(0, true);
+  };
+
   const listener = (e) => {
     const messages = e.currentTarget.subListeners;
     if (messages && e.type in messages) give(e, messages[e.type]);
@@ -66,12 +141,27 @@ export function dom(root) {
 
   const windowTarget = (type) => (type === 'pointerlockchange' || type === 'pointerlockerror' ? document : window);
 
+  const watched = new Map();
+  let observer = null;
+
+  function watch(node, message) {
+    observer ||= new IntersectionObserver((entries) => {
+      for (const entry of entries) if (watched.has(entry.target)) give(entry, watched.get(entry.target));
+    });
+    watched.set(node, message);
+    observer.observe(node);
+  }
+
   const unlisten = (id) => {
     const n = nodes.get(id);
     if (n instanceof Node && n.subListeners) {
       for (const message of Object.values(n.subListeners)) caller.forget(message);
       n.subListeners = null;
     }
+    if (watched.has(n)) {
+      observer.unobserve(n);
+      watched.delete(n);
+    }
     for (const { type, message, handler } of windowListeners.get(id) || []) {
       windowTarget(type).removeEventListener(type, handler);
       caller.forget(message);
@@ -260,68 +350,75 @@ export function dom(root) {
           const node = nodes.get(w[i + 1]);
           const type = string(i + 2);
           (node.subListeners ||= {})[type] = w[i + 4];
-          node.addEventListener(type, listener);
+          if (type === 'visibility') watch(node, w[i + 4]);
+          else node.addEventListener(type, listener);
           i += 5;
           break;
         }
-        case 10: {
-          const node = nodes.get(w[i + 1]);
-          after.push(() => node.focus());
-          i += 2;
-          break;
-        }
-        case 11: {
-          const node = nodes.get(w[i + 1]);
-          after.push(() => { node.scrollTop = node.scrollHeight; });
-          i += 2;
-          break;
-        }
-        case 12:
+        case 10:
           listenWindow(w[i + 1], string(i + 2), w[i + 4]);
           i += 5;
           break;
-        case 15: {
-          const node = nodes.get(w[i + 1]);
-          if (w[i + 2] !== 0) {
-            after.push(() => { const p = node.requestPointerLock(); if (p && p.catch) p.catch(() => {}); });
-          } else {
-            after.push(() => document.exitPointerLock());
-          }
-          i += 3;
+        case 11: {
+          const canvas = nodes.get(w[i + 1]);
+          const count = w[i + 2];
+          const f = new Float32Array(w.buffer, w.byteOffset, w.length);
+          draw(canvas.getContext('2d'), w, f, i + 3, i + 3 + count, string);
+          i += 3 + count;
           break;
         }
-        case 14: {
+        case 12: {
           const name = string(i + 2);
           const image = new Image();
           const bytes = app.files.get(resolvePath(app.cwd, name));
           const type = imageTypes[name.slice(name.lastIndexOf('.') + 1).toLowerCase()] || '';
-          const url = bytes ? URL.createObjectURL(new Blob([bytes], { type })) : name;
+          const url = bytes ? URL.createObjectURL(new Blob([bytes], { type })) : app.url(name);
           const id = w[i + 1];
+          const tag = w[i + 4];
           const finished = () => {
-            loading--;
+            counted(tag, -1);
             if (bytes) URL.revokeObjectURL(url);
           };
-          loading++;
+          counted(tag, 1);
           image.onload = () => {
             finished();
-            caller.event(IMAGE_LOADED, id, 0, 0);
+            caller.event(IMAGE_LOADED, id, tag, 0);
           };
           image.onerror = () => {
             finished();
             console.error(`dom: cannot load the image ${name}`);
-            caller.event(IMAGE_FAILED, id, 0, errors.missing, utf8.encode(`cannot load the image ${name}`));
+            caller.event(IMAGE_FAILED, id, tag, errors.missing, utf8.encode(`cannot load the image ${name}`));
           };
           image.src = url;
           images.set(w[i + 1], image);
-          i += 4;
+          i += 5;
           break;
         }
         case 13: {
-          const canvas = nodes.get(w[i + 1]);
-          const count = w[i + 2];
-          const f = new Float32Array(w.buffer, w.byteOffset, w.length);
-          draw(canvas.getContext('2d'), w, f, i + 3, i + 3 + count, string);
-          i += 3 + count;
+          const style = document.createElement('style');
+          style.textContent = string(i + 1);
+          root.ownerDocument.head.appendChild(style);
+          i += 3;
+          break;
+        }
+        case 14: {
+          const node = nodeOf(w[i + 1]);
+          const path = string(i + 2);
+          const value = w[i + 4] === 0 ? float64(w[i + 5], w[i + 6]) : string(i + 5);
+          after.push(() => write(node, path, value));
+          i += 7;
+          break;
+        }
+        case 15: {
+          const node = nodeOf(w[i + 1]);
+          const path = string(i + 2);
+          const args = [];
+          for (let k = 0; k < w[i + 4]; k++) {
+            const at = i + 5 + 3 * k;
+            args.push(w[at] === 0 ? float64(w[at + 1], w[at + 2]) : string(at + 1));
+          }
+          after.push(() => call(node, path, args));
+          i += 5 + 3 * w[i + 4];
           break;
         }
         default:
@@ -340,45 +437,49 @@ export function dom(root) {
     caller = theCaller;
     app = theApp;
     const given = (s, out) => caller.give(utf8.encode(s), out);
+    const current = () => {
+      const e = event();
+      if (!e) caller.trap('dom: there is no current event');
+      return e;
+    };
+    const known = (id) => {
+      if (!nodes.has(id)) caller.trap(`dom: there is no node ${id}`);
+      return nodeOf(id);
+    };
     return {
       source: SOURCE,
       apply(ptr, length) {
         apply(caller.memory(), caller.u(ptr), length);
       },
-      event_value(out) {
-        const e = event();
-        const target = e && e.target;
-        return given(target && typeof target.value === 'string' ? target.value : '', out);
+      event_number(ptr, length) {
+        return numberOf(read(current(), caller.string(ptr, length)));
       },
-      event_key(out) {
-        const e = event();
-        return given(e && typeof e.key === 'string' ? e.key : '', out);
+      event_text(ptr, length, out) {
+        return given(textOf(read(current(), caller.string(ptr, length))), out);
       },
-      event_flags() {
-        const e = event();
-        if (!e) return 0;
-        return (e.shiftKey ? 1 : 0) | (e.ctrlKey ? 2 : 0) | (e.altKey ? 4 : 0) | (e.metaKey ? 8 : 0) |
-          (e.target && e.target.checked === true ? 16 : 0) | (document.pointerLockElement ? 32 : 0);
+      event_call(ptr, length) {
+        call(current(), caller.string(ptr, length), []);
       },
-      event_number(which) {
-        const e = event();
-        if (!e) return 0;
-        switch (which) {
-          case 0: return e.timeStamp || 0;
-          case 1: return e.offsetX || 0;
-          case 2: return e.offsetY || 0;
-          case 3: return e.movementX || 0;
-          case 4: return e.movementY || 0;
-          case 5: return e.button || 0;
-          default: return 0;
-        }
+      event_is(node, ptr, length) {
+        return walk(current(), caller.string(ptr, length)) === known(node) ? 1 : 0;
+      },
+      read_number(node, ptr, length) {
+        return numberOf(read(known(node), caller.string(ptr, length)));
+      },
+      read_text(node, ptr, length, out) {
+        return given(textOf(read(known(node), caller.string(ptr, length))), out);
+      },
+      is(node, from, ptr, length) {
+        return walk(known(from), caller.string(ptr, length)) === known(node) ? 1 : 0;
       },
-      images_loading() {
-        return loading;
+      images_loading(tag) {
+        return loading.get(tag) || 0;
       },
-      prevent_default() {
-        const e = event();
-        if (e && e.preventDefault) e.preventDefault();
+      element(ptr, length, node) {
+        const found = root.ownerDocument.getElementById(caller.string(ptr, length));
+        if (!found) return 0;
+        nodes.set(node, found);
+        return 1;
       },
     };
   };

package/substrate/host/web/dom.sub

@@ -1,34 +1,16 @@
-;; The page: the host module "dom". A heard event carries the id and tag its listener was given. dom-event-flags gives
-;; the bits dom-shift to dom-locked. dom-event-number takes one of dom-time, dom-x, dom-y, dom-movement-x,
-;; dom-movement-y and dom-button, and gives that number for the current event.
-(provide dom-source dom-heard dom-image-loaded dom-image-failed
-         dom-shift dom-control dom-alt dom-meta dom-checked dom-locked
-         dom-time dom-x dom-y dom-movement-x dom-movement-y dom-button
-         dom-apply dom-event-value dom-event-key dom-event-flags dom-event-number dom-prevent-default dom-images-loading)
+;; The document: the host module "dom". A heard event carries the id and tag its listener was given. A visibility
+;; listener hears when its element comes into the viewport or leaves it. dom-bind-element gives the element with an id a
+;; node number, for dom-element (std/web/dom.sub). The reads of the document are in std/web/dom.sub too.
+;; dom-images-loading counts the images loading for a tag.
+(provide dom-source dom-heard dom-image-loaded dom-image-failed dom-apply dom-bind-element dom-images-loading)
 
 (const dom-source u32 1)
 (const dom-heard u32 1)
 (const dom-image-loaded u32 2)
 (const dom-image-failed u32 3)
 
-(const dom-shift u32 1)
-(const dom-control u32 2)
-(const dom-alt u32 4)
-(const dom-meta u32 8)
-(const dom-checked u32 16)
-(const dom-locked u32 32)
-
-(const dom-time i32 0)
-(const dom-x i32 1)
-(const dom-y i32 2)
-(const dom-movement-x i32 3)
-(const dom-movement-y i32 4)
-(const dom-button i32 5)
-
 (import dom-apply "dom" "apply" (i32 i32 ->))
-(import dom-event-value "dom" "event_value" (i32 -> i32))
-(import dom-event-key "dom" "event_key" (i32 -> i32))
-(import dom-event-flags "dom" "event_flags" (-> i32))
-(import dom-event-number "dom" "event_number" (i32 -> f64))
-(import dom-prevent-default "dom" "prevent_default" (->))
-(import dom-images-loading "dom" "images_loading" (-> i32))
+(import images-loading "dom" "images_loading" (i32 -> i32))
+(import dom-bind-element "dom" "element" (i32 i32 i32 -> i32))
+
+(define (dom-images-loading [tag (ptr void)]) -> u32 (cast u32 (images-loading (cast i32 tag))))

package/substrate/host/web/fs.mjs

@@ -1,5 +1,5 @@
-// A page's files for fs.mjs, kept in memory under the program's working directory and checked against the program's
-// grants. A directory exists as long as it has a file in it, and there are no links or modes.
+// A web program's files for fs.mjs, kept in memory under the program's working directory and checked against the
+// program's grants. A directory exists as long as it has a file in it, and there are no links or modes.
 import { mayPath, mayTree, pathDenied, unlimited } from '../grants.mjs';
 import { sameFile, tempName } from '../fs.mjs';
 
@@ -17,7 +17,7 @@ const missing = () => Object.assign(new Error('No such file or directory'), { co
 const unsupported = () => new Error('Operation not supported');
 const under = (dir) => (dir === '/' ? '/' : `${dir}/`);
 
-export function pageFiles(files, cwd, grants) {
+export function memoryFiles(files, cwd, grants) {
   const times = new Map();
   const at = (k, p, tree = false) => {
     const key = resolvePath(cwd, p);