substrate-lang 0.9.3 → 0.10.0

package/substrate/host/node/env.sub

@@ -1,8 +1,7 @@
-;; Environment variables: the host module "env". env-get stores a variable's value at value and returns #t, or returns
-;; #f when it is not set or not granted, with the reason at err. env-set and env-delete change the caller's environment
-;; and return 0, or -1 with the reason at err. Programs the caller runs and workers it starts afterwards see the change;
-;; each gets a copy of the caller's environment when it starts. env-list stores the variables -E grants at into,
-;; NAME=VALUE, in name order, as Deno's toObject does, and returns 0, or -1 without -E.
+;; Environment variables: the host module "env". env-get stores a variable's value at value, and fails when the
+;; variable is not set. env-set and env-delete change the caller's environment. Programs the caller runs and workers it
+;; starts afterwards see the change; each gets a copy of the caller's environment when it starts. env-list stores the
+;; variables -E grants at into, NAME=VALUE, in name order, as Deno's toObject does.
 (provide env-get env-set env-delete env-list)
 
 (import get "env" "get" (i32 i32 i32 i32 -> i32))
@@ -10,19 +9,25 @@
 (import drop "env" "delete" (i32 i32 i32 -> i32))
 (import listed "env" "list" (i32 i32 -> i32))
 
-(define (env-get [name string] [value (ptr string)] [err (ptr string)]) -> bool
-  (let* ([n u32 0] [p (get (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (& n)) (cast i32 err))])
+(define (env-get [name string] [value (ptr string)] [err (ptr error)]) -> bool
+  (let* ([why string] [n u32 0]
+         [p (get (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (& n)) (cast i32 (& why)))])
     (set! (@ value) (cast string (slice (cast (ptr u8) p) n)))
-    (!= p 0)))
+    (or (!= p 0) (host-failed! (& why) err))))
 
-(define (env-set [name string] [value string] [err (ptr string)]) -> i32
-  (put (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (-> value bytes)) (cast i32 (-> value length))
-       (cast i32 err)))
+(define (env-set [name string] [value string] [err (ptr error)]) -> bool
+  (let ([why string])
+    (or (== (put (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (-> value bytes))
+                 (cast i32 (-> value length)) (cast i32 (& why)))
+            0)
+        (host-failed! (& why) err))))
 
-(define (env-delete [name string] [err (ptr string)]) -> i32
-  (drop (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 err)))
+(define (env-delete [name string] [err (ptr error)]) -> bool
+  (let ([why string])
+    (or (== (drop (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (& why))) 0)
+        (host-failed! (& why) err))))
 
-(define (env-list [into (ptr (slice string))] [err (ptr string)]) -> i32
-  (let* ([n u32 0] [p (listed (cast i32 (& n)) (cast i32 err))])
+(define (env-list [into (ptr (slice string))] [err (ptr error)]) -> bool
+  (let* ([why string] [n u32 0] [p (listed (cast i32 (& n)) (cast i32 (& why)))])
     (set! (@ into) (entry-strings (cast (ptr u8) p) n))
-    (if (== p 0) -1 0)))
+    (or (!= p 0) (host-failed! (& why) err))))

package/substrate/host/node/fs.mjs

@@ -20,7 +20,7 @@ const plain = (f) => (...args) => {
     return f(...args);
   } catch (e) {
     if (typeof e.errno !== 'number') throw e;
-    throw new Error(plainMessage(e));
+    throw Object.assign(new Error(plainMessage(e)), { code: e.code });
   }
 };
 

package/substrate/host/node/net.mjs

@@ -50,7 +50,7 @@ export function netModule(grants, certificate) {
             });
           } else server.listen(port, host);
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return 0;
         }
         id = next++;
@@ -81,7 +81,7 @@ export function netModule(grants, certificate) {
             ? tls.connect({ host, port, servername, ca, allowHalfOpen: true, lookup })
             : net.connect({ host, port, allowHalfOpen: true, lookup });
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return 0;
         }
         let connected = false;

package/substrate/host/node/net.sub

@@ -14,12 +14,19 @@
 (const net-connected u32 3)
 (const net-failed u32 4)
 
-(define (net-listen [port u32] [host string] [secure bool] [most u32] [tag (ptr void)] [err (ptr string)]) -> u32
-  (cast u32 (listen (cast i32 port) (cast i32 (-> host bytes)) (cast i32 (-> host length)) secure (cast i32 most)
-                    (cast i32 tag) (cast i32 err))))
+(define (net-listen [port u32] [host string] [secure bool] [most u32] [tag (ptr void)] [id (ptr u32)]
+                    [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (listen (cast i32 port) (cast i32 (-> host bytes)) (cast i32 (-> host length)) secure
+                              (cast i32 most) (cast i32 tag) (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
-(define (net-connect [port u32] [host string] [secure bool] [tag (ptr void)] [err (ptr string)]) -> u32
-  (cast u32 (connect (cast i32 port) (cast i32 (-> host bytes)) (cast i32 (-> host length)) secure (cast i32 tag)
-                     (cast i32 err))))
+(define (net-connect [port u32] [host string] [secure bool] [tag (ptr void)] [id (ptr u32)] [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (connect (cast i32 port) (cast i32 (-> host bytes)) (cast i32 (-> host length)) secure
+                               (cast i32 tag) (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (net-close [id u32]) (close (cast i32 id)))

package/substrate/host/node/process.mjs

@@ -84,7 +84,7 @@ export function processes(grants, loader, setup = {}) {
           const l = launched(file ?? program, entries(caller.string(ap, al)));
           process = child.spawn(l.command, l.args, { cwd, env, stdio: modes });
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return 0;
         }
         const id = next++;
@@ -130,7 +130,7 @@ export function processes(grants, loader, setup = {}) {
           new DataView(caller.memory().buffer).setUint32(caller.u(op), p, true);
           return r.status !== null ? r.status : 128 + (os.constants.signals[r.signal] || 0);
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return -1;
         } finally {
           if (dir) fs.rmSync(dir, { recursive: true, force: true });
@@ -146,7 +146,7 @@ export function processes(grants, loader, setup = {}) {
           const l = launched(file ?? program, entries(caller.string(ap, al)), program);
           become(l.command, [l.argv0, ...l.args], env);
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
         }
         return -1;
       },
@@ -161,7 +161,7 @@ export function processes(grants, loader, setup = {}) {
           const l = launched(file ?? program, entries(caller.string(ap, al)), program);
           setup.atEnd = { file: l.command, argv: [l.argv0, ...l.args], env };
         } catch (e) {
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return -1;
         }
         return 0;

package/substrate/host/node/process.sub

@@ -20,11 +20,10 @@
 (const process-source u32 10)
 (const process-exit u32 1)
 (const process-failed u32 2)
-(const process-pipe i32 0)
-(const process-ignore i32 1)
-(const process-inherit i32 2)
+(enum process-stdio process-pipe process-ignore process-inherit)
 
-(struct process-options [dir string] [env (slice string)] [clear bool] [stdin i32] [stdout i32] [stderr i32])
+(struct process-options [dir string] [env (slice string)] [clear bool] [stdin process-stdio] [stdout process-stdio]
+        [stderr process-stdio])
 
 (define (process-options-init! [o (ptr process-options)])
   (set! (-> o dir) "")
@@ -34,54 +33,55 @@
   (set! (-> o stdout) process-pipe)
   (set! (-> o stderr) process-pipe))
 
-(define (process-spawn [program string] [args (slice string)] [o (ptr process-options)] [tag (ptr void)]
-                       [err (ptr string)]) -> u32
-  (let ([defaults process-options] [p o] [a (make-buffer)] [e (make-buffer)] [id u32 0])
+(define (process-spawn [program string] [args (slice string)] [o (ptr process-options)] [tag (ptr void)] [id (ptr u32)]
+                       [err (ptr error)]) -> bool
+  (let ([defaults process-options] [p o] [a (make-buffer)] [e (make-buffer)] [why string] [n u32 0])
     (when (== p 0)
       (process-options-init! (& defaults))
       (set! p (& defaults)))
     (buffer-add-entries! (& a) args)
     (buffer-add-entries! (& e) (-> p env))
-    (set! id (cast u32 (spawn (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes))
-                              (cast i32 (-> a length)) (cast i32 (-> p dir bytes)) (cast i32 (-> p dir length))
-                              (cast i32 (-> e bytes)) (cast i32 (-> e length)) (-> p clear) (-> p stdin) (-> p stdout)
-                              (-> p stderr) (cast i32 tag) (cast i32 err))))
+    (set! n (cast u32 (spawn (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes))
+                             (cast i32 (-> a length)) (cast i32 (-> p dir bytes)) (cast i32 (-> p dir length))
+                             (cast i32 (-> e bytes)) (cast i32 (-> e length)) (-> p clear) (cast i32 (-> p stdin))
+                             (cast i32 (-> p stdout)) (cast i32 (-> p stderr)) (cast i32 tag) (cast i32 (& why)))))
     (buffer-free! (& a))
     (buffer-free! (& e))
-    id))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (process-run [program string] [args (slice string)] [o (ptr process-options)] [input (slice u8)] [timeout u32]
-                     [output (ptr (slice u8))] [err (ptr string)]) -> i32
-  (let ([defaults process-options] [p o] [a (make-buffer)] [e (make-buffer)] [code i32 0])
+                     [output (ptr (slice u8))] [status (ptr i32)] [err (ptr error)]) -> bool
+  (let ([defaults process-options] [p o] [a (make-buffer)] [e (make-buffer)] [why string])
     (when (== p 0)
       (process-options-init! (& defaults))
       (set! p (& defaults)))
     (set! (@ output) (slice (cast (ptr u8) 0) 0))
     (buffer-add-entries! (& a) args)
     (buffer-add-entries! (& e) (-> p env))
-    (set! code (run (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes)) (cast i32 (-> a length))
-                    (cast i32 (-> p dir bytes)) (cast i32 (-> p dir length)) (cast i32 (-> e bytes)) (cast i32 (-> e length))
-                    (-> p clear) (cast i32 (-> input items)) (cast i32 (-> input length)) (cast i32 timeout)
-                    (cast i32 output) (cast i32 err)))
+    (set! (@ status) (run (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes))
+                          (cast i32 (-> a length)) (cast i32 (-> p dir bytes)) (cast i32 (-> p dir length))
+                          (cast i32 (-> e bytes)) (cast i32 (-> e length)) (-> p clear) (cast i32 (-> input items))
+                          (cast i32 (-> input length)) (cast i32 timeout) (cast i32 output) (cast i32 (& why))))
     (buffer-free! (& a))
     (buffer-free! (& e))
-    code))
+    (or (>= (@ status) 0) (host-failed! (& why) err))))
 
-(define (process-exec [program string] [args (slice string)] [err (ptr string)]) -> i32
-  (let ([a (make-buffer)] [r i32 0])
+(define (process-exec [program string] [args (slice string)] [err (ptr error)]) -> bool
+  (let ([a (make-buffer)] [why string])
     (buffer-add-entries! (& a) args)
-    (set! r (exec (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes)) (cast i32 (-> a length))
-                  (cast i32 err)))
+    (exec (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes)) (cast i32 (-> a length))
+          (cast i32 (& why)))
     (buffer-free! (& a))
-    r))
+    (host-failed! (& why) err)))
 
-(define (process-exec-at-end [program string] [args (slice string)] [err (ptr string)]) -> i32
-  (let ([a (make-buffer)] [r i32 0])
+(define (process-exec-at-end [program string] [args (slice string)] [err (ptr error)]) -> bool
+  (let ([a (make-buffer)] [r i32 0] [why string])
     (buffer-add-entries! (& a) args)
     (set! r (exec-at-end (cast i32 (-> program bytes)) (cast i32 (-> program length)) (cast i32 (-> a bytes))
-                         (cast i32 (-> a length)) (cast i32 err)))
+                         (cast i32 (-> a length)) (cast i32 (& why))))
     (buffer-free! (& a))
-    r))
+    (or (== r 0) (host-failed! (& why) err))))
 
 (define (process-stdin [id u32]) -> u32 (cast u32 (stdin (cast i32 id))))
 

package/substrate/host/node/signal.mjs

@@ -1,5 +1,6 @@
 // The host module "signal" (signal.sub) on Node.
 import os from 'node:os';
+import { errors } from '../errors.mjs';
 
 const SOURCE = 16;
 const RECEIVED = 1;
@@ -18,11 +19,11 @@ export function signals() {
     listen(np, nl, tag, err) {
       const name = caller.string(np, nl);
       if (!Object.hasOwn(os.constants.signals, name)) {
-        caller.fail(err, `signal.listen: ${name} is not a signal`);
+        caller.fail(err, `signal.listen: ${name} is not a signal`, errors.invalid);
         return 0;
       }
       if (forbidden.has(name)) {
-        caller.fail(err, `signal.listen: ${name} cannot be listened for`);
+        caller.fail(err, `signal.listen: ${name} cannot be listened for`, errors.invalid);
         return 0;
       }
       const id = next++;

package/substrate/host/node/signal.sub

@@ -1,8 +1,7 @@
 ;; Signals to the program: the host module "signal", after Deno's addSignalListener. signal-listen listens for the
-;; signal named, such as "SIGINT" or "SIGTERM", and returns the listener's number, or 0 with the reason at err; while
-;; any listener is there, the signal no longer ends the program, and a listener alone does not keep it running. A
-;; received event comes each time the signal arrives. SIGKILL, SIGSTOP, SIGILL, SIGFPE and SIGSEGV cannot be listened
-;; for, and a worker has no signals.
+;; signal named, such as "SIGINT" or "SIGTERM". While any listener is there, the signal no longer ends the program, and
+;; a listener alone does not keep it running. A received event comes each time the signal arrives. SIGKILL, SIGSTOP,
+;; SIGILL, SIGFPE and SIGSEGV cannot be listened for, and a worker has no signals.
 (provide signal-source signal-received signal-listen signal-stop)
 
 (import listen "signal" "listen" (i32 i32 i32 i32 -> i32))
@@ -11,7 +10,11 @@
 (const signal-source u32 16)
 (const signal-received u32 1)
 
-(define (signal-listen [name string] [tag (ptr void)] [err (ptr string)]) -> u32
-  (cast u32 (listen (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 tag) (cast i32 err))))
+(define (signal-listen [name string] [tag (ptr void)] [id (ptr u32)] [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (listen (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 tag)
+                              (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (signal-stop [id u32]) (stop (cast i32 id)))

package/substrate/host/node/watch.mjs

@@ -60,7 +60,7 @@ export function watchModule(grants) {
         return id;
       } catch (e) {
         close(w);
-        caller.fail(err, `watch.start: ${at}: ${plainMessage(e)}`);
+        caller.fail(err, `watch.start: ${at}: ${plainMessage(e)}`, errorOf(e));
         return 0;
       }
     },

package/substrate/host/node/watch.sub

@@ -1,8 +1,7 @@
 ;; Watching files: the host module "watch", after Deno's watchFs. watch-start watches the paths, and everything under
-;; them unless the options' recursive is #f, and returns the watch's number, or 0 with the reason at err. A changed
-;; event's value is watch-create, watch-modify or watch-remove, and its bytes are the absolute paths it is about, as
-;; entries; a rename comes as a remove and a create. Changes under the options' ignore paths are left out. A failed
-;; event ends the watch.
+;; them unless the options' recursive is #f. A changed event's value is watch-create, watch-modify or watch-remove, and
+;; its bytes are the absolute paths it is about, as entries; a rename comes as a remove and a create. Changes under the
+;; options' ignore paths are left out. A failed event ends the watch.
 (provide watch-source watch-changed watch-failed watch-create watch-modify watch-remove watch-options
          watch-options-init! watch-start watch-stop)
 
@@ -23,17 +22,20 @@
   (set! (-> o recursive) #t)
   (set! (-> o ignore) 0))
 
-(define (watch-start [paths (slice string)] [o (ptr watch-options)] [tag (ptr void)] [err (ptr string)]) -> u32
-  (let ([defaults watch-options] [p o] [watched (make-buffer)] [ignored (make-buffer)] [id u32 0])
+(define (watch-start [paths (slice string)] [o (ptr watch-options)] [tag (ptr void)] [id (ptr u32)] [err (ptr error)])
+  -> bool
+  (let ([defaults watch-options] [p o] [watched (make-buffer)] [ignored (make-buffer)] [why string] [n u32 0])
     (when (== p 0)
       (watch-options-init! (& defaults))
       (set! p (& defaults)))
     (buffer-add-entries! (& watched) paths)
     (buffer-add-entries! (& ignored) (-> p ignore))
-    (set! id (cast u32 (start (cast i32 (-> watched bytes)) (cast i32 (-> watched length)) (-> p recursive)
-                              (cast i32 (-> ignored bytes)) (cast i32 (-> ignored length)) (cast i32 tag) (cast i32 err))))
+    (set! n (cast u32 (start (cast i32 (-> watched bytes)) (cast i32 (-> watched length)) (-> p recursive)
+                             (cast i32 (-> ignored bytes)) (cast i32 (-> ignored length)) (cast i32 tag)
+                             (cast i32 (& why)))))
     (buffer-free! (& watched))
     (buffer-free! (& ignored))
-    id))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (watch-stop [w u32]) (stop (cast i32 w)))

package/substrate/host/stream.sub

@@ -1,6 +1,8 @@
 ;; Byte streams: the host module "stream", whose ids other modules give out. A read event's value is how many bytes
 ;; were read, or 0 at the end. A read that stream-take! posts holds no room: its event carries the bytes, at most
 ;; most of them, for events-take. A finished event comes once everything written before stream-finish has been sent.
+;; stream-write returns 0 when the stream can take more, and 1 when it is full. It takes the bytes in both cases. After
+;; a 1, wait for a drained event before writing again. It returns -1 when the stream is not open.
 (require-unqualified "events.sub")
 
 (provide stream-source stream-read stream-drained stream-failed stream-finished

package/substrate/host/subhost-core.mjs

@@ -1,6 +1,7 @@
 // The JavaScript host, shared by Node (subhost.mjs) and the browser (web/subhost-web.mjs).
 import { createStreams, STREAM } from './streams.mjs';
 import { joined } from './entries.mjs';
+import { errors } from './errors.mjs';
 
 const utf8 = new TextEncoder();
 const text = new TextDecoder();
@@ -174,6 +175,7 @@ export function createHost(platform) {
   // A memory's malloc, from the module that exports both.
   const allocators = new WeakMap();
   let lastError = '';
+  let failureCode = errors.other;
   // The running program: its module names in load order, a function that returns a module's bytes, and the files of
   // the compiled modules its build wrote, keyed by file name (null if it wrote none).
   let programNames = [];
@@ -330,7 +332,8 @@ export function createHost(platform) {
       trap: hostTrap,
       write: (fd, bytes) => platform.write(fd === 2 ? 2 : 1, bytes),
       give,
-      fail(err, message) {
+      fail(err, message, code = errors.other) {
+        failureCode = code;
         if (!err) return;
         const p = give(utf8.encode(message), u(err) + 4);
         new DataView(memory().buffer).setUint32(u(err), p, true);
@@ -377,6 +380,11 @@ export function createHost(platform) {
         platform.write(fd === 2 ? 2 : 1, memory().subarray(u(ptr), u(ptr) + len));
         return len;
       },
+      failure_code() {
+        const code = failureCode;
+        failureCode = errors.other;
+        return code;
+      },
       trap(ptr, len) {
         hostTrap(string(ptr, len));
       },

package/substrate/host/web/clipboard.mjs

@@ -1,5 +1,5 @@
 // The host module "clipboard" (clipboard.sub).
-import { errorOf, reasonOf } from '../errors.mjs';
+import { errors, errorOf, reasonOf } from '../errors.mjs';
 
 const utf8 = new TextEncoder();
 
@@ -14,7 +14,7 @@ export function clipboard() {
     let ended = false;
     const attempt = (tag, err, ask, answer) => {
       if (!navigator.clipboard) {
-        caller.fail(err, 'clipboard: none');
+        caller.fail(err, 'clipboard: none', errors.other);
         return 0;
       }
       const id = next++;

package/substrate/host/web/clipboard.sub

@@ -9,7 +9,14 @@
 (const clipboard-written u32 2)
 (const clipboard-failed u32 3)
 
-(define (clipboard-read [tag (ptr void)] [err (ptr string)]) -> u32 (cast u32 (read (cast i32 tag) (cast i32 err))))
+(define (clipboard-read [tag (ptr void)] [id (ptr u32)] [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (read (cast i32 tag) (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
-(define (clipboard-write [text string] [tag (ptr void)] [err (ptr string)]) -> u32
-  (cast u32 (write (cast i32 (-> text bytes)) (cast i32 (-> text length)) (cast i32 tag) (cast i32 err))))
+(define (clipboard-write [text string] [tag (ptr void)] [id (ptr u32)] [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (write (cast i32 (-> text bytes)) (cast i32 (-> text length)) (cast i32 tag) (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))

package/substrate/host/web/files.mjs

@@ -1,5 +1,5 @@
 // The host module "files" (files.sub).
-import { errors } from '../errors.mjs';
+import { errors, errorOf } from '../errors.mjs';
 import { readerSource } from '../streams.mjs';
 
 const utf8 = new TextEncoder();
@@ -43,7 +43,7 @@ export function files() {
           input.showPicker();
         } catch (e) {
           input.remove();
-          caller.fail(err, e.message);
+          caller.fail(err, e.message, errorOf(e));
           return 0;
         }
         return id;

package/substrate/host/web/files.sub

@@ -10,8 +10,12 @@
 (const files-picked u32 2)
 (const files-failed u32 3)
 
-(define (files-pick [multiple bool] [accept string] [tag (ptr void)] [err (ptr string)]) -> u32
-  (cast u32 (pick multiple (cast i32 (-> accept bytes)) (cast i32 (-> accept length)) (cast i32 tag) (cast i32 err))))
+(define (files-pick [multiple bool] [accept string] [tag (ptr void)] [id (ptr u32)] [err (ptr error)]) -> bool
+  (let ([why string] [n u32 0])
+    (set! n (cast u32 (pick multiple (cast i32 (-> accept bytes)) (cast i32 (-> accept length)) (cast i32 tag)
+                            (cast i32 (& why)))))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (files-save [name string] [b (slice u8)])
   (save (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (-> b items)) (cast i32 (-> b length))))

package/substrate/host/web/fs.mjs

@@ -13,7 +13,7 @@ export function resolvePath(cwd, path) {
   return `/${out.join('/')}`;
 }
 
-const missing = () => new Error('No such file or directory');
+const missing = () => Object.assign(new Error('No such file or directory'), { code: 'ENOENT' });
 const unsupported = () => new Error('Operation not supported');
 const under = (dir) => (dir === '/' ? '/' : `${dir}/`);
 
@@ -142,7 +142,7 @@ export function pageFiles(files, cwd, grants) {
     },
     readLink(p) {
       info(at('read', p));
-      throw new Error('Invalid argument');
+      throw Object.assign(new Error('Invalid argument'), { code: 'EINVAL' });
     },
     realPath(p) {
       const key = at('read', p);
@@ -180,7 +180,7 @@ export function pageFiles(files, cwd, grants) {
       const key = at(changes ? 'write' : 'read', p);
       if (how.read && changes) at('read', p);
       if (files.has(key)) {
-        if (how.createNew) throw new Error('File already exists');
+        if (how.createNew) throw Object.assign(new Error('File already exists'), { code: 'EEXIST' });
       } else if (inside(key).length > 0) {
         throw new Error('Illegal operation on a directory');
       } else if (how.create || how.createNew) {

package/substrate/host/web/location.mjs

@@ -1,4 +1,6 @@
 // The host module "location" (location.sub).
+import { errorOf } from '../errors.mjs';
+
 const utf8 = new TextEncoder();
 
 const SOURCE = 12;
@@ -13,7 +15,7 @@ export function locationModule() {
         go(caller.string(ptr, len));
         return 0;
       } catch (e) {
-        caller.fail(err, e.message);
+        caller.fail(err, e.message, errorOf(e));
         return -1;
       }
     };

package/substrate/host/web/location.sub

@@ -12,10 +12,14 @@
 
 (define (location-get) -> string (let* ([n u32 0] [p (get (cast i32 (& n)))]) (cast string (slice (cast (ptr u8) p) n))))
 
-(define (location-push [url string] [err (ptr string)]) -> i32
-  (push (cast i32 (-> url bytes)) (cast i32 (-> url length)) (cast i32 err)))
+(define (location-push [url string] [err (ptr error)]) -> bool
+  (let ([why string])
+    (or (== (push (cast i32 (-> url bytes)) (cast i32 (-> url length)) (cast i32 (& why))) 0)
+        (host-failed! (& why) err))))
 
-(define (location-replace [url string] [err (ptr string)]) -> i32
-  (replace (cast i32 (-> url bytes)) (cast i32 (-> url length)) (cast i32 err)))
+(define (location-replace [url string] [err (ptr error)]) -> bool
+  (let ([why string])
+    (or (== (replace (cast i32 (-> url bytes)) (cast i32 (-> url length)) (cast i32 (& why))) 0)
+        (host-failed! (& why) err))))
 
 (define (location-back) (back))

package/substrate/host/worker-side.mjs

@@ -1,5 +1,7 @@
 // The worker module's side inside a worker, in a browser or on Node. It batches output, delivers the parent's
 // messages as events, and reports back.
+import { errors } from './errors.mjs';
+
 const utf8 = new TextEncoder();
 
 const SOURCE = 3;
@@ -72,7 +74,7 @@ export function workerSide(post) {
   const worker = (caller) => ({
     source: SOURCE,
     start(f, bp, bl, time, size, heard, tag, gp, gl, err) {
-      caller.fail(err, 'worker.start: a worker cannot start workers');
+      caller.fail(err, 'worker.start: a worker cannot start workers', errors.invalid);
       return 0;
     },
     send(w, ptr, length) {

package/substrate/host/worker.mjs

@@ -1,6 +1,7 @@
 // The host module "worker" (worker.sub). The browser and Node each give spawn, their way of starting a thread.
 import { entries } from './entries.mjs';
-import { askedOf, mayTree, within } from './grants.mjs';
+import { errors, errorOf } from './errors.mjs';
+import { askedOf, mayTree, notGranted, within } from './grants.mjs';
 
 const utf8 = new TextEncoder();
 
@@ -69,7 +70,7 @@ export function workerModule({ spawn }) {
       thread = spawn({ modules, compiled, entry, argument, grants, names: caller.moduleNames(), pages, heard, ...setup },
                      app);
     } catch (e) {
-      caller.fail(err, e.message);
+      caller.fail(err, e.message, errorOf(e));
       return 0;
     }
     const w = nextNumber++;
@@ -100,7 +101,7 @@ export function workerModule({ spawn }) {
       start(f, bp, bl, time, size, heard, tag, gp, gl, err, ends, ap, al) {
         const entry = caller.named(f >>> 0);
         if (!entry) {
-          caller.fail(err, 'worker.start: a function of code the program loaded');
+          caller.fail(err, 'worker.start: a function of code the program loaded', errors.invalid);
           return 0;
         }
         const pages = Math.ceil((size >>> 0) / 65536);
@@ -113,11 +114,11 @@ export function workerModule({ spawn }) {
           const parent = caller.grants();
           const files = caller.parseGrants(read.flatMap((file) => ['read', file])).grants.read.items;
           for (const file of files) {
-            if (!mayTree(parent.read, file)) throw new Error(`read ${file} reaches beyond the parent's grants`);
+            if (!mayTree(parent.read, file)) throw notGranted(`read ${file} reaches beyond the parent's grants`);
           }
           grants = within(askedOf(request, parent), parent);
         } catch (e) {
-          caller.fail(err, `worker.start: ${e.message}`);
+          caller.fail(err, `worker.start: ${e.message}`, errorOf(e));
           return 0;
         }
         const args = al > 0 ? entries(string(ap, al)) : null;

package/substrate/host/worker.sub

@@ -1,6 +1,5 @@
 ;; Workers: functions of this program, each running on its own thread and sharing only messages. worker-start runs one
-;; of the program's own functions with the bytes as its argument 0, and returns the worker's number, or 0 with the
-;; reason at err. Its options:
+;; of the program's own functions with the bytes as its argument 0. Its options:
 ;;   time, memory  limits in ms for each stretch of work and in bytes, or 0 for none
 ;;   output        the worker's stdout and stderr come as events
 ;;   grants        the worker's grants (grants.sub), within the parent's and by default the parent's own
@@ -41,22 +40,23 @@
   (set! (-> o grants) (make-grants))
   (grants-inherit! (& (-> o grants))))
 
-(define (worker-start [function (fn ())] [argument (slice u8)] [o (ptr worker-options)] [tag (ptr void)]
-                      [err (ptr string)]) -> u32
-  (let ([defaults worker-options] [p o] [entries (make-buffer)] [args (make-buffer)] [id u32 0])
+(define (worker-start [function (fn ())] [argument (slice u8)] [o (ptr worker-options)] [tag (ptr void)] [id (ptr u32)]
+                      [err (ptr error)]) -> bool
+  (let ([defaults worker-options] [p o] [entries (make-buffer)] [args (make-buffer)] [why string] [n u32 0])
     (when (== p 0)
       (worker-options-init! (& defaults))
       (set! p (& defaults)))
     (grants-entries! (& entries) (& (-> p grants)))
     (buffer-add-entries! (& args) (-> p args))
-    (set! id (cast u32 (start (cast i32 function) (cast i32 (-> argument items)) (cast i32 (-> argument length))
-                              (cast i32 (-> p time)) (cast i32 (-> p memory)) (-> p output) (cast i32 tag)
-                              (cast i32 (-> entries bytes)) (cast i32 (-> entries length)) (cast i32 err) (-> p ends)
-                              (cast i32 (-> args bytes)) (cast i32 (-> args length)))))
+    (set! n (cast u32 (start (cast i32 function) (cast i32 (-> argument items)) (cast i32 (-> argument length))
+                             (cast i32 (-> p time)) (cast i32 (-> p memory)) (-> p output) (cast i32 tag)
+                             (cast i32 (-> entries bytes)) (cast i32 (-> entries length)) (cast i32 (& why))
+                             (-> p ends) (cast i32 (-> args bytes)) (cast i32 (-> args length)))))
     (buffer-free! (& entries))
     (buffer-free! (& args))
     (when (== o 0) (buffer-free! (& (-> defaults grants list))))
-    id))
+    (unless (== id 0) (set! (@ id) n))
+    (or (!= n 0) (host-failed! (& why) err))))
 
 (define (worker-send [w u32] [b (slice u8)]) -> i32 (send (cast i32 w) (cast i32 (-> b items)) (cast i32 (-> b length))))