substrate-lang 0.9.1 → 0.9.3

package/substrate/compiler/roots.sub

@@ -8,7 +8,7 @@
 
 (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
-         module-source-file module-path-from
+         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)
 
@@ -76,35 +76,46 @@
   (set! toolchain-directory (keep (absolute dir)))
   (set! roots (keep (toolchain-roots)))
   (set! shared-uses nil)
-  (set! test-labels nil))
+  (set! test-labels nil)
+  (set! compiled nil))
 
 ;; A root is (label directory uses rules): uses is ((name label) ...), and rules is () or (exports file packages), with
 ;; paths relative to the directory. A module's identity is label/path in its root, or ./path or ../path from the first
-;; file's directory when no root holds it.
+;; file's directory when no root holds it. A root of compiled modules has #f instead of a directory.
 (define roots datum nil)
 (define shared-uses datum nil)
 (define test-labels datum nil)
 (define loose-directory datum 0)
 (define display-directory datum 0)
 
+;; compiled holds the compiled modules from the program's build, as (identity hash) pairs, where hash is the SHA-256 of
+;; the module's file.
+(define compiled datum nil)
+
 (define toolchain-labels datum '("host" "compiler"))
 
 (define (toolchain-root? [label datum]) -> bool (!= (member label toolchain-labels) 0))
 
-(define (toolchain-roots) -> datum (map (lambda ([l datum]) -> datum `(,l ,(file-in toolchain-directory l) () ())) toolchain-labels))
+(define (toolchain-roots) -> datum
+  (map (lambda ([l datum]) -> datum `(,l ,(if (== toolchain-directory 0) '#f (file-in toolchain-directory l)) () ()))
+       toolchain-labels))
 
-(define (root-directories) -> datum (map (lambda ([r datum]) -> datum (cadr r)) roots))
+(define (root-directories) -> datum
+  (filter (lambda ([d datum]) -> bool (not (equal? d '#f))) (map (lambda ([r datum]) -> datum (cadr r)) roots)))
 
 (define (root-under-test? [label datum]) -> bool (!= (member label test-labels) 0))
 
-;; set-module-map! replaces the roots with a module map's, given as (root label "directory" clause ...) and
-;; (uses (name label) ...) forms.
+;; set-module-map! replaces the roots with those of a module map, which is made of (root label "directory" clause ...),
+;; (uses (name label) ...) and (program label) forms. A root of compiled modules has no directory.
 (define (set-module-map! [forms datum])
   (set! roots (keep (toolchain-roots)))
   (set! shared-uses nil)
   (set! test-labels nil)
   (for-each (lambda ([f datum])
-              (if (and (pair? f) (equal? (car f) 'uses)) (set! shared-uses (keep (uses-in f shared-uses))) (add-root! f)))
+              (cond [(and (pair? f) (equal? (car f) 'uses)) (set! shared-uses (keep (uses-in f shared-uses)))]
+                    [(and (pair? f) (equal? (car f) 'program) (pair? (cdr f)) (symbol? (cadr f)) (null? (cddr f)))
+                     (set! program-label (keep (string->datum (symbol->string (cadr f)))))]
+                    [else (add-root! f)]))
             forms)
   (for-each (lambda ([r datum])
               (for-each (lambda ([u datum])
@@ -117,13 +128,16 @@
             shared-uses))
 
 (define (add-root! [f datum])
-  (let ([label datum 0] [uses nil] [exports nil] [one '""] [nested nil] [restricted #f] [cs datum 0])
-    (unless (and (pair? f) (equal? (car f) 'root) (pair? (cdr f)) (symbol? (cadr f)) (pair? (cddr f)) (string? (caddr f)))
+  (let ([label datum 0] [dir datum '#f] [uses nil] [exports nil] [one '""] [nested nil] [restricted #f] [cs datum 0])
+    (unless (and (pair? f) (equal? (car f) 'root) (pair? (cdr f)) (symbol? (cadr f)))
       (fail-at 0 "expected (root label \"directory\" clause ...) or (uses (name label) ...), not ~s" (list1 f)))
     (set! label (string->datum (symbol->string (cadr f))))
     (when (or (toolchain-root? label) (!= (assoc label roots) 0))
       (fail-at 0 "the module map gives a root named ~a twice, or names a root host or compiler" (list1 label)))
-    (set! cs (cdddr f))
+    (set! cs (cddr f))
+    (when (and (pair? cs) (string? (car cs)))
+      (set! dir (absolute (car cs)))
+      (set! cs (cdr cs)))
     (while (pair? cs)
       (let ([c (car cs)])
         (cond [(and (pair? c) (equal? (car c) 'uses)) (set! uses (uses-in c uses))]
@@ -141,7 +155,7 @@
                (fail-at 0 "a root's clauses are (uses (name label) ...), (exports \"path\" ...), (file \"path\"), (packages (name \"path\") ...) and (test), not ~s"
                         (list1 c))]))
       (set! cs (cdr cs)))
-    (set! roots (keep (cons `(,label ,(absolute (caddr f)) ,uses ,(if restricted `(,exports ,one ,nested) nil)) roots)))))
+    (set! roots (keep (cons `(,label ,dir ,uses ,(if restricted `(,exports ,one ,nested) nil)) roots)))))
 
 (define (nested? [l datum]) -> bool
   (while (pair? l)
@@ -169,6 +183,44 @@
 (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.
+(define (set-compiled-module-map! [forms datum] [modules datum])
+  (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
+;; modules.
+(define (compiled-module-map) -> datum
+  (let ([out (if (== program-label 0) nil `((program ,(symbol-of program-label))))])
+    (unless (null? shared-uses) (set! out (cons (cons 'uses (uses-forms shared-uses)) out)))
+    (for-each (lambda ([r datum])
+                (unless (toolchain-root? (car r))
+                  (set! out (cons (append `(root ,(symbol-of (car r)) ,(cons 'uses (uses-forms (caddr r))))
+                                          (append (rules-forms (cadddr r)) (if (root-under-test? (car r)) '((test)) nil)))
+                                  out))))
+              roots)
+    out))
+
+(define (uses-forms [uses datum]) -> datum
+  (map (lambda ([u datum]) -> datum `(,(symbol-of (car u)) ,(symbol-of (cadr u)))) uses))
+
+(define (rules-forms [rules datum]) -> datum
+  (if (null? rules)
+      nil
+      (append (list1 (cons 'exports (car rules)))
+              (append (if (equal? (cadr rules) '"") nil `((file ,(cadr rules))))
+                      (if (null? (caddr rules))
+                          nil
+                          (list1 (cons 'packages (map (lambda ([p datum]) -> datum `(,(symbol-of (car p)) ,(cadr p)))
+                                                      (caddr rules)))))))))
+
+(define (compiled-module [id datum]) -> datum (assoc id compiled))
+
+(define (compiled-root? [id datum]) -> bool
+  (let* ([label (identity-label id)] [r (if (== label 0) 0 (assoc label roots))])
+    (and (!= r 0) (equal? (cadr r) '#f))))
+
 (define (set-display-directory! [dir datum]) (set! display-directory (keep (absolute dir))))
 
 (define (root-of [label datum]) -> datum (root-in label roots))
@@ -205,12 +257,13 @@
           [else id])))
 
 (define (host-file [id datum]) -> datum
-  (let ([label (identity-label id)])
-    (if (== label 0)
-        (resolve-segments (concat (loose-root) (concat '"/" (identity-path id))))
-        (file-in (cadr (root-of label)) (identity-path id)))))
+  (let ([label (identity-label id)] [dir datum 0])
+    (when (== label 0) (return (resolve-segments (concat (loose-root) (concat '"/" (identity-path id))))))
+    (set! dir (cadr (root-of label)))
+    (if (equal? dir '#f) '#f (file-in dir (identity-path id)))))
 
-(define (inside? [file datum] [dir datum]) -> bool (path-within? (path-windows?) (datum->string file) (datum->string dir)))
+(define (inside? [file datum] [dir datum]) -> bool
+  (and (not (equal? dir '#f)) (path-within? (path-windows?) (datum->string file) (datum->string dir))))
 
 (define (toolchain-holding [file datum]) -> datum
   (let ([l roots] [found datum 0])
@@ -228,7 +281,9 @@
     found))
 
 (define (holds? [r datum] [file datum]) -> bool
-  (if (equal? (one-file r) '"") (inside? file (cadr r)) (same? file (file-in (cadr r) (one-file r)))))
+  (cond [(equal? (cadr r) '#f) #f]
+        [(equal? (one-file r) '"") (inside? file (cadr r))]
+        [else (same? file (file-in (cadr r) (one-file r)))]))
 
 (define (same? [a datum] [b datum]) -> bool (path-same? (path-windows?) (datum->string a) (datum->string b)))
 
@@ -286,7 +341,7 @@
 
 (define (displayed [source datum]) -> datum
   (let ([label (identity-label source)])
-    (cond [(and (!= label 0) (== (assoc label roots) 0)) source]
+    (cond [(and (!= label 0) (or (== (assoc label roots) 0) (compiled-root? source))) source]
           [(!= display-directory 0) (relative-path display-directory (host-file source))]
           [(== label 0) (identity-path source)]
           [else source])))
@@ -318,9 +373,10 @@
   (let* ([s (symbol->string (syntax-e id))] [n (-> s length)] [slash u32 0] [label datum 0])
     (unless (clean-name? s) (fail-at id "~a is not a module name: its parts may not be empty, . or .." (list1 (syntax-e id))))
     (while (and (< slash n) (!= (@ s slash) #\/)) (+= slash 1))
-    (set! label (named-root id (string->datum (slice s 0 slash)) (if (== from 0) 0 (identity-label from)) rs))
+    (set! label (named-root id (string->datum (slice s 0 slash)) (naming-label from) rs))
     (when (== slash n) (return (identity label (concat (label-name label) '".sub"))))
-    (identity label (named-file (cadr (root-in label rs)) (string->datum (slice s (+ slash 1) n))))))
+    (let ([dir (cadr (root-in label rs))] [rest (string->datum (slice s (+ slash 1) n))])
+      (identity label (if (equal? dir '#f) (compiled-file label rest) (named-file dir rest))))))
 
 (define (named-file [dir datum] [rest datum]) -> datum
   (let ([file (concat rest '".sub")])
@@ -328,6 +384,16 @@
         (file-in rest (concat (last-part rest) '".sub"))
         file)))
 
+;; compiled-file does what named-file does, for a root of compiled modules.
+(define (compiled-file [label datum] [rest datum]) -> datum
+  (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)))
+
+;; 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
+  (let ([label (if (== from 0) 0 (identity-label from))]) (if (== label 0) program-label label)))
+
 (define (named-root [id datum] [head datum] [from datum] [rs datum]) -> datum
   (let ([r (if (or (== from 0) (toolchain-root? from)) 0 (root-in from rs))] [u datum 0])
     (cond [(toolchain-root? head) head]
@@ -395,13 +461,13 @@
           [else (package-refusal subject id r (if (== from 0) program-label (identity-label from)))])))
 
 (define (package-refusal [subject datum] [id datum] [r datum] [from-label datum]) -> datum
-  (let* ([rules (cadddr r)] [exports (car rules)] [one (cadr rules)] [path (identity-path id)]
-         [holder (root-holding (host-file id))] [inner (nested-holding (caddr rules) path)])
+  (let* ([rules (cadddr r)] [exports (car rules)] [one (cadr rules)] [path (identity-path id)] [files (not (equal? (cadr r) '#f))]
+         [holder (if files (root-holding (host-file id)) 0)] [inner (nested-holding (caddr rules) path)])
     (cond [(not (equal? one '""))
            (if (equal? path one) 0 (format "~a is not part of ~a, a package of one file" `(,subject ,(car r))))]
           [(!= inner 0) (format "~a is in the package ~a, which is required by name" `(,subject ,(car inner)))]
           [(and (!= holder 0) (not (equal? (cadr holder) (cadr r)))) (by-name subject holder)]
-          [(linked-under? (cadr r) path)
+          [(and files (linked-under? (cadr r) path))
            (format "~a goes through a link in the package ~a, which packages do not allow" `(,subject ,(car r)))]
           [(or (and (!= from-label 0) (equal? from-label (car r))) (!= (member path exports) 0)) 0]
           [else (format "~a is not one of the modules ~a exports" `(,subject ,(car r)))])))

package/substrate/compiler/sha256.sub

@@ -0,0 +1,110 @@
+;; SHA-256 (FIPS 180-4), over bytes added in pieces or given at once.
+(provide sha256 sha256-init! sha256-add! sha256-end! sha256-of)
+
+(struct sha256 [state (array u32 8)] [block (array u8 64)] [filled u32] [length u64])
+
+(define k (array u32 64)
+  (array-of u32 #x428a2f98 #x71374491 #xb5c0fbcf #xe9b5dba5 #x3956c25b #x59f111f1 #x923f82a4 #xab1c5ed5
+               #xd807aa98 #x12835b01 #x243185be #x550c7dc3 #x72be5d74 #x80deb1fe #x9bdc06a7 #xc19bf174
+               #xe49b69c1 #xefbe4786 #x0fc19dc6 #x240ca1cc #x2de92c6f #x4a7484aa #x5cb0a9dc #x76f988da
+               #x983e5152 #xa831c66d #xb00327c8 #xbf597fc7 #xc6e00bf3 #xd5a79147 #x06ca6351 #x14292967
+               #x27b70a85 #x2e1b2138 #x4d2c6dfc #x53380d13 #x650a7354 #x766a0abb #x81c2c92e #x92722c85
+               #xa2bfe8a1 #xa81a664b #xc24b8b70 #xc76c51a3 #xd192e819 #xd6990624 #xf40e3585 #x106aa070
+               #x19a4c116 #x1e376c08 #x2748774c #x34b0bcb5 #x391c0cb3 #x4ed8aa4a #x5b9cca4f #x682e6ff3
+               #x748f82ee #x78a5636f #x84c87814 #x8cc70208 #x90befffa #xa4506ceb #xbef9a3f7 #xc67178f2))
+
+(define (rotr [x u32] [n u32]) #:inline -> u32 (bit-or (>> x n) (<< x (- 32 n))))
+
+(define (word [p (ptr u8)]) #:inline -> u32
+  (bit-or (<< (cast u32 (@ p 0)) 24) (<< (cast u32 (@ p 1)) 16) (<< (cast u32 (@ p 2)) 8) (cast u32 (@ p 3))))
+
+(define (compress! [s (ptr sha256)] [p (ptr u8)])
+  (let ([w (array u32 64)]
+        [a (@ (-> s state) 0)] [b (@ (-> s state) 1)] [c (@ (-> s state) 2)] [d (@ (-> s state) 3)]
+        [e (@ (-> s state) 4)] [f (@ (-> s state) 5)] [g (@ (-> s state) 6)] [hh (@ (-> s state) 7)])
+    (for ([i u32 0]) (< i 16) (+= i 1) (set! (@ w i) (word (+ p (* i 4)))))
+    (for ([i u32 16]) (< i 64) (+= i 1)
+      (let ([x (@ w (- i 15))] [y (@ w (- i 2))])
+        (set! (@ w i) (+ (@ w (- i 16)) (bit-xor (rotr x 7) (rotr x 18) (>> x 3)) (@ w (- i 7))
+                         (bit-xor (rotr y 17) (rotr y 19) (>> y 10))))))
+    (for ([i u32 0]) (< i 64) (+= i 1)
+      (let* ([t1 (+ hh (bit-xor (rotr e 6) (rotr e 11) (rotr e 25)) (bit-xor (bit-and e f) (bit-and (bit-not e) g))
+                    (@ k i) (@ w i))]
+             [t2 (+ (bit-xor (rotr a 2) (rotr a 13) (rotr a 22)) (bit-xor (bit-and a b) (bit-and a c) (bit-and b c)))])
+        (set! hh g)
+        (set! g f)
+        (set! f e)
+        (set! e (+ d t1))
+        (set! d c)
+        (set! c b)
+        (set! b a)
+        (set! a (+ t1 t2))))
+    (+= (@ (-> s state) 0) a)
+    (+= (@ (-> s state) 1) b)
+    (+= (@ (-> s state) 2) c)
+    (+= (@ (-> s state) 3) d)
+    (+= (@ (-> s state) 4) e)
+    (+= (@ (-> s state) 5) f)
+    (+= (@ (-> s state) 6) g)
+    (+= (@ (-> s state) 7) hh)))
+
+(define (sha256-init! [s (ptr sha256)])
+  (set! (@ (-> s state) 0) #x6a09e667)
+  (set! (@ (-> s state) 1) #xbb67ae85)
+  (set! (@ (-> s state) 2) #x3c6ef372)
+  (set! (@ (-> s state) 3) #xa54ff53a)
+  (set! (@ (-> s state) 4) #x510e527f)
+  (set! (@ (-> s state) 5) #x9b05688c)
+  (set! (@ (-> s state) 6) #x1f83d9ab)
+  (set! (@ (-> s state) 7) #x5be0cd19)
+  (set! (-> s filled) 0)
+  (set! (-> s length) 0))
+
+(define (sha256-add! [s (ptr sha256)] [b (slice u8)])
+  (let ([p (-> b items)] [n (-> b length)] [i u32 0])
+    (+= (-> s length) (cast u64 n))
+    (when (> (-> s filled) 0)
+      (while (and (< i n) (< (-> s filled) 64))
+        (set! (@ (-> s block) (-> s filled)) (@ p i))
+        (+= (-> s filled) 1)
+        (+= i 1))
+      (when (== (-> s filled) 64)
+        (compress! s (-> s block))
+        (set! (-> s filled) 0)))
+    (while (<= (+ i 64) n)
+      (compress! s (+ p i))
+      (+= i 64))
+    (while (< i n)
+      (set! (@ (-> s block) (-> s filled)) (@ p i))
+      (+= (-> s filled) 1)
+      (+= i 1))))
+
+;; into takes the 32 bytes of the digest.
+(define (sha256-end! [s (ptr sha256)] [into (slice u8)])
+  (let ([bits (* (-> s length) 8)])
+    (set! (@ (-> s block) (-> s filled)) 128)
+    (+= (-> s filled) 1)
+    (when (> (-> s filled) 56)
+      (while (< (-> s filled) 64)
+        (set! (@ (-> s block) (-> s filled)) 0)
+        (+= (-> s filled) 1))
+      (compress! s (-> s block))
+      (set! (-> s filled) 0))
+    (while (< (-> s filled) 56)
+      (set! (@ (-> s block) (-> s filled)) 0)
+      (+= (-> s filled) 1))
+    (for ([i u32 0]) (< i 8) (+= i 1)
+      (set! (@ (-> s block) (+ 56 i)) (cast u8 (>> bits (* 8 (- 7 i))))))
+    (compress! s (-> s block))
+    (for ([i u32 0]) (< i 8) (+= i 1)
+      (let ([h (@ (-> s state) i)])
+        (set! (@ into (* i 4)) (cast u8 (>> h 24)))
+        (set! (@ into (+ (* i 4) 1)) (cast u8 (>> h 16)))
+        (set! (@ into (+ (* i 4) 2)) (cast u8 (>> h 8)))
+        (set! (@ into (+ (* i 4) 3)) (cast u8 h))))))
+
+(define (sha256-of [b (slice u8)] [into (slice u8)])
+  (let ([s sha256])
+    (sha256-init! (& s))
+    (sha256-add! (& s) b)
+    (sha256-end! (& s) into)))

package/substrate/compiler/substrate.sub

@@ -8,7 +8,8 @@
          += -= *= /= %= <<= >>= bit-and= bit-or= bit-xor=
          heap-start sbrk reset-stack!
          host-write host-trap host-args host-os host-exit host-instantiate host-export-index
-         host-program-modules host-module-bytes handler event-head untagged-handler! trap-handler! printf print-bytes
+         host-program-modules host-module-bytes host-compiled-file handler event-head untagged-handler! trap-handler!
+         printf print-bytes
          output-to! test expect expect-equal test-failed test-skipped
          buffer-add-entries! entry-strings
          sqrt fabs floor ceil trunc nearbyint copysign sqrtf fabsf floorf ceilf truncf nearbyintf copysignf
@@ -98,6 +99,7 @@
 (import export_index "host" "export_index" (i32 i32 i32 i32 -> i32))
 (import program_modules "host" "program_modules" (i32 -> i32))
 (import module_bytes "host" "module_bytes" (i32 i32 i32 -> i32))
+(import compiled_file "host" "compiled_file" (i32 i32 i32 -> i32))
 
 (define (host-write [fd i32] [b (slice u8)]) #:inline -> i32 (write fd (cast i32 (-> b items)) (cast i32 (-> b length))))
 (define (host-trap [s string]) #:inline (trap (cast i32 (-> s bytes)) (cast i32 (-> s length))))
@@ -142,6 +144,9 @@
 (define (host-module-bytes [name string]) -> (slice u8)
   (let* ([n u32 0] [p (module_bytes (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (& n)))])
     (slice (cast (ptr u8) p) n)))
+(define (host-compiled-file [name string]) -> (slice u8)
+  (let* ([n u32 0] [p (compiled_file (cast i32 (-> name bytes)) (cast i32 (-> name length)) (cast i32 (& n)))])
+    (slice (cast (ptr u8) p) n)))
 
 ;; ---- output ----
 

package/substrate/host/node/worker-thread.mjs

@@ -44,7 +44,7 @@ parentPort.on('message', (m) => {
       absent: new Set(['stdin', 'signal']),
       memoryPages: m.pages,
     });
-    const entry = host.load([...wasm.keys()], (name) => wasm.get(name));
+    const entry = host.load([...wasm.keys()], (name) => wasm.get(name), m.compiled);
     if (!entry) {
       side.ended(2, host.lastError);
       return;

package/substrate/host/node/worker.mjs

@@ -42,6 +42,7 @@ export function workers(setup) {
       thread.postMessage({
         type: 'start',
         modules: plan.modules,
+        compiled: plan.compiled,
         entry: plan.entry,
         argument: plan.argument,
         grants: plan.grants,

package/substrate/host/subhost-core.mjs

@@ -174,9 +174,11 @@ export function createHost(platform) {
   // A memory's malloc, from the module that exports both.
   const allocators = new WeakMap();
   let lastError = '';
-  // The running program: its modules' names in load order, and how to get one's bytes.
+  // 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 = [];
   let programBytes = null;
+  let programCompiled = null;
   let entry = null;
   let onEvent = null;
   let onTrap = null;
@@ -344,7 +346,7 @@ export function createHost(platform) {
       parseGrants: (list) => platform.parseGrants(list),
       moduleNames: () => (platform.modules ? [...platform.modules.keys()] : []),
       module: (name) => (platform.modules ? platform.modules.get(name) : undefined),
-      program: () => ({ names: programNames, bytes: programBytes }),
+      program: () => ({ names: programNames, bytes: programBytes, compiled: programCompiled }),
       // named gives the module and the export name of the program's function at the index in the table, or null.
       named(index) {
         const table = self.exports.table;
@@ -412,6 +414,10 @@ export function createHost(platform) {
         const name = string(np, nl);
         return programNames.includes(name) ? give(programBytes(name), out) : 0;
       },
+      compiled_file(np, nl, out) {
+        const bytes = programCompiled && programCompiled.get(string(np, nl));
+        return bytes ? give(bytes, out) : 0;
+      },
     };
   }
 
@@ -499,9 +505,10 @@ export function createHost(platform) {
     return true;
   }
 
-  function load(names, bytesOf) {
+  function load(names, bytesOf, compiled = null) {
     programNames = names;
     programBytes = bytesOf;
+    programCompiled = compiled;
     running = true;
     try {
       for (const name of names) {

package/substrate/host/subhost.mjs

@@ -61,6 +61,18 @@ const names = read(`${dir}/program`).toString().split(/\r?\n/).filter((n) => n !
 const outside = names.find((name) => /[/\\]/.test(name));
 if (outside !== undefined) fail(`${dir}/program lists ${outside}, which is not in ${dir}`);
 const bytes = new Map(names.map((name) => [name, read(`${dir}/${name}.wasm`)]));
+// 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();
+if (fs.existsSync(`${dir}/compiled`)) {
+  const list = read(`${dir}/compiled`);
+  const hashes = list.toString().split(/\r?\n/).filter((l) => l !== '').map((l) => l.slice(0, l.indexOf(' ')));
+  const bad = hashes.find((h) => !/^[0-9a-f]+$/.test(h));
+  if (bad !== undefined) fail(`${dir}/compiled lists ${bad}, which is not a hash`);
+  compiled.set('compiled', list);
+  if (hashes.length > 0) compiled.set('compiled.map', read(`${dir}/compiled.map`));
+  for (const h of hashes) compiled.set(`${h}.subc`, read(`${dir}/${h}.subc`));
+}
 
 // The program process.exec_at_end kept (node/process.mjs).
 const atEnd = () => {
@@ -93,7 +105,7 @@ const host = createHost({
   keyOf: (bytes) => crypto.createHash('sha256').update(bytes).digest('hex'),
 });
 
-const entry = host.load(names, (name) => bytes.get(name));
+const entry = host.load(names, (name) => bytes.get(name), compiled);
 if (!entry) {
   process.stderr.write(`error: ${host.lastError}\n`);
   process.exit(2);

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

@@ -110,7 +110,18 @@ export async function boot(options) {
     for (const bytes of wasm.values()) for (const name of importedModules(bytes)) wanted.add(name);
     modules = await modules(wanted);
   }
-  return run({ ...options, files, modules }, names, wasm);
+  // 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);
 }
 
 export function run(options, names, wasm) {
@@ -157,7 +168,7 @@ export function run(options, names, wasm) {
     return host.call(f, args);
   };
 
-  app.entry = host.load(names, (name) => wasm.get(name));
+  app.entry = host.load(names, (name) => wasm.get(name), options.compiled || null);
   if (!app.entry && options.entry) {
     ended(2, host.lastError);
   } else if (!app.entry) {

package/substrate/host/web/worker-script.mjs

@@ -62,6 +62,7 @@ self.onmessage = async (e) => {
     }
     const app = run({
       args: m.args ?? [m.argument],
+      compiled: m.compiled,
       files: m.files,
       cwd: m.cwd,
       output: side.write,

package/substrate/host/web/worker.mjs

@@ -11,6 +11,7 @@ export function workers() {
       thread.postMessage({
         type: 'start',
         modules: plan.modules,
+        compiled: plan.compiled,
         entry: plan.entry,
         argument: plan.argument,
         files: app.files,

package/substrate/host/worker.mjs

@@ -63,9 +63,11 @@ export function workerModule({ spawn }) {
   function start(entry, argument, time, pages, heard, tag, app, err, grants, setup) {
     const program = caller.program();
     const modules = program.names.map((name) => [name, program.bytes(name)]);
+    const { compiled } = program;
     let thread;
     try {
-      thread = spawn({ modules, entry, argument, grants, names: caller.moduleNames(), pages, heard, ...setup }, app);
+      thread = spawn({ modules, compiled, entry, argument, grants, names: caller.moduleNames(), pages, heard, ...setup },
+                     app);
     } catch (e) {
       caller.fail(err, e.message);
       return 0;