substrate-lang 0.10.1 → 0.10.2

package/std/package.sub

@@ -1,6 +1,6 @@
 (package std
-  (version "0.10.1")
-  (substrate "0.10.1")
+  (version "0.10.2")
+  (substrate "0.10.2")
   (exports archive/tar browser/chromium browser/devtools compress/deflate compress/gzip compress/inflate crypto/hmac
            crypto/password crypto/sha1
            crypto/sha256 crypto/sha512 doc/doc doc/html doc/root doc/text encoding/base64 encoding/json encoding/utf8

package/std/test/browser.sub

@@ -105,13 +105,13 @@
 
 (define (%browser-step! [s string]) (page-step! s))
 
-(define (browser-opened [spec string] [html string] [url string] [args (slice string)] [server (fn ())] [message string])
-                        -> browser
+(define (browser-opened [spec string] [html string] [release bool] [url string] [args (slice string)] [server (fn ())]
+                        [message string]) -> browser
   (let ([address string])
     (unless (env-get "SUBSTRATE_DEVTOOLS" (& address) 0)
       (throw test-failed (lines-joined message "a test that opens a browser needs (browser) in the tests clause of its package's package.sub")))
     (when (== (-> address length) 0) (throw test-skipped "need Chromium"))
-    (let ([dir (site-built spec html message)] [why error] [p (ptr page) 0])
+    (let ([dir (site-built spec html release message)] [why error] [p (ptr page) 0])
       (unless (page-open dir (with-args url args) address server (& p) (& why))
         (throw test-failed (lines-joined message (error-text (& why)))))
       (browser #:page p))))
@@ -126,28 +126,31 @@
       (url-add-form-value! (& b) (@ args i)))
     (buffer-string (& b))))
 
-(struct built [spec string] [html string] [dir string])
+(struct built [spec string] [html string] [release bool] [dir string])
 
 (define made buffer)
 
 ;; Builds spec's site in the test's scratch directory, once per test.
-(define (site-built [spec string] [html string] [message string]) -> string
+(define (site-built [spec string] [html string] [release bool] [message string]) -> string
   (let* ([all (cast (ptr built) (-> made bytes))] [n (/ (-> made length) (sizeof built))]
          [base (base-of spec)] [name (if (ends? base ".sub") (slice base 0 (- (-> base length) 4)) base)]
          [dir (joined-path (joined-path (scratch-directory) "sites") name)] [info fs-info] [err (make-buffer)]
          [b built])
     (for ([i u32 0]) (< i n) (+= i 1)
       (let ([m (& (@ all i))])
-        (when (and (== (-> m spec) spec) (== (-> m html) html)) (return (-> m dir)))
+        (when (and (== (-> m spec) spec) (== (-> m html) html) (== (-> m release) release)) (return (-> m dir)))
         (when (== (-> m dir) dir) (set! dir (numbered dir n)))))
     (let ([p (planned spec name message)])
       (when (> (-> html length) 0) (set! (-> p html) html))
+      (build-ready!)
       (unless (site-write! (& p) dir (toolchain) (& err))
         (throw test-failed (lines-joined message (buffer-string (& err)))))
       (unless (and (fs-stat (-> p program) (& info) 0) (== (-> info kind) fs-directory))
-        (unless (program-write! (-> p program) (joined-path dir "program") (& err))
-          (throw test-failed (lines-joined message (buffer-string (& err)))))))
-    (set! b (built #:spec spec #:html html #:dir dir))
+        (unless (program-write! (-> p program) (joined-path dir "program") release (& err))
+          (throw test-failed (lines-joined message (buffer-string (& err))))))
+      (when (and release (not (site-release! dir (& err))))
+        (throw test-failed (lines-joined message (buffer-string (& err))))))
+    (set! b (built #:spec spec #:html html #:release release #:dir dir))
     (buffer-add! (& made) (slice (cast (ptr u8) (& b)) (sizeof built)))
     dir))
 
@@ -367,18 +370,21 @@
   (define (with-browser-form [s datum]) -> datum
     (syntax-match s
       [(_ ((? identifier? b) (? text? file) options ...) body ...)
-       (let ([html (literal '"")] [url (literal '"")] [args (no-fields)] [server #'(cast (fn ()) 0)] [l options])
+       (let ([html (literal '"")] [release #'#f] [url (literal '"")] [args (no-fields)] [server #'(cast (fn ()) 0)]
+             [l options])
          (while (pair? l)
            (unless (and (keyword? (syntax-e (car l))) (pair? (cdr l)))
              (raise-syntax-error 'with-browser "expected a keyword and its value" (car l)))
            (let ([k (keyword->string (syntax-e (car l)))] [v (cadr l)])
              (cond [(and (== k "html") (text? v)) (set! html (path-of s v))]
+                   [(== k "release") (set! release v)]
                    [(and (== k "url") (text? v)) (set! url v)]
                    [(== k "args") (set! args (arguments v))]
                    [(== k "server") (set! server v)]
-                   [else (raise-syntax-error 'with-browser "the options are #:html \"file\", #:url \"url\", #:args and #:server function" (car l))]))
+                   [else (raise-syntax-error 'with-browser "the options are #:html \"file\", #:release #t, #:url \"url\", #:args and #:server function" (car l))]))
            (set! l (cddr l)))
-         #`(let ([#,b (browser-opened #,(if (named? (syntax-e file)) file (path-of s file)) #,html #,url #,args #,server
+         #`(let ([#,b (browser-opened #,(if (named? (syntax-e file)) file (path-of s file)) #,html #,release #,url #,args
+                                      #,server
                                       #,(literal (format "~a:~a: (with-browser (~s ~s) ...)"
                                                          `(,(syntax-source s) ,(syntax-line s) ,(syntax->datum b)
                                                            ,(syntax-e file)))))])
@@ -386,8 +392,8 @@
                [catch-all (browser-closed! #,b) (rethrow)])
              (%browser-step! "")
              (browser-closed! #,b)))]
-      [_ (raise-syntax-error 'with-browser "expected (with-browser (name \"site or program.sub\" [#:html \"index.html\"] [#:url \"url\"] [#:args (\"argument\" ...)]
-                                       [#:server function]) body ...)" s)]))
+      [_ (raise-syntax-error 'with-browser "expected (with-browser (name \"site or program.sub\" [#:html \"index.html\"] [#:release #t] [#:url \"url\"]
+                                       [#:args (\"argument\" ...)] [#:server function]) body ...)" s)]))
 
   ;; The program's arguments from #:args: either a list of strings, or an expression that gives a slice of strings.
   (define (arguments [v datum]) -> datum

package/std/test/build.sub

@@ -1,4 +1,5 @@
 ;; Building programs during a test: expect-compile-error, and program-write!, which with-browser uses to build sites.
+;; build-ready! gives the compiler the test program's toolchain, module map and cache, once.
 (require-unqualified compiler/macros)
 (require-unqualified compiler/expander)
 (require-unqualified compiler/roots)
@@ -9,12 +10,12 @@
 (require-unqualified "test.sub")
 (require-unqualified "compare.sub")
 
-(provide expect-compile-error program-write!)
+(provide expect-compile-error program-write! build-ready!)
 
 (define ready bool #f)
 (define directory string)
 
-(define (ready!)
+(define (build-ready!)
   (unless ready
     (set! ready #t)
     (let ([why error] [toolchain string] [map-file string] [cache string])
@@ -29,19 +30,20 @@
 
 ;; Builds the program at path into out, both relative to the package's directory, with the test program's module map
 ;; and cache. Returns #f with the compile error in err if it does not compile.
-(define (program-write! [path string] [out string] [err (ptr buffer)]) -> bool
-  (ready!)
+(define (program-write! [path string] [out string] [strip bool] [err (ptr buffer)]) -> bool
+  (build-ready!)
   (let ([full (resolved-path directory path)] [to (resolved-path directory out)])
     (set-display-directory! (string->datum (parent-of full)))
     (fs-remove to #t 0)
-    (try (begin (write-program! 0 (string->datum full) (string->datum to) #f) #t)
+    (try (begin (write-program! 0 (string->datum full) (string->datum to) strip) #t)
          [catch compile-error (message blamed loc)
            (write-error err message blamed loc)
            #f])))
 
 (define (compile-error-check [path string] [text string] [message string])
   (let ([err (make-buffer)])
-    (when (program-write! path (joined-path (joined-path (scratch-directory) "programs") (program-name path)) (& err))
+    (when (program-write! path (joined-path (joined-path (scratch-directory) "programs") (program-name path)) #f
+                          (& err))
       (failure! message "the file compiled"))
     (unless (contains? (buffer-string (& err)) text) (failure! message (text-of "its compile error is\n" (buffer-string (& err)))))
     (buffer-free! (& err))))

package/std/test/page/agent.mjs

@@ -74,8 +74,14 @@ const same = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
 // nameOf names drawn images and sounds by the path of the site's asset with the same bytes.
 async function nameOf(bytes, otherwise) {
   if (!assets) {
-    const listed = (await (await fetch('/assets.list')).text()).split('\n').filter((p) => p !== '');
-    assets = await Promise.all(listed.map(async (p) => [`/${p}`, new Uint8Array(await (await fetch(`/${p}`)).arrayBuffer())]));
+    const start = document.querySelector('script[src$="host/web/start.mjs"]');
+    const list = start ? new URL('../../assets.list', start.src) : new URL('/assets.list', location.href);
+    const lines = (await (await fetch(list)).text()).split('\n').filter((l) => l !== '');
+    assets = await Promise.all(lines.map(async (line) => {
+      const [path, url = path] = line.split('\t');
+      const from = new URL(url.split('/').map(encodeURIComponent).join('/'), location.href);
+      return [`/${path}`, new Uint8Array(await (await fetch(from)).arrayBuffer())];
+    }));
   }
   const found = assets.find(([, b]) => same(b, bytes));
   return found ? found[0] : otherwise;

package/std/web/canvas.sub

@@ -1,5 +1,5 @@
 ;; Drawing on a <canvas> element: rectangles, paths, circles, text, images and transforms. The calls write into the
-;; page's patches (patches.sub) between canvas-begin! and canvas-end!, and a call made outside them draws nothing.
+;; patches (patches.sub) between canvas-begin! and canvas-end!, and a call made outside them draws nothing.
 (require-unqualified std/web/patches)
 
 (provide canvas-begin! canvas-end! canvas-drawing?

package/std/web/dom.sub

@@ -1,8 +1,8 @@
-;; The page: the host module "dom" and the patches that patches.sub writes. dom-flush! sends the patches. A read takes a
-;; name that walks from a node, or from the current event, through the page's objects: a property's name, or names
-;; joined by dots. It gives a number, with true as 1, or text. The text lasts until the patches are sent. dom-is and
-;; dom-event-is also take a node, and say whether the name leads to it. (dom-is node dom-document "activeElement") says
-;; whether the node has the focus. dom-event-call calls a method of the current event.
+;; The document: the host module "dom" and the patches that patches.sub writes. dom-flush! sends the patches. A read
+;; takes a name that walks from a node, or from the current event, through the document's objects: a property's name, or
+;; names joined by dots. It gives a number, with true as 1, or text. The text lasts until the patches are sent. dom-is
+;; and dom-event-is also take a node, and say whether the name leads to it. (dom-is node dom-document "activeElement")
+;; says whether the node has the focus. dom-event-call calls a method of the current event.
 (require-unqualified host-dom host/web/dom)
 (require-unqualified patches "patches.sub")
 

package/std/web/patches.sub

@@ -1,8 +1,8 @@
-;; Changes to the page, written as patches for the host module "dom". dom.sub sends them. A template is HTML in which
-;; the nodes a program will change are marked: elements with a data-n attribute, <!--t--> for a text node, and <!--a-->
-;; for a place that other pieces can be put before. dom-add! puts a piece, a copy of a template, on the page and returns
-;; the piece's number; its marked nodes are numbered after it, in document order. The strings these functions take are
-;; copied, and the copies last until the patches are sent or dom-discard! drops them.
+;; Changes to the document, written as patches for the host module "dom". dom.sub sends them. A template is HTML in
+;; which the nodes a program will change are marked: elements with a data-n attribute, <!--t--> for a text node, and
+;; <!--a--> for a place that other pieces can be put before. dom-add! puts a piece, a copy of a template, in the document
+;; and returns the piece's number; its marked nodes are numbered after it, in document order. The strings these
+;; functions take are copied, and the copies last until the patches are sent or dom-discard! drops them.
 (provide dom-template dom-add! dom-remove! dom-forget! dom-move! dom-set-text! dom-set-attr! dom-remove-attr! dom-listen!
          dom-listen-window! dom-value dom-number dom-text dom-write-number! dom-write-text! dom-call! dom-call-with!
          dom-document dom-image! dom-stylesheet! dom-new-node!
@@ -49,8 +49,8 @@
     (words! (slice (array-of u32 2 template first n parent before)))
     first))
 
-;; dom-remove! takes a piece off the page and forgets its nodes. dom-forget! only forgets them, for a piece that was
-;; inside one taken off.
+;; dom-remove! takes a piece out of the document and forgets its nodes. dom-forget! only forgets them, for a piece that
+;; was inside one taken out.
 (define (dom-remove! [first u32] [template u32]) (words! (slice (array-of u32 3 first (size-of template)))))
 (define (dom-forget! [first u32] [template u32]) (words! (slice (array-of u32 4 first (size-of template)))))
 
@@ -110,7 +110,7 @@
   (let ([n (kept name)]) (words! (slice (array-of u32 8 node (cast u32 (-> n bytes)) (-> n length))))))
 
 ;; dom-listen! sends the node's event to tag's handler, and dom-listen-window! sends the window's event there while the
-;; node is on the page.
+;; node is in the document.
 (define (dom-listen! [node u32] [event string] [tag (ptr void)])
   (let ([e (kept event)]) (words! (slice (array-of u32 9 node (cast u32 (-> e bytes)) (-> e length) (cast u32 tag))))))
 

package/substrate/VERSION

@@ -1 +1 @@
-0.10.1
+0.10.2

package/substrate/compiler/expander.sub

@@ -1069,10 +1069,9 @@
        (equal? (section d 'format) (make-integer cache-format))
        (equal? (section d 'compiler) compiler-hash)))
 
-;; load-cached loads a module from the cache, or from the program's compiled modules if that is where the module comes
-;; from.
+;; load-cached loads the module at path from the program's compiled modules when they hold it, or else from the cache.
 (define (load-cached [path datum]) -> datum
-  (if (if (compiled-root? path) (== (compiled-module path) 0) (== (cache-compiler) 0))
+  (if (and (== (compiled-module path) 0) (or (compiled-root? path) (== (cache-compiler) 0)))
       0
       (begin
         (begin-module-arena)

package/substrate/compiler/roots.sub

@@ -9,8 +9,8 @@
 (provide set-toolchain-directory! set-module-map! set-module-map-text! set-display-directory! toolchain-root? toolchain-roots
          toolchain-holding root-directories root-under-test? identity identity-label host-file entry-identity program-identity
          set-compiled-module-map! compiled-module-map compiled-module compiled-root? module-source-file module-path-from
-         module-identity named-file program-forms language-path compiler-file module-source? string-literal? displayed
-         write-error fail-at read-text file-text host-error module-refusal)
+         module-identity named-file named-directory program-forms language-path compiler-file module-source?
+         string-literal? displayed write-error fail-at read-text file-text host-error module-refusal)
 
 (define (symbol-of [s datum]) -> datum (string->symbol (datum->string s)))
 
@@ -183,10 +183,12 @@
 (define (set-module-map-text! [text datum] [source datum])
   (set-module-map! (map (lambda ([f datum]) -> datum (syntax->datum f)) (read-text text (symbol-of source)))))
 
-;; set-compiled-module-map! replaces the roots with those of the program's compiled modules, which have no directories.
+;; set-compiled-module-map! gives sessions the program's compiled modules. When the program has given no roots with
+;; directories, it also replaces the roots with those of the compiled modules, which have no directories.
 (define (set-compiled-module-map! [forms datum] [modules datum])
-  (set! toolchain-directory 0)
-  (set-module-map! forms)
+  (when (null? (root-directories))
+    (set! toolchain-directory 0)
+    (set-module-map! forms))
   (set! compiled (keep modules)))
 
 ;; compiled-module-map returns the module map without directories, which a build writes next to the program's compiled
@@ -390,6 +392,11 @@
   (let ([file (concat rest '".sub")] [inner (file-in rest (concat (last-part rest) '".sub"))])
     (if (and (== (compiled-module (identity label file)) 0) (!= (compiled-module (identity label inner)) 0)) inner file)))
 
+;; named-directory gives the directory that name stands for in a require from file, or #f for a root of compiled modules.
+(define (named-directory [file datum] [name datum]) -> datum
+  (let ([r (root-holding (absolute file))])
+    (cadr (root-in (named-root 0 name (if (== r 0) program-label (car r)) roots) roots))))
+
 ;; naming-label returns the root used to resolve module names in code from a given module: that module's root, or the
 ;; program's root for code outside any root, such as session input.
 (define (naming-label [from datum]) -> datum

package/substrate/host/grants.mjs

@@ -1,7 +1,7 @@
 // What a program may do beyond computing: read and write files, reach hosts, read the environment and run
-// programs. The grants match Deno's permissions wherever the two overlap, except that the host never prompts, a page
-// cannot check where fetch is redirected or where names resolve, and a child may keep the dynamic loader's variables
-// the host started with.
+// programs. The grants match Deno's permissions wherever the two overlap, except that the host never prompts, a web
+// program cannot check where fetch is redirected or where names resolve, and a child may keep the dynamic loader's
+// variables the host started with.
 const kinds = ['read', 'write', 'net', 'env', 'run'];
 export const flags = {
   read: '--allow-read', write: '--allow-write', net: '--allow-net', env: '--allow-env', run: '--allow-run',

package/substrate/host/node/net.mjs

@@ -1,4 +1,5 @@
-// The host module "net" (net.sub).
+// The host module "net" (net.sub). A TLS server reloads its certificate and key when their files change.
+import fs from 'node:fs';
 import net from 'node:net';
 import tls from 'node:tls';
 import { errorOf, reasonOf } from '../errors.mjs';
@@ -14,6 +15,19 @@ const ACCEPT = 2;
 const CONNECTED = 3;
 const FAILED = 4;
 
+function renewed(server, certificate) {
+  const [certFile, keyFile] = certificate.files;
+  const reload = () => {
+    try {
+      server.setSecureContext({ cert: fs.readFileSync(certFile), key: fs.readFileSync(keyFile) });
+    } catch {}
+  };
+  for (const file of certificate.files) fs.watchFile(file, { interval: 1000, persistent: false }, reload);
+  server.once('close', () => {
+    for (const file of certificate.files) fs.unwatchFile(file, reload);
+  });
+}
+
 export function netModule(grants, certificate) {
   const listeners = new Map();
   const ca = certificate ? [...tls.rootCertificates, certificate.cert] : undefined;
@@ -39,9 +53,10 @@ export function netModule(grants, certificate) {
             throw new Error('net.listen: TLS needs the host started with --tls-cert and --tls-key');
           }
           server = secure
-            ? tls.createServer({ ...certificate, allowHalfOpen: true })
+            ? tls.createServer({ cert: certificate.cert, key: certificate.key, allowHalfOpen: true })
             : net.createServer({ allowHalfOpen: true });
           if (most > 0) server.maxConnections = most;
+          if (secure && certificate.files) renewed(server, certificate);
           if (addressDenials(grants.net) && !net.isIP(host)) {
             lookupWithin(grants, 'net.listen', port)(host, {}, (e, address) => {
               if (listeners.get(id) !== server) return;

package/substrate/host/node/worker.mjs

@@ -30,7 +30,9 @@ export function workers(setup) {
     spawn(plan) {
       const { port1, port2 } = new MessageChannel();
       const signal = new Int32Array(new SharedArrayBuffer(4));
-      const tls = plan.tls ? { cert: read(plan.tls.cert), key: read(plan.tls.key) } : setup.tls;
+      const tls = plan.tls
+        ? { cert: read(plan.tls.cert), key: read(plan.tls.key), files: [plan.tls.cert, plan.tls.key] }
+        : setup.tls;
       const thread = new Worker(new URL('./worker-thread.mjs', import.meta.url));
       // The messages a thread posted before it ended, which can still wait on the port when its exit is heard.
       let heard = null;

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

@@ -74,7 +74,7 @@ export function audio() {
       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();
         });

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';
 
@@ -64,7 +64,7 @@ export function dom(root) {
       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 page's objects`);
+        caller.trap(`dom: ${path}: ${parts.slice(0, k + 1).join('.')} is not one of the document's objects`);
       }
     }
     return [x, last];
@@ -372,7 +372,7 @@ export function dom(root) {
           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 = () => {

package/substrate/host/web/dom.sub

@@ -1,7 +1,7 @@
-;; The page: 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 page are in std/web/dom.sub too. dom-images-loading
-;; counts the images loading for a tag.
+;; 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)

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);

package/substrate/host/web/gpu.mjs

@@ -144,7 +144,7 @@ export async function gpu(options = {}) {
         case 1: {
           const id = w[i + 1];
           const node = theDom && theDom.nodeOf ? theDom.nodeOf(w[i + 2]) : null;
-          if (!node) caller.trap(`gpu: surface ${id}: the page gave this module no dom, or node ${w[i + 2]} is not on the page`);
+          if (!node) caller.trap(`gpu: surface ${id}: this module has no dom, or node ${w[i + 2]} is not in the document`);
           if (!(node instanceof HTMLCanvasElement)) caller.trap(`gpu: surface ${id}: node ${w[i + 2]} is not a canvas`);
           if (options.offscreen) {
             const texture = device.createTexture({
@@ -563,7 +563,7 @@ export async function gpu(options = {}) {
     counted(to, 1);
     try {
       const bytes = app && app.files.get(resolvePath(app.cwd, name));
-      const blob = bytes ? new Blob([bytes]) : await fetch(name).then((r) => {
+      const blob = bytes ? new Blob([bytes]) : await fetch(app ? app.url(name) : name).then((r) => {
         if (!r.ok) throw new Error(`the server answered ${r.status}`);
         return r.blob();
       });

package/substrate/host/web/location.sub

@@ -1,4 +1,4 @@
-;; The page's URL and history: the host module "location". When the user goes back or forward, each listener's tag
+;; The document's URL and history: the host module "location". When the user goes back or forward, each listener's tag
 ;; gets a changed event with the URL as its bytes. location-listen gives the listener's number, and location-unlisten
 ;; takes it.
 (provide location-source location-changed location-get location-push location-replace location-back location-listen

package/substrate/host/web/start.mjs

@@ -1,5 +1,6 @@
-// Starts a site's program with the files in assets.list and files.pack, the URL's arg parameters as its arguments, and
-// the host modules it imports. It sets window.modules, sets window.ready once the program has started, and sets
+// Starts a site's program with the files in files.pack, the URL's arg parameters as its arguments, and the host modules
+// it imports. The program, files.pack and assets.list sit beside the host directory. The assets load from the site
+// when the program asks for them. It sets window.modules, sets window.ready once the program has started, and sets
 // window.ended to the program's exit status and window.endReason to why it ended.
 import { boot } from './subhost-web.mjs';
 import { allGrants } from '../grants.mjs';
@@ -7,6 +8,7 @@ import { allGrants } from '../grants.mjs';
 const query = new URLSearchParams(location.search);
 const grants = allGrants();
 const root = document.getElementById('root');
+const built = new URL('../../', import.meta.url);
 const made = {};
 const makers = {
   dom: async () => (await import('./dom.mjs')).dom(root),
@@ -26,9 +28,10 @@ const makers = {
 const make = (name) => (made[name] ||= makers[name]());
 
 window.app = await boot({
-  program: 'program/',
-  lists: [['assets.list', '/']],
-  packs: [['files.pack', '/']],
+  program: new URL('program/', built).href,
+  packs: [[new URL('files.pack', built).href, '/']],
+  assets: new URL('assets.list', built).href,
+  site: document.baseURI,
   args: query.getAll('arg'),
   grants,
   onEnd: (code, reason) => {
@@ -36,8 +39,9 @@ window.app = await boot({
     window.endReason = reason;
   },
   async modules(wanted) {
-    const modules = {};
-    for (const name of wanted) if (Object.hasOwn(makers, name)) modules[name] = await make(name);
+    const names = [...wanted].filter((name) => Object.hasOwn(makers, name));
+    const given = await Promise.all(names.map(make));
+    const modules = Object.fromEntries(names.map((name, i) => [name, given[i]]));
     window.modules = modules;
     return modules;
   },

package/substrate/host/web/subhost-web.mjs

@@ -1,9 +1,9 @@
-// The host for a web page: runs a program in a browser, with its files kept in memory. A page has every grant and
+// The web host: runs a program in a browser, with its files kept in memory. A web program has every grant and
 // no fakes. Its workers can be given fewer grants and some fakes (worker-script.mjs).
 import { createHost } from '../subhost-core.mjs';
 import { fsModule } from '../fs.mjs';
 import { allGrants, pairsFrom, requestOf } from '../grants.mjs';
-import { pageFiles, resolvePath } from './fs.mjs';
+import { memoryFiles, resolvePath } from './fs.mjs';
 
 const text = new TextDecoder();
 const utf8 = new TextEncoder();
@@ -26,13 +26,13 @@ async function fetchBytes(url) {
   return new Uint8Array(await response.arrayBuffer());
 }
 
-async function fetchListed(url, dir, files) {
-  const list = new URL(url, globalThis.document ? document.baseURI : globalThis.location.href);
-  const paths = text.decode(await fetchBytes(list)).split('\n').filter((p) => p !== '');
-  await Promise.all(paths.map(async (path) => {
-    const from = new URL(path.split('/').map(encodeURIComponent).join('/'), list);
-    files.set(resolvePath(dir, path), await fetchBytes(from));
-  }));
+async function fetchAssets(url) {
+  const urls = new Map();
+  for (const line of text.decode(await fetchBytes(url)).split('\n')) {
+    const tab = line.indexOf('\t');
+    if (tab >= 0) urls.set(resolvePath('/', line.slice(0, tab)), line.slice(tab + 1));
+  }
+  return urls;
 }
 
 function lines(line) {
@@ -92,36 +92,50 @@ export function importedModules(bytes) {
   return names;
 }
 
+async function fetchProgram(base, wasm) {
+  const names = text.decode(await fetchBytes(`${base}program`)).split('\n').filter((n) => n !== '');
+  await Promise.all(names.map(async (name) => {
+    wasm.set(name, await fetchBytes(`${base}${encodeURIComponent(name)}.wasm`));
+  }));
+  return names;
+}
+
+// The compiled modules for sessions: the compiled file lists them, each one is in <hash>.subc, and compiled.map holds
+// their module map.
+async function fetchCompiled(base) {
+  const compiled = new Map();
+  const listed = await fetch(`${base}compiled`);
+  if (!listed.ok) return compiled;
+  const list = new Uint8Array(await listed.arrayBuffer());
+  const hashes = text.decode(list).split('\n').filter((l) => l !== '').map((l) => l.slice(0, l.indexOf(' ')));
+  const fetched = async (name) => compiled.set(name, await fetchBytes(`${base}${name}`));
+  const names = hashes.map((h) => `${h}.subc`);
+  compiled.set('compiled', list);
+  await Promise.all((hashes.length > 0 ? ['compiled.map', ...names] : []).map(fetched));
+  return compiled;
+}
+
 // options.modules is the modules, or a function that takes the names the program imports and gives the modules.
+// options.assets is the URL of the site's assets.list.
 export async function boot(options) {
   const base = options.program.endsWith('/') ? options.program : `${options.program}/`;
   const files = options.files || new Map();
-  for (const [url, dir] of options.lists || []) await fetchListed(url, dir, files);
-  for (const [url, dir] of options.packs || []) unpack(await fetchBytes(url), dir, files);
-
-  const names = text.decode(await fetchBytes(`${base}program`)).split('\n').filter((n) => n !== '');
   const wasm = new Map();
-  await Promise.all(names.map(async (name) => {
-    wasm.set(name, await fetchBytes(`${base}${encodeURIComponent(name)}.wasm`));
-  }));
-  let { modules } = options;
-  if (typeof modules === 'function') {
+  const names = fetchProgram(base, wasm);
+  const ask = options.modules;
+  const modules = typeof ask !== 'function' ? ask : names.then(() => {
     const wanted = new Set();
     for (const bytes of wasm.values()) for (const name of importedModules(bytes)) wanted.add(name);
-    modules = await modules(wanted);
-  }
-  // The compiled modules for sessions: the compiled file lists them, each one is in <hash>.subc, and compiled.map holds
-  // their module map.
-  const compiled = new Map();
-  const listed = await fetch(`${base}compiled`);
-  if (listed.ok) {
-    const list = new Uint8Array(await listed.arrayBuffer());
-    const hashes = text.decode(list).split('\n').filter((l) => l !== '').map((l) => l.slice(0, l.indexOf(' ')));
-    compiled.set('compiled', list);
-    if (hashes.length > 0) compiled.set('compiled.map', await fetchBytes(`${base}compiled.map`));
-    await Promise.all(hashes.map(async (h) => compiled.set(`${h}.subc`, await fetchBytes(`${base}${h}.subc`))));
-  }
-  return run({ ...options, files, modules, compiled }, names, wasm);
+    return ask(wanted);
+  });
+  const [listed, given, compiled, urls] = await Promise.all([
+    names,
+    modules,
+    fetchCompiled(base),
+    options.assets ? fetchAssets(options.assets) : new Map(),
+    ...(options.packs || []).map(async ([url, dir]) => unpack(await fetchBytes(url), dir, files)),
+  ]);
+  return run({ ...options, files, modules: given, compiled, urls }, listed, wasm);
 }
 
 export function run(options, names, wasm) {
@@ -136,9 +150,16 @@ export function run(options, names, wasm) {
   const output = options.output || ((fd, bytes) => write(fd, decoders[fd].decode(bytes, { stream: true })));
 
   const app = { files, cwd, entry: null, ended: false, realTime: [] };
+  // app.url gives the URL to load a file from when it is not in memory.
+  const site = options.site || (globalThis.document ? document.baseURI : globalThis.location.href);
+  const urls = options.urls || new Map();
+  app.url = (name) => {
+    const path = resolvePath(cwd, name);
+    return new URL((urls.get(path) || path.slice(1)).split('/').map(encodeURIComponent).join('/'), site).href;
+  };
   const modules = new Map();
   for (const [name, make] of Object.entries(options.modules || {})) modules.set(name, (caller) => make(caller, app));
-  if (!modules.has('fs')) modules.set('fs', fsModule(pageFiles(files, cwd, grants)));
+  if (!modules.has('fs')) modules.set('fs', fsModule(memoryFiles(files, cwd, grants)));
   const report = (message) => output(2, utf8.encode(`error: ${message}\n`));
   const ended = (code, reason) => {
     app.ended = true;