@sasjs/cli 6.19.1 → 6.19.3

package/build/commands/build/internal/mockSite/assets/boot.js

@@ -114,13 +114,41 @@
     stamp = ''
   }
 
-  // Registered relative to the page, and scoped to the directory it sits in:
-  // the site is served from the origin root on one host and from a folder on
-  // another (a demonstration site beside its own docs), and the worker's scope
-  // has to follow the page rather than assume the root.
+  // Registered against the loader's own URL, which sits in <base>/host/, and
+  // scoped to the folder above it: the site is served from the origin root on
+  // one host and from a folder on another (a demonstration site beside its own
+  // docs). The page cannot be the reference - at `<base>` with no trailing
+  // slash a page-relative URL names the origin root, and './' resolves to '/',
+  // which is the mis-registration this is here to avoid.
+  //
+  // The tag the build emits is absolute (`<base>/host/boot.js`) when the target
+  // names a folder, and relative (`host/boot.js`) when it does not - so a site
+  // published in a folder without naming it depends on its own URL ending in a
+  // slash - and in both cases the loader's own URL then carries `<base>`. The
+  // fallback below is for the case where there is no currentScript to read.
+  var loaderSrc = (script && script.src) || loaderUrl()
+
+  // The loader always sits in <base>/host/, so without a currentScript the page
+  // still names the base. A path that does not end in a slash is ambiguous: it
+  // is the folder when its last segment has no dot (`/demo`), and a file when it
+  // does (`/demo/index.html`) - only the second has a segment to drop.
+  // `location.href` cannot do this: one level above `/demo` is the origin root.
+  function loaderUrl() {
+    var page = location.pathname
+    var lastSegment = page.slice(page.lastIndexOf('/') + 1)
+    var base
+
+    if (lastSegment.indexOf('.') === -1) {
+      base = page.charAt(page.length - 1) === '/' ? page : page + '/'
+    } else {
+      base = page.slice(0, page.lastIndexOf('/') + 1)
+    }
+
+    return location.origin + base + 'host/boot.js'
+  }
   navigator.serviceWorker
-    .register(new URL('sw.js' + stamp, location.href).href, {
-      scope: './',
+    .register(new URL('../sw.js' + stamp, loaderSrc).href, {
+      scope: new URL('../', loaderSrc).pathname,
       updateViaCache: 'none'
     })
     .then(function () {

package/build/commands/build/internal/mockSite/assets/persist.js

@@ -89,6 +89,63 @@
 
   const clearAll = () => withStore('readwrite', (store) => store.clear())
 
+  /**
+   * The build this site is, as the page can see it: mock-config.json carries the
+   * stamp the build wrote over its host code and the seed it lays out. Read here
+   * rather than passed down, because the page decides whether to keep a stored
+   * drive before the worker is asked anything.
+   *
+   * The base is the worker's script URL, not the page's: the site can be served
+   * from a folder, and a page reached at `/demo` (no trailing slash) has a
+   * baseURI of `https://host/demo`, which resolves `host/mock-config.json` one
+   * level too high. The worker sits at `<base>/sw.js` and fetches the same file
+   * relative to itself, so its URL is the one definition of the site folder.
+   *
+   * Empty when the config cannot be read, which leaves the drive alone: a page
+   * that cannot tell which build it is has no business dropping one.
+   */
+  const readBuildStamp = async (controller) => {
+    try {
+      const script = controller && controller.scriptURL
+      // no controller URL means no way to name the site folder; keep the drive
+      if (!script) return ''
+      const res = await fetch(new URL('host/mock-config.json', script), {
+        cache: 'no-store'
+      })
+      if (!res.ok) return ''
+      const config = await res.json()
+      return config && typeof config.buildStamp === 'string'
+        ? config.buildStamp
+        : ''
+    } catch (e) {
+      return ''
+    }
+  }
+
+  /** Where the stamp of the build that wrote the stored drive is kept. */
+  const BUILD_STAMP_KEY = 'sasjs-mock-build'
+
+  /**
+   * The stamp recorded for the stored drive, '' when there is none (a drive
+   * from a build before stamps existed) and null when storage cannot be read at
+   * all - which is not the same answer, and must not drop a drive on every load.
+   */
+  const storedBuildStamp = () => {
+    try {
+      return localStorage.getItem(BUILD_STAMP_KEY) || ''
+    } catch (e) {
+      return null
+    }
+  }
+
+  const keepBuildStamp = (stamp) => {
+    try {
+      if (stamp) localStorage.setItem(BUILD_STAMP_KEY, stamp)
+    } catch (e) {
+      /* a browser that refuses storage still runs the site */
+    }
+  }
+
   const waitForController = () =>
     new Promise((resolve) => {
       if (navigator.serviceWorker.controller)
@@ -210,6 +267,32 @@
       console.error('[sasjs-mock] could not read storage: ' + e)
     }
 
+    // A stored drive outlives the build that wrote it, so a returning visitor
+    // would keep running that build's services - including ones the app being
+    // loaded no longer matches. This build stamps the seed it ships, and a drive
+    // whose stamp is absent or different is dropped rather than merged: a
+    // partial drive from two builds is the one thing that cannot be reasoned
+    // about. A site whose config carries no stamp keeps its drives, which is the
+    // behaviour every build before this one had.
+    const stamp = await readBuildStamp(controller)
+    const previous = storedBuildStamp()
+    if (
+      Object.keys(files).length &&
+      stamp &&
+      previous !== null &&
+      previous !== stamp
+    ) {
+      console.info(
+        '[sasjs-mock] the stored drive is from another build - seeding this one'
+      )
+      try {
+        await clearAll()
+      } catch (e) {
+        console.error('[sasjs-mock] could not clear storage: ' + e)
+      }
+      files = {}
+    }
+
     if (Object.keys(files).length) {
       window.__sasjsMockBoot = await askWorker(
         { type: 'sasjs-load', files },
@@ -221,6 +304,8 @@
         'sasjs-seed-ack'
       )
     }
+    if (window.__sasjsMockBoot && !window.__sasjsMockBoot.error)
+      keepBuildStamp(stamp)
     return window.__sasjsMockBoot
   })()
 })()

package/build/commands/build/internal/mockSite/assets/runtime-core.js

@@ -1100,7 +1100,16 @@ return _webout;
       BUFFERS
     )
   } catch (e) {
-    thrown = e && e.stack ? e.stack : String(e)
+    // The stack alone is not an error message: WebKit's carries frames only, so
+    // a failure there arrives at the app as "anonymous@... > Function:219:1" with
+    // the reason nowhere in it. V8's stack already opens with the message, so it
+    // is prepended only when it is missing rather than repeated.
+    const message = e && e.message ? String(e.message) : ''
+    const stack = e && e.stack ? String(e.stack) : ''
+    thrown =
+      stack && message && stack.indexOf(message) < 0
+        ? message + '\n' + stack
+        : stack || String(e)
     logLines.push(String(thrown))
   }
 
@@ -1415,6 +1424,13 @@ const boot = async () => {
   await loadMockConfig()
   await loadWeboutPrelude()
   const { source, files: seed } = await fetchDrive()
+  // a seed replaces the drive, it does not merge into one: the worker survives
+  // page loads, so it can still hold the drive it was given last time, and any
+  // file only that drive had would otherwise outlive the build that wrote it
+  FILES.clear()
+  SIZES.clear()
+  DIRS.clear()
+  DIRS.add('/')
   mkdirp(DRIVE_APP)
   mkdirp(`${DRIVE_ROOT}/files`)
   for (const [path, contents] of Object.entries(seed)) {

package/build/commands/build/internal/mockSite/mockSite.js

@@ -517,8 +517,9 @@ var escapeAttribute = function (value) {
  * order, plus the inline snippets some pages use to set up a global before the
  * bundle runs - so the host does not dictate how the app is built.
  */
-var bootTag = function (scripts, version) {
-    return "<script src=\"host/boot.js?v=".concat(version, "\" data-scripts='").concat(escapeAttribute(JSON.stringify(scripts)), "'></script>");
+var bootTag = function (scripts, version, basePath) {
+    if (basePath === void 0) { basePath = ''; }
+    return "<script src=\"".concat(basePath ? "".concat(basePath, "/host/boot.js") : 'host/boot.js', "?v=").concat(version, "\" data-scripts='").concat(escapeAttribute(JSON.stringify(scripts)), "'></script>");
 };
 /**
  * Script types the browser executes. Anything else (`application/ld+json`, a
@@ -531,28 +532,36 @@ var EXECUTABLE_TYPES = [
     'application/javascript'
 ];
 /**
- * The folder the site is published under, as a path with no trailing slash.
+ * The folder the site is published under, with a leading slash and no trailing
+ * one.
  *
  * Empty for the origin root, which is the ordinary case. A host that serves the
  * demonstration site beside its documentation (a GitHub Pages site whose root is
  * the docs) names the folder here, and every path the build emits follows it.
+ *
+ * The shapes the released build accepts keep working - a bare `demo`, a leading
+ * or trailing slash, surrounding space - and are normalised rather than
+ * refused, because a `fix(mock)` release must not fail a build that passes
+ * today. The sasjsconfig schema states the canonical form; this only rejects
+ * what could never have worked, a segment that is `.`, `..` or empty.
  */
 var normaliseBasePath = function (value) {
     if (!value)
         return '';
-    var base = String(value).trim();
-    if (!base.startsWith('/'))
-        base = '/' + base;
-    base = base.replace(/\/+$/, '');
-    var segments = base.split('/').slice(1);
+    var segments = String(value)
+        .trim()
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .split('/');
     if (!segments.length ||
         segments.some(function (segment) {
-            return !/^[A-Za-z0-9._~-]+$/.test(segment) ||
+            return !segment ||
                 segment === '.' ||
-                segment === '..';
+                segment === '..' ||
+                !/^[A-Za-z0-9._~-]+$/.test(segment);
         }))
         throw new Error("mockWebBasePath is not a folder path: ".concat(JSON.stringify(value), ". Use a path such as \"/demo\", or leave it unset for the origin root."));
-    return base;
+    return '/' + segments.join('/');
 };
 /**
  * Tells the interface that this page is answered by the browser host.
@@ -648,7 +657,7 @@ var patchIndexHtml = function (html, version, basePath) {
         return '';
     });
     if (scripts.length) {
-        var tag = bootTag(scripts, version);
+        var tag = bootTag(scripts, version, basePath);
         patched = /<\/body>/i.test(patched)
             ? patched.replace(/<\/body>/i, "".concat(tag, "\n</body>"))
             : patched + tag;
@@ -674,7 +683,7 @@ var patchIndexHtml = function (html, version, basePath) {
  */
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
+        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
         var e_8, _e;
         var _f, _g, _h, _j, _k, _l;
         return __generator(this, function (_m) {
@@ -828,6 +837,12 @@ function buildMockSite(target) {
                         .reduce(function (all, buf) { return Buffer.concat([all, buf]); }, Buffer.alloc(0)))
                         .digest('hex')
                         .slice(0, 10);
+                    buildStamp = (0, crypto_1.createHash)('md5')
+                        .update(JSON.stringify(Object.keys(seed)
+                        .sort()
+                        .map(function (key) { return [key, seed[key]]; })))
+                        .digest('hex')
+                        .slice(0, 10);
                     swPath = path_1.default.join(outputFolder, 'sw.js');
                     fs_1.default.writeFileSync(swPath, fs_1.default
                         .readFileSync(swPath, 'utf8')
@@ -848,6 +863,7 @@ function buildMockSite(target) {
                         jsPrograms: jsPrograms,
                         programFolders: PROGRAM_FOLDERS,
                         snapshot: hasSnapshot,
+                        buildStamp: buildStamp,
                         builtAt: new Date().toISOString()
                     }, null, 2));
                     indexPath = path_1.default.join(outputFolder, 'index.html');

package/build/commands/build/internal/mockSite/spec/boot.spec.js

@@ -56,15 +56,24 @@ var loadBoot = function (specs, options) {
         };
         return element;
     };
+    // The page carries an absolute boot tag, `<base>/host/boot.js`, so the
+    // loader's own URL names the folder whether or not the page URL ends in a
+    // slash - a relative tag would resolve against the page and, at `/demo`, name
+    // the origin root.
+    var pageHref = options.href || 'http://localhost:8123/';
+    var stamp = options.noStamp ? '' : '?v=abc123';
+    // the tag the build emits: absolute when the target names a folder, relative
+    // to the page when it does not
+    var loaderSrc = options.basePath
+        ? "".concat(new URL(pageHref).origin).concat(options.basePath, "/host/boot.js").concat(stamp)
+        : new URL('host/boot.js' + stamp, pageHref).href;
     var document = {
         currentScript: options.noScript
             ? null
             : {
                 // the builder stamps the boot tag with the host version, and the
                 // loader reuses that query for the worker's own URL
-                src: options.noStamp
-                    ? 'http://localhost:8123/host/boot.js'
-                    : 'http://localhost:8123/host/boot.js?v=abc123',
+                src: loaderSrc,
                 getAttribute: function (name) {
                     if (name !== 'data-scripts')
                         return null;
@@ -126,7 +135,9 @@ var loadBoot = function (specs, options) {
         }
     };
     global.location = {
-        href: options.href || 'http://localhost:8123/',
+        href: pageHref,
+        pathname: new URL(pageHref).pathname,
+        origin: new URL(pageHref).origin,
         reload: function () { return timeline.push('reload'); }
     };
     jest.spyOn(console, 'error').mockImplementation(function () { });
@@ -185,7 +196,7 @@ describe('the boot loader', function () {
                     // root on one host and from /demo beside its docs on another.
                     expect(registered).toEqual([
                         'http://localhost:8123/sw.js?v=abc123 ' +
-                            JSON.stringify({ scope: './', updateViaCache: 'none' })
+                            JSON.stringify({ scope: '/', updateViaCache: 'none' })
                     ]);
                     return [2 /*return*/];
             }
@@ -196,13 +207,104 @@ describe('the boot loader', function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    registered = loadBoot([], { href: 'http://localhost:8123/demo/' }).registered;
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/',
+                        basePath: '/demo'
+                    }).registered;
                     return [4 /*yield*/, settle()];
                 case 1:
                     _a.sent();
                     expect(registered).toEqual([
                         'http://localhost:8123/demo/sw.js?v=abc123 ' +
-                            JSON.stringify({ scope: './', updateViaCache: 'none' })
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers under the folder when the page has no trailing slash', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo',
+                        basePath: '/demo'
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js?v=abc123 ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('finds the folder from the page when the document has no currentScript', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()
+                        // no tag, no version: the fallback cannot carry the build's stamp, so this
+                        // path registers the folder's worker without a cache-busting query
+                    ];
+                case 1:
+                    _a.sent();
+                    // no tag, no version: the fallback cannot carry the build's stamp, so this
+                    // path registers the folder's worker without a cache-busting query
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('treats a path with no trailing slash as the folder, not a file', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
+                    ]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('drops a file name from the path, and keeps the folder above it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var registered;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    registered = loadBoot([], {
+                        href: 'http://localhost:8123/demo/index.html',
+                        basePath: '/demo',
+                        noScript: true
+                    }).registered;
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(registered).toEqual([
+                        'http://localhost:8123/demo/sw.js ' +
+                            JSON.stringify({ scope: '/demo/', updateViaCache: 'none' })
                     ]);
                     return [2 /*return*/];
             }

package/build/commands/build/internal/mockSite/spec/mockSite.spec.js

@@ -136,6 +136,34 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('stamps the config with the build, so a page can tell one drive from another', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var first;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    first = readConfig();
+                    expect(first.buildStamp).toMatch(/^[0-9a-f]{10}$/);
+                    // an identical build keeps its stamp: a rebuild that changes nothing must
+                    // not throw a returning visitor's drive away
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 2:
+                    // an identical build keeps its stamp: a rebuild that changes nothing must
+                    // not throw a returning visitor's drive away
+                    _a.sent();
+                    expect(readConfig().buildStamp).toBe(first.buildStamp);
+                    // a changed service changes the stamp, which is what makes the page re-seed
+                    // rather than run the previous build's program
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'services', 'public', 'getdata.js'), 'const a = 999\n');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 3:
+                    _a.sent();
+                    expect(readConfig().buildStamp).not.toBe(first.buildStamp);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('stamps the seed with the drive format the runtime checks', function () { return __awaiter(void 0, void 0, void 0, function () {
         return __generator(this, function (_a) {
             switch (_a.label) {
@@ -375,9 +403,9 @@ describe('browser-hosted build', function () {
                     _a.sent();
                     html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
                     expect(html).toContain('serverurl="/demo"');
-                    // the loader and the host's files stay relative to the page, so the same
-                    // build works at the origin root and under the folder
-                    expect(html).toContain('<script src="host/boot.js?v=');
+                    // the boot tag is absolute and names the folder, so a page at `/demo` with
+                    // no trailing slash still loads the loader from `/demo/host/`
+                    expect(html).toContain('<script src="/demo/host/boot.js?v=');
                     return [2 /*return*/];
             }
         });
@@ -395,6 +423,50 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('normalises the folder shapes the released build already accepts', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, _b, value, html_1, e_3_1, html;
+        var e_3, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    _d.trys.push([0, 5, 6, 7]);
+                    _a = __values(['/demo/', ' /demo ', 'demo']), _b = _a.next();
+                    _d.label = 1;
+                case 1:
+                    if (!!_b.done) return [3 /*break*/, 4];
+                    value = _b.value;
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockWebBasePath: value }))];
+                case 2:
+                    _d.sent();
+                    html_1 = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html_1).toContain('serverurl="/demo"');
+                    _d.label = 3;
+                case 3:
+                    _b = _a.next();
+                    return [3 /*break*/, 1];
+                case 4: return [3 /*break*/, 7];
+                case 5:
+                    e_3_1 = _d.sent();
+                    e_3 = { error: e_3_1 };
+                    return [3 /*break*/, 7];
+                case 6:
+                    try {
+                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                    return [7 /*endfinally*/];
+                case 7: 
+                // explicit empty is the origin root, as it was before the option existed
+                return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockWebBasePath: '' }))];
+                case 8:
+                    // explicit empty is the origin root, as it was before the option existed
+                    _d.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).toContain('serverurl=""');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('points the app at itself and installs the boot loader', function () { return __awaiter(void 0, void 0, void 0, function () {
         var html;
         return __generator(this, function (_a) {
@@ -630,7 +702,7 @@ describe('browser-hosted build', function () {
     }); });
     it('stops seeding bytes once the drive budget is spent, and names the file', function () { return __awaiter(void 0, void 0, void 0, function () {
         var chunk, _a, _b, name_1, seed, seeded;
-        var e_3, _c;
+        var e_4, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -643,12 +715,12 @@ describe('browser-hosted build', function () {
                             fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', name_1), chunk);
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_4) throw e_4.error; }
                     }
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
                         // the budget is spent in path order, so the drive is the same on every host:
@@ -734,7 +806,7 @@ describe('browser-hosted build', function () {
      */
     it('builds an interface that has no services, and says the drive is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, _b, folder, warn, result;
-        var e_4, _c;
+        var e_5, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -749,12 +821,12 @@ describe('browser-hosted build', function () {
                             });
                         }
                     }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_5) throw e_5.error; }
                     }
                     warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
@@ -776,7 +848,7 @@ describe('browser-hosted build', function () {
      */
     it('warns when the build folder holds only folders that are not programs', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, _b, folder, warn, result;
-        var e_5, _c;
+        var e_6, _c;
         var _d;
         return __generator(this, function (_e) {
             switch (_e.label) {
@@ -790,12 +862,12 @@ describe('browser-hosted build', function () {
                             });
                         }
                     }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
                     finally {
                         try {
                             if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_6) throw e_6.error; }
                     }
                     write(path_1.default.join(root, 'sasjsbuild', 'docs', 'index.html'), '<html></html>');
                     warn = jest.spyOn((_d = process.logger) !== null && _d !== void 0 ? _d : console, 'warn');
@@ -898,8 +970,8 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('refuses a mockWebFolder that would delete the project or its inputs', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, _b, mockWebFolder, e_6_1;
-        var e_6, _c;
+        var _a, _b, mockWebFolder, e_7_1;
+        var e_7, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -930,14 +1002,14 @@ describe('browser-hosted build', function () {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 7];
                 case 5:
-                    e_6_1 = _d.sent();
-                    e_6 = { error: e_6_1 };
+                    e_7_1 = _d.sent();
+                    e_7 = { error: e_7_1 };
                     return [3 /*break*/, 7];
                 case 6:
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_6) throw e_6.error; }
+                    finally { if (e_7) throw e_7.error; }
                     return [7 /*endfinally*/];
                 case 7:
                     expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);

package/build/commands/build/internal/mockSite/spec/persist.spec.js

@@ -137,6 +137,10 @@ var loadPersist = function (options) {
     var controller = options.controller === undefined
         ? { postMessage: function (message) { return posted.push(message); } }
         : options.controller;
+    // a real controller names the site folder, which is how the page finds the
+    // config file; every case gets one unless it is testing that it is missing
+    if (controller && !controller.scriptURL)
+        controller.scriptURL = options.scriptURL || 'https://host.test/sw.js';
     var serviceWorker = {
         controller: controller,
         // Never resolves by default: the boot sequence then stops before it touches
@@ -158,6 +162,36 @@ var loadPersist = function (options) {
     var window = {};
     global.window = window;
     global.navigator = { serviceWorker: serviceWorker };
+    // the page reads its build stamp and what the stored drive was written by
+    var local = new Map();
+    if (options.storedStamp !== undefined)
+        local.set('sasjs-mock-build', options.storedStamp);
+    global.localStorage = options.storageUnavailable
+        ? {
+            getItem: function () {
+                throw new Error('storage is denied');
+            },
+            setItem: function () {
+                throw new Error('storage is denied');
+            }
+        }
+        : {
+            getItem: function (key) { return (local.has(key) ? local.get(key) : null); },
+            setItem: function (key, value) { return local.set(key, value); }
+        };
+    global.document = {
+        baseURI: options.baseURI || 'https://host.test/'
+    };
+    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, ({
+                    ok: true,
+                    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({ buildStamp: options.buildStamp || '' })];
+                    }); }); }
+                })];
+        });
+    }); });
     var idb = options.seeded
         ? (function () {
             var fake = createIndexedDB();
@@ -171,7 +205,15 @@ var loadPersist = function (options) {
     global.indexedDB = idb;
     require('../assets/persist.js');
     var reply = function (data) { return __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: data }); }); };
-    return { window: window, listeners: listeners, removed: removed, posted: posted, reply: reply, rows: idb.rows };
+    return {
+        window: window,
+        listeners: listeners,
+        removed: removed,
+        posted: posted,
+        reply: reply,
+        rows: idb.rows,
+        stored: local
+    };
 };
 describe('page-side store', function () {
     afterEach(function () {
@@ -179,6 +221,9 @@ describe('page-side store', function () {
         delete global.window;
         delete global.navigator;
         delete global.indexedDB;
+        delete global.document;
+        delete global.localStorage;
+        delete global.fetch;
     });
     it('asks the worker for a snapshot and drops the listener when it replies', function () { return __awaiter(void 0, void 0, void 0, function () {
         var _a, window, listeners, removed, reply, before, pending;
@@ -473,4 +518,162 @@ describe('page-side store', function () {
             }
         });
     }); });
+    /**
+     * Answers whatever the page asks, so a boot test can assert on which question
+     * was asked rather than on the reply.
+     */
+    var answerBoot = function (controller, listeners) {
+        var answering = setInterval(function () {
+            var asked = controller.postMessage.mock.calls;
+            if (!asked.length)
+                return;
+            var type = asked[0][0].type;
+            __spreadArray([], __read(listeners), false).forEach(function (fn) { return fn({ data: { type: type + '-ack' } }); });
+        }, 5);
+        return function () { return clearInterval(answering); };
+    };
+    it("drops a drive written by another build and takes this build's seed", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stored, rows, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-a'
+                    }), window = _a.window, listeners = _a.listeners, stored = _a.stored, rows = _a.rows;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    expect(stored.get('sasjs-mock-build')).toBe('build-b');
+                    // the old drive is gone rather than merged with the new seed
+                    expect(rows.size).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('seeds over a drive from a build before the stamp existed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps a drive this build wrote', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-b'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the drive when the site publishes no stamp', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' }
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('keeps the drive when storage is refused, instead of seeding every load', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storageUnavailable: true
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _b.sent();
+                    stop();
+                    expect(controller.postMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'sasjs-load' }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reads the config from the folder the worker sits in, not the page URL', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var controller, _a, window, listeners, stop, _b, url, init;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    controller = { postMessage: jest.fn() };
+                    _a = loadPersist({
+                        controller: controller,
+                        ready: Promise.resolve({}),
+                        seeded: { '/sasjs/drive/stored.txt': 'stored' },
+                        buildStamp: 'build-b',
+                        storedStamp: 'build-a',
+                        scriptURL: 'https://host.test/demo/sw.js',
+                        baseURI: 'https://host.test/demo'
+                    }), window = _a.window, listeners = _a.listeners;
+                    stop = answerBoot(controller, listeners);
+                    return [4 /*yield*/, window.__sasjsMockReady];
+                case 1:
+                    _c.sent();
+                    stop();
+                    _b = __read(global.fetch.mock.calls[0], 2), url = _b[0], init = _b[1];
+                    expect(String(url)).toBe('https://host.test/demo/host/mock-config.json');
+                    expect(init).toEqual({ cache: 'no-store' });
+                    // and the stamp it read is acted on
+                    expect(controller.postMessage).toHaveBeenCalledWith({ type: 'sasjs-seed' });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
 });

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -136,6 +136,37 @@ describe('browser runtime', function () {
             }
         });
     }); });
+    it('replaces the drive when a seed arrives, rather than merging the two', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, info;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    return [4 /*yield*/, seedDrive(runtime, (_a = {}, _a[drivePath('first.txt')] = 'one', _a))
+                        // a worker outlives the page that seeded it, so a later seed - a page that
+                        // found a drive from another build, or a reset - arrives with the previous
+                        // drive still in memory. A file only that drive had must not survive it.
+                    ];
+                case 1:
+                    _b.sent();
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            return [2 /*return*/, url.includes('mock-config')
+                                    ? jsonResponse({ appLoc: appLoc })
+                                    : jsonResponse({ files: (_a = {}, _a[drivePath('second.txt')] = 'two', _a) })];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 2:
+                    info = _b.sent();
+                    expect(info.files).toBe(1);
+                    expect(Object.keys(runtime.dumpAll())).toEqual([drivePath('second.txt')]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('reads a drive file with no format stamp as the current format', function () { return __awaiter(void 0, void 0, void 0, function () {
         var runtime;
         var _a;
@@ -294,6 +325,25 @@ describe('browser runtime', function () {
         expect(result.log).toContain('boom');
         expect(result.webout).toBe('');
     });
+    it('carries the message when the stack does not, as WebKit reports one', function () {
+        var runtime = loadRuntime();
+        // WebKit's Error.stack is frames only - V8's opens with the message - so the
+        // body a service failure returns had the reason nowhere in it there, which is
+        // what a stack of "Function:219:1" in an app's error dialog looks like.
+        var result = runtime.run({
+            code: [
+                'const error = new Error("webout is not defined")',
+                'error.stack = "global code@https://host.test/sw.js:1:1"',
+                'throw error'
+            ].join('\n')
+        });
+        expect(result.error).toBe('webout is not defined\nglobal code@https://host.test/sw.js:1:1');
+    });
+    it('does not repeat a message the stack already carries', function () {
+        var runtime = loadRuntime();
+        var result = runtime.run({ code: 'throw new Error("boom")' });
+        expect(result.error.match(/boom/g)).toHaveLength(1);
+    });
     /**
      * The shims a service reaches for are node's, refusals included: a mock that
      * answered a copy from a missing file with an empty file, or accepted

package/build/types/index.d.ts

@@ -5,3 +5,4 @@ export { TargetScope } from './targetScope';
 export { TestFlow, Coverage, CoverageReport, CoverageSummary, CoverageType, CoverageState, TestResults, TestResultStatus, TestDescription, TestResult, TestResultDescription, TestResultCsv } from './testing';
 export { Flow, FlowWave, FlowWaveJob } from './flow';
 export * from './log';
+export * from './mockWebBasePath';

package/build/types/index.js

@@ -24,3 +24,4 @@ Object.defineProperty(exports, "CoverageType", { enumerable: true, get: function
 Object.defineProperty(exports, "CoverageState", { enumerable: true, get: function () { return testing_1.CoverageState; } });
 Object.defineProperty(exports, "TestResultStatus", { enumerable: true, get: function () { return testing_1.TestResultStatus; } });
 __exportStar(require("./log"), exports);
+__exportStar(require("./mockWebBasePath"), exports);

package/build/types/mockWebBasePath.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `mockWebBasePath` on a stream config.
+ *
+ * A `.ts` rather than a `.d.ts` so it compiles into `build/types/` with the
+ * rest of the package: tsc does not emit an ambient input file, and this one
+ * would otherwise type the CLI's own build and vanish from the published one.
+ *
+ * The option belongs to the mock target the CLI reads, but `StreamConfig` in
+ * @sasjs/utils 4.9.0 predates it, so without this the property is invisible to
+ * anyone typing a sasjsconfig and to anything that round-trips a target through
+ * the type. The field lands upstream in sasjs/utils#317; when the pin moves past
+ * that release, delete this file and the declaration merges from the package
+ * itself.
+ */
+export {};
+declare module '@sasjs/utils/types/config' {
+    interface StreamConfig {
+        /**
+         * The folder the mock site is published in, as a path with no trailing
+         * slash (`/demo`). Unset means the origin root.
+         */
+        mockWebBasePath?: string;
+    }
+}

package/build/types/mockWebBasePath.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.19.1"
+  "version": "6.19.3"
 }