@sasjs/cli 6.15.0 → 6.16.0

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

@@ -23,10 +23,19 @@
  * The drive is persisted by the page (host/persist.js) and the identity is not:
  * an account, group, permission rule or client created through these routes
  * lives in this worker's memory, so a worker the browser terminates starts again
- * from the fixture. Edits that must survive a restart belong on a server.
+ * from the fixture. Edits that must survive a restart belong on a server. The
+ * activity log the Admin routes report is in this worker's memory for the same
+ * reason.
+ *
+ * Every operation in @sasjs/api's route table is answered here: the drive, the
+ * sign-in flow, the records, the runs, the sessions, the diagnostics and logs,
+ * the directory import, the app-stream delete, the linter and the home page. The
+ * services are the package's; this file supplies the transport, the worker's own
+ * activity, and the browser's answers to questions a server asks its process.
  */
 importScripts('/host/runtime-core.js')
 importScripts('/host/api-browser.js')
+importScripts('/host/lint-browser.js')
 
 const R = self.SASjsMockRuntime
 
@@ -36,6 +45,10 @@ const R = self.SASjsMockRuntime
 // and the few capabilities a static origin does not have, which the package
 // reports as a 501 naming the missing service.
 const API = self.SASjsApi
+// The linter, bundled at build time from the installed @sasjs/api/code and
+// @sasjs/lint (see mockSite.ts). It is a separate script because the linter is
+// not part of the root package a service worker can import.
+const CODE = self.SASjsCode
 
 const DRIVE_STORE = R.driveStore
 const IDENTITY_STORE = new API.MemoryIdentityStore(API.DEFAULT_IDENTITY)
@@ -304,6 +317,175 @@ const tablesOf = (files) => {
 
 const RUNTIME = new BrowserRuntime()
 
+// ------------------------------------------------------------- host reports
+// The Admin routes ask a host what it is doing. A browser has no process, but it
+// does have a page, a heap and this worker's own activity, so the reports are
+// built from those rather than refused: the request log below is the log file,
+// and the memory reading is `performance.memory` where the browser exposes it.
+const STARTED = Date.now()
+const HOST_LOG_LIMIT = 2000
+const HOST_LOG = []
+const LOG_FILE = 'app.log'
+// the moment the last line was written, which is the file's mtime - not the
+// moment a report read it
+let LOG_UPDATED = null
+
+const logEntry = (line) => {
+  LOG_UPDATED = new Date().toISOString()
+  HOST_LOG.push(`${LOG_UPDATED} ${line}`)
+  if (HOST_LOG.length > HOST_LOG_LIMIT)
+    HOST_LOG.splice(0, HOST_LOG.length - HOST_LOG_LIMIT)
+}
+
+const logText = () => HOST_LOG.join('\n')
+const bytesOf = (text) => new TextEncoder().encode(String(text)).length
+
+const adminReports = {
+  diagnostics: async () => {
+    const perf = self.performance || {}
+    const heap = perf.memory || {}
+    const deviceBytes = Number(navigator.deviceMemory || 0) * 1024 ** 3
+    const total = Number(heap.jsHeapSizeLimit || deviceBytes || 0)
+    const used = Number(heap.usedJSHeapSize || 0)
+    return {
+      build: { version: 'dev', gitHash: 'unknown', buildDate: null },
+      server: {
+        // a page is not a process: the fields exist so a diagnostics screen
+        // renders, and their values describe this worker rather than inventing
+        // one behind it
+        mode: 'browser',
+        uptimeSeconds: (Date.now() - STARTED) / 1000,
+        startedAt: new Date(STARTED).toISOString(),
+        pid: 0,
+        nodeVersion: 'n/a',
+        platform: navigator.platform || 'browser',
+        arch: 'browser',
+        cpuCount: navigator.hardwareConcurrency || 1,
+        cpuModel: 'unknown',
+        loadAverage: [],
+        runTimes: ['js'],
+        sasjsRoot: '/'
+      },
+      memory: {
+        rssBytes: used,
+        heapTotalBytes: total,
+        heapUsedBytes: used,
+        externalBytes: 0,
+        systemTotalBytes: deviceBytes || total,
+        systemFreeBytes: Math.max(0, (deviceBytes || total) - used)
+      },
+      // a static origin cannot read the device's filesystem, which the document
+      // allows the host to state
+      filesystem: null,
+      folders: [],
+      logs: {
+        folder: 'worker memory',
+        // no file until a request has written one, and the stamp is the last
+        // write rather than the moment this report was assembled
+        fileCount: HOST_LOG.length ? 1 : 0,
+        totalBytes: bytesOf(logText()),
+        newestFile: HOST_LOG.length ? LOG_FILE : null,
+        newestModified: LOG_UPDATED
+      }
+    }
+  },
+  logs: async () =>
+    HOST_LOG.length
+      ? [
+          {
+            name: LOG_FILE,
+            sizeBytes: bytesOf(logText()),
+            modified: LOG_UPDATED
+          }
+        ]
+      : [],
+  logTail: async (fileName, lines) => {
+    if (fileName !== LOG_FILE || !HOST_LOG.length) return undefined
+    const tail = HOST_LOG.slice(-lines)
+    const content = tail.join('\n')
+    return {
+      fileName,
+      lines: tail.length,
+      bytesRead: bytesOf(content),
+      truncated: tail.length < HOST_LOG.length,
+      content
+    }
+  }
+}
+
+/**
+ * The directory the LDAP import reads.
+ *
+ * A browser has no bind to make, so the source is the fixture this host already
+ * signs in with: every account and group it names is present, so the import
+ * answers the route (the package owns the idempotency) and creates nothing. A
+ * host with a real directory supplies its own source.
+ */
+const directorySource = {
+  users: async () =>
+    API.DEFAULT_IDENTITY.users.map((user) => ({
+      username: user.username,
+      displayName: user.displayName
+    })),
+  groups: async () =>
+    API.DEFAULT_IDENTITY.groups.map((group) => ({
+      name: group.name,
+      members: group.users || []
+    }))
+}
+
+/**
+ * The app streams this host published: the site itself.
+ *
+ * The folder is the identity, so unpublishing the app the site was built for
+ * answers `success`; any other folder is the documented 404. The static files
+ * stay where they are - a worker cannot delete the site it is served from - so
+ * this is a record of the publication, not a filesystem operation.
+ */
+let registryPromise
+const registry = () => {
+  if (!registryPromise)
+    registryPromise = (async () => {
+      let appLoc
+      try {
+        const config = await (await fetch('/host/mock-config.json')).json()
+        appLoc = config && config.appLoc
+      } catch (e) {
+        appLoc = undefined
+      }
+      return new API.MemoryAppStreamRegistry(appLoc ? [appLoc] : [])
+    })()
+  return registryPromise
+}
+
+/**
+ * The page at `/`.
+ *
+ * The site's own index.html is already in the build, so the home route reads it
+ * from the static host and hands the package the page and a token of its
+ * contents. The package decides what to do with the token; these builds do not
+ * reference `index.bundle.js`, so in practice it is returned unchanged.
+ */
+const contentVersion = (text) => {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = Math.imul(hash, 0x01000193)
+  }
+  return (hash >>> 0).toString(16)
+}
+
+const homeService = API.createHomeService(async () => {
+  try {
+    const response = await fetch('/index.html', { cache: 'no-store' })
+    if (!response.ok) return undefined
+    const html = await response.text()
+    return { html, version: contentVersion(html) }
+  } catch (e) {
+    return undefined
+  }
+})
+
 const SERVICES = {
   drive: API.createDriveService(DRIVE_STORE),
   info: API.createInfoService(API.BROWSER_INFO),
@@ -315,11 +497,17 @@ const SERVICES = {
     runTimes: ['js']
   }),
   session: API.createSessionService(IDENTITY_STORE, RUNTIME),
-  authConfig: API.createAuthConfigService({})
-  // `admin`, `directory`, `code` and `home` are deliberately absent: this host
-  // has no process to report on, no LDAP connection to import from, and the
-  // linter is a node-only dependency. The package answers a 501 naming the
-  // capability rather than a 404 that reads like a typo in the caller.
+  authConfig: API.createAuthConfigService({}),
+  admin: API.createAdminService(adminReports),
+  directory: API.createDirectoryService(IDENTITY_STORE, directorySource),
+  registry: {
+    unpublish: async (appLoc) => (await registry()).unpublish(appLoc)
+  },
+  home: homeService,
+  // the package's own code service over the bundled linter; the host passes no
+  // lint config, so a buffer is linted against the linter's defaults - a mock
+  // has no `.sasjslint` tree to resolve one from
+  code: CODE.createCodeService({})
 }
 
 /** The routes this host performs itself, because the answer is not JSON. */
@@ -663,7 +851,7 @@ const contentsResponse = (answer, path) => {
   })
 }
 
-const handle = async (request, url) => {
+const routeRequest = async (request, url) => {
   const path = url.pathname.replace(/\/+$/, '') || '/'
   const query = {}
   for (const [k, v] of url.searchParams.entries()) query[k] = v
@@ -710,6 +898,14 @@ const handle = async (request, url) => {
     const answer = await API.dispatch(SERVICES, routeId, apiRequest)
     if (request.method !== 'GET') await persistChanges()
 
+    // the shell is a page, not a file the caller named: the document states
+    // text/html for it, and the extension of `/` says nothing
+    if (routeId === 'GET /')
+      return new Response(answer.contents, {
+        status: answer.status,
+        headers: { 'content-type': 'text/html; charset=utf-8' }
+      })
+
     if (answer.contents !== undefined)
       return contentsResponse(
         answer,
@@ -718,6 +914,7 @@ const handle = async (request, url) => {
     return json(answer.body, answer.status)
   } catch (e) {
     const message = (e && e.stack) || String(e)
+    logEntry(`${request.method} ${path} ERROR ${(e && e.message) || message}`)
     broadcast({ type: 'sasjs-host-error', path, message })
     // A refusal the API decided on carries its status and, where the route
     // answers an envelope, the body to send. The drive's routes send the message
@@ -736,14 +933,51 @@ const handle = async (request, url) => {
   }
 }
 
+/**
+ * One request, answered and written to the host's activity log.
+ *
+ * The log is what the Admin routes report: a browser has no server log file, so
+ * the worker keeps its own - method, path, status and how long it took - and the
+ * three admin routes read it back.
+ */
+const handle = async (request, url) => {
+  const started = Date.now()
+  const response = await routeRequest(request, url)
+  logEntry(
+    `${request.method} ${url.pathname} ${response.status} ${
+      Date.now() - started
+    }ms`
+  )
+  return response
+}
+
 self.addEventListener('fetch', (event) => {
   const url = new URL(event.request.url)
   if (url.origin !== self.location.origin) return
-  // The site's own page is the home route, and the static host serves it: a
-  // worker that answered `/` with the page it copied would be serving the app
-  // from two places. The API's own paths are answered here, including one the
-  // table does not have - falling through to the static host would put the SPA's
-  // index.html behind a typo in a caller's URL.
+
+  // The site's own page is answered by the home route, but a navigation must
+  // never be at the API's mercy: if that route throws or answers an error, the
+  // request falls back to the static host, which holds the same index.html. A
+  // broken API route can cost a client its data; it must not cost the app its
+  // page.
+  if (url.pathname === '/') {
+    event.respondWith(
+      (async () => {
+        try {
+          const response = await handle(event.request, url)
+          if (response && response.status < 400) return response
+        } catch (e) {
+          /* fall through to the static host */
+        }
+        return fetch(event.request)
+      })()
+    )
+    return
+  }
+
+  // The API's own paths are answered here, including one the table does not
+  // have - falling through to the static host would put the SPA's index.html
+  // behind a typo in a caller's URL.
   if (!/^\/(SASjsApi|SASLogon)(\/|$)/i.test(url.pathname)) return
   event.respondWith(handle(event.request, url))
 })

package/build/commands/build/internal/mockSite/mockSite.d.ts

@@ -28,6 +28,16 @@ export declare const WEBOUT_SENTINELS: {
     userId: string;
     apiServerUrl: string;
 };
+/**
+ * Builds `lint-browser.js` from the installed packages.
+ *
+ * The shim sources are written to the system temp folder, never beside this
+ * module: an installed package can be read-only (a global install, a pnpm store
+ * symlink, a container that builds as another user), and a build that writes
+ * inside it fails with EACCES for exactly the users least able to diagnose it.
+ * Resolution is kept by naming the CLI's `node_modules` through `nodePaths`.
+ */
+export declare const buildLintBundle: (destination: string) => void;
 /**
  * The bounds on what the browser drive seeds. A byte entry is carried as base64
  * in vfs-seed.json and held in the worker's memory, so a large artefact - an

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

@@ -1,4 +1,8 @@
 "use strict";
+var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -75,11 +79,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = exports.WEBOUT_SENTINELS = void 0;
+exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = exports.buildLintBundle = exports.WEBOUT_SENTINELS = void 0;
 exports.buildMockSite = buildMockSite;
 var crypto_1 = require("crypto");
 var fs_1 = __importDefault(require("fs"));
+var os_1 = __importDefault(require("os"));
 var path_1 = __importDefault(require("path"));
+var esbuild_1 = require("esbuild");
 var utils_1 = require("@sasjs/utils");
 /**
  * The webout() block is the one @sasjs/utils generates for the server, emitted
@@ -116,8 +122,141 @@ var ASSETS_FOLDER = path_1.default.join(__dirname, 'assets');
  */
 var API_BROWSER_BUILD = path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
 var toPosix = function (value) { return value.split(path_1.default.sep).join('/'); };
-var listFiles = function (folder, base) {
+/**
+ * The linter, as a service worker can run it.
+ *
+ * `@sasjs/api/code` is a node-only entry because `@sasjs/lint` resolves its
+ * configuration by walking a filesystem - but the linter's core (`lintText`,
+ * `formatText`) reads only the text it is given and the configuration it is
+ * passed, so the two can run anywhere the module graph can be built. This
+ * bundle is that graph: the package's own code service, the linter it wraps, and
+ * shims for the four node modules reached at import time (`path` and `os` for
+ * resolution, `fs` and `@sasjs/utils/file` for the config lookup that a mock
+ * never makes, because it hands the linter the default configuration).
+ *
+ * It is built from the installed @sasjs/api and @sasjs/lint on every mock
+ * build, so the rules a client sees are the version the CLI resolved - a
+ * committed bundle would be a second copy to drift.
+ */
+var LINT_BUNDLE_FILES = {
+    'entry.js': [
+        "import './process.js'",
+        "import { createCodeService } from '@sasjs/api/code'",
+        'globalThis.SASjsCode = { createCodeService }'
+    ].join('\n'),
+    'process.js': [
+        '// the linter reads process.env for a default and process.cwd() for a root;',
+        '// neither is a real lookup in a worker, and both are answered in one place',
+        'if (typeof globalThis.process === "undefined")',
+        '  globalThis.process = {',
+        '    env: {},',
+        '    platform: "browser",',
+        '    cwd: () => "/",',
+        '    versions: {},',
+        '    argv: [],',
+        '    version: "v0"',
+        '  }'
+    ].join('\n'),
+    'fs.js': [
+        'const unavailable = (name) => () => {',
+        '  throw new Error(name + " is not available in the browser host")',
+        '}',
+        'module.exports = {',
+        '  readFileSync: unavailable("readFileSync"),',
+        '  writeFileSync: unavailable("writeFileSync"),',
+        '  existsSync: () => false,',
+        '  promises: {}',
+        '}'
+    ].join('\n'),
+    'os.js': [
+        'module.exports = {',
+        '  homedir: () => "/",',
+        '  platform: () => "browser",',
+        '  tmpdir: () => "/tmp",',
+        '  EOL: "\\n"',
+        '}'
+    ].join('\n'),
+    'utils-file.js': [
+        'const unavailable = (name) => async () => {',
+        '  throw new Error(name + " is not available in the browser host")',
+        '}',
+        'module.exports = {',
+        '  readFile: unavailable("readFile"),',
+        '  writeFile: unavailable("writeFile"),',
+        '  fileExists: async () => false,',
+        '  listFilesInFolder: async () => []',
+        '}'
+    ].join('\n'),
+    'path.js': String.raw(templateObject_1 || (templateObject_1 = __makeTemplateObject(["// the posix half of path, which is all the linter uses: the rules name files,\n// and a mock hands the linter no folder to walk\nconst SEP = String.fromCharCode(92)\nconst clean = (value) =>\n  String(value).split(SEP).join(\"/\").replace(//+/g, \"/\")\nconst strip = (value) => clean(value).replace(//+$/, \"\")\nconst basename = (value) => strip(value).split(\"/\").pop() || \"\"\nconst extname = (value) => {\n  const base = basename(value)\n  const dot = base.lastIndexOf(\".\")\n  return dot > 0 ? base.slice(dot) : \"\"\n}\nconst dirname = (value) => {\n  const parts = clean(value).split(\"/\")\n  parts.pop()\n  return parts.join(\"/\") || \".\"\n}\nconst join = (...parts) => clean(parts.filter(Boolean).join(\"/\"))\nmodule.exports = {\n  sep: \"/\",\n  delimiter: \":\",\n  basename,\n  extname,\n  dirname,\n  join,\n  resolve: (...parts) => clean(parts.filter(Boolean).join(\"/\")),\n  relative: (from, to) => clean(to).replace(clean(from) + \"/\", \"\"),\n  isAbsolute: (value) => String(value).startsWith(\"/\"),\n  normalize: clean,\n  parse: (value) => ({\n    root: \"\",\n    dir: dirname(value),\n    base: basename(value),\n    ext: extname(value),\n    name: basename(value).slice(0, basename(value).length - extname(value).length)\n  })\n}"], ["// the posix half of path, which is all the linter uses: the rules name files,\n// and a mock hands the linter no folder to walk\nconst SEP = String.fromCharCode(92)\nconst clean = (value) =>\n  String(value).split(SEP).join(\"/\").replace(/\\/+/g, \"/\")\nconst strip = (value) => clean(value).replace(/\\/+$/, \"\")\nconst basename = (value) => strip(value).split(\"/\").pop() || \"\"\nconst extname = (value) => {\n  const base = basename(value)\n  const dot = base.lastIndexOf(\".\")\n  return dot > 0 ? base.slice(dot) : \"\"\n}\nconst dirname = (value) => {\n  const parts = clean(value).split(\"/\")\n  parts.pop()\n  return parts.join(\"/\") || \".\"\n}\nconst join = (...parts) => clean(parts.filter(Boolean).join(\"/\"))\nmodule.exports = {\n  sep: \"/\",\n  delimiter: \":\",\n  basename,\n  extname,\n  dirname,\n  join,\n  resolve: (...parts) => clean(parts.filter(Boolean).join(\"/\")),\n  relative: (from, to) => clean(to).replace(clean(from) + \"/\", \"\"),\n  isAbsolute: (value) => String(value).startsWith(\"/\"),\n  normalize: clean,\n  parse: (value) => ({\n    root: \"\",\n    dir: dirname(value),\n    base: basename(value),\n    ext: extname(value),\n    name: basename(value).slice(0, basename(value).length - extname(value).length)\n  })\n}"])))
+};
+/**
+ * The `node_modules` the CLI's own dependency lives in.
+ *
+ * esbuild resolves a bare import from the entry file upwards, which is wrong for
+ * a scratch entry outside the install: the walk would miss the installed
+ * packages entirely. `nodePaths` states where to look instead, and it is taken
+ * from `require.resolve` so it is the tree the CLI actually loaded from - a
+ * hoisted install, a nested one, and a pnpm store symlink all answer with their
+ * own location.
+ */
+var NODE_MODULES = (function () {
+    var resolved = require.resolve('@sasjs/api');
+    var marker = "".concat(path_1.default.sep, "node_modules").concat(path_1.default.sep);
+    var index = resolved.lastIndexOf(marker);
+    return index < 0 ? undefined : resolved.slice(0, index + marker.length - 1);
+})();
+/**
+ * Builds `lint-browser.js` from the installed packages.
+ *
+ * The shim sources are written to the system temp folder, never beside this
+ * module: an installed package can be read-only (a global install, a pnpm store
+ * symlink, a container that builds as another user), and a build that writes
+ * inside it fails with EACCES for exactly the users least able to diagnose it.
+ * Resolution is kept by naming the CLI's `node_modules` through `nodePaths`.
+ */
+var buildLintBundle = function (destination) {
     var e_1, _a;
+    var work = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'sasjs-lint-'));
+    try {
+        try {
+            for (var _b = __values(Object.entries(LINT_BUNDLE_FILES)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name_1 = _d[0], contents = _d[1];
+                fs_1.default.writeFileSync(path_1.default.join(work, name_1), contents);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        (0, esbuild_1.buildSync)({
+            entryPoints: [path_1.default.join(work, 'entry.js')],
+            bundle: true,
+            platform: 'browser',
+            format: 'iife',
+            outfile: destination,
+            nodePaths: NODE_MODULES ? [NODE_MODULES] : [],
+            alias: {
+                fs: path_1.default.join(work, 'fs.js'),
+                path: path_1.default.join(work, 'path.js'),
+                os: path_1.default.join(work, 'os.js'),
+                '@sasjs/utils/file': path_1.default.join(work, 'utils-file.js')
+            },
+            logLevel: 'silent'
+        });
+    }
+    catch (error) {
+        throw new Error("The browser lint bundle could not be built from @sasjs/api/code: ".concat((error && error.message) || error));
+    }
+    finally {
+        fs_1.default.rmSync(work, { recursive: true, force: true });
+    }
+};
+exports.buildLintBundle = buildLintBundle;
+var listFiles = function (folder, base) {
+    var e_2, _a;
     if (base === void 0) { base = folder; }
     var entries = fs_1.default.readdirSync(folder, { withFileTypes: true });
     var files = [];
@@ -131,17 +270,17 @@ var listFiles = function (folder, base) {
                 files.push(toPosix(path_1.default.relative(base, absolute)));
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
     finally {
         try {
             if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
         }
-        finally { if (e_1) throw e_1.error; }
+        finally { if (e_2) throw e_2.error; }
     }
     return files;
 };
 var copyFolder = function (from, to) {
-    var e_2, _a;
+    var e_3, _a;
     fs_1.default.mkdirSync(to, { recursive: true });
     try {
         for (var _b = __values(fs_1.default.readdirSync(from, { withFileTypes: true })), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -154,12 +293,12 @@ var copyFolder = function (from, to) {
                 fs_1.default.copyFileSync(source, target);
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_2) throw e_2.error; }
+        finally { if (e_3) throw e_3.error; }
     }
 };
 /**
@@ -221,7 +360,7 @@ var readDriveFile = function (absolute) {
     };
 };
 var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
-    var e_3, _a, e_4, _b, e_5, _c;
+    var e_4, _a, e_5, _b, e_6, _c;
     if (exclude === void 0) { exclude = []; }
     if (excludeFolders === void 0) { excludeFolders = []; }
     var files = {};
@@ -247,26 +386,26 @@ var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
                 candidates.push({ key: key, absolute: path_1.default.join(folder, relative) });
             };
             try {
-                for (var _d = (e_4 = void 0, __values(listFiles(folder))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                for (var _d = (e_5 = void 0, __values(listFiles(folder))), _e = _d.next(); !_e.done; _e = _d.next()) {
                     var relative = _e.value;
                     _loop_1(relative);
                 }
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_5) throw e_5.error; }
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
     finally {
         try {
             if (directories_1_1 && !directories_1_1.done && (_a = directories_1.return)) _a.call(directories_1);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_4) throw e_4.error; }
     }
     // The budget is spent in path order, not in whatever order the folder listing
     // returns, so the same project yields the same drive - and the same warning -
@@ -294,12 +433,12 @@ var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
             files[candidate.key] = file.contents;
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
     finally {
         try {
             if (candidates_1_1 && !candidates_1_1.done && (_c = candidates_1.return)) _c.call(candidates_1);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_6) throw e_6.error; }
     }
     return { files: files, skipped: skipped };
 };
@@ -441,7 +580,7 @@ var patchIndexHtml = function (html, version) {
     var scripts = [];
     var tagPattern = /<script\b([^>]*)>([\s\S]*?)<\/script>[ \t]*\r?\n?/gi;
     patched = patched.replace(tagPattern, function (tag, source, body) {
-        var e_6, _a;
+        var e_7, _a;
         var attributes = parseAttributes(source);
         var type = (attributes.type || '').trim().toLowerCase();
         var inlined = !attributes.src;
@@ -466,16 +605,16 @@ var patchIndexHtml = function (html, version) {
                     continue;
                 if (attribute === 'type' && !attributes.type)
                     continue;
-                var name_1 = REPLAYED_ATTRIBUTES[attribute];
-                spec[name_1] = attribute === 'nomodule' ? 'true' : attributes[attribute];
+                var name_2 = REPLAYED_ATTRIBUTES[attribute];
+                spec[name_2] = attribute === 'nomodule' ? 'true' : attributes[attribute];
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_6) throw e_6.error; }
+            finally { if (e_7) throw e_7.error; }
         }
         scripts.push(spec);
         return '';
@@ -508,7 +647,7 @@ var patchIndexHtml = function (html, version) {
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
         var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
-        var e_7, _e;
+        var e_8, _e;
         var _f, _g, _h;
         return __generator(this, function (_j) {
             switch (_j.label) {
@@ -597,14 +736,24 @@ function buildMockSite(target) {
                             fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, asset), path_1.default.join(hostFolder, asset));
                         }
                     }
-                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
                     finally {
                         try {
                             if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
                         }
-                        finally { if (e_7) throw e_7.error; }
+                        finally { if (e_8) throw e_8.error; }
                     }
                     fs_1.default.copyFileSync(API_BROWSER_BUILD, path_1.default.join(hostFolder, 'api-browser.js'));
+                    // 2. the linter, bundled from the installed packages so the code routes answer
+                    // with the rules this CLI resolved rather than a second implementation
+                    return [4 /*yield*/, (0, exports.buildLintBundle)(path_1.default.join(hostFolder, 'lint-browser.js'))
+                        // sw.js sits at the site root: a worker can only control the folder it is
+                        // served from, and the app has to be controlled from /
+                    ];
+                case 3:
+                    // 2. the linter, bundled from the installed packages so the code routes answer
+                    // with the rules this CLI resolved rather than a second implementation
+                    _j.sent();
                     // sw.js sits at the site root: a worker can only control the folder it is
                     // served from, and the app has to be controlled from /
                     fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));
@@ -630,6 +779,7 @@ function buildMockSite(target) {
                         'intercept.js',
                         'boot.js',
                         'api-browser.js',
+                        'lint-browser.js',
                         'webout-prelude.json'
                     ]
                         .map(function (asset) { return fs_1.default.readFileSync(path_1.default.join(hostFolder, asset)); })
@@ -640,7 +790,8 @@ function buildMockSite(target) {
                     fs_1.default.writeFileSync(swPath, fs_1.default
                         .readFileSync(swPath, 'utf8')
                         .replace("importScripts('/host/runtime-core.js')", "importScripts('/host/runtime-core.js?v=".concat(hostVersion, "')"))
-                        .replace("importScripts('/host/api-browser.js')", "importScripts('/host/api-browser.js?v=".concat(hostVersion, "')")));
+                        .replace("importScripts('/host/api-browser.js')", "importScripts('/host/api-browser.js?v=".concat(hostVersion, "')"))
+                        .replace("importScripts('/host/lint-browser.js')", "importScripts('/host/lint-browser.js?v=".concat(hostVersion, "')")));
                     snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
                     hasSnapshot = fs_1.default.existsSync(snapshotSource);
                     if (hasSnapshot) {
@@ -673,3 +824,4 @@ function buildMockSite(target) {
         });
     });
 }
+var templateObject_1;

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

@@ -169,7 +169,8 @@ describe('browser-hosted build', function () {
                             'persist.js',
                             'intercept.js',
                             'boot.js',
-                            'api-browser.js'
+                            'api-browser.js',
+                            'lint-browser.js'
                         ]), _b = _a.next(); !_b.done; _b = _a.next()) {
                             asset = _b.value;
                             expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', asset))).toBe(true);
@@ -209,11 +210,33 @@ describe('browser-hosted build', function () {
                     // a rebuild that changes either file has to change the URL
                     expect(sw).toMatch(/importScripts\('\/host\/runtime-core\.js\?v=[0-9a-f]{10}'\)/);
                     expect(sw).toMatch(/importScripts\('\/host\/api-browser\.js\?v=[0-9a-f]{10}'\)/);
+                    expect(sw).toMatch(/importScripts\('\/host\/lint-browser\.js\?v=[0-9a-f]{10}'\)/);
                     expect(sw).not.toContain("importScripts('/host/runtime-core.js')");
                     return [2 /*return*/];
             }
         });
     }); });
+    it('bundles the linter from the installed packages, ready for a worker', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var bundle, vm, realm;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    bundle = fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'lint-browser.js'), 'utf8');
+                    // the bundle carries the package's code service, not a second linter
+                    expect(bundle).toContain('SASjsCode');
+                    expect(bundle).toContain('createCodeService');
+                    vm = require('vm');
+                    realm = { globalThis: null, console: console };
+                    realm.globalThis = realm;
+                    vm.createContext(realm);
+                    vm.runInContext(bundle, realm);
+                    expect(typeof realm.SASjsCode.createCodeService).toBe('function');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('names the package when its browser build is missing, and keeps the previous site', function () { return __awaiter(void 0, void 0, void 0, function () {
         var browserBuild, exists;
         return __generator(this, function (_a) {

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

@@ -35,17 +35,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __read = (this && this.__read) || function (o, n) {
     var m = typeof Symbol === "function" && o[Symbol.iterator];
     if (!m) return o;
@@ -62,13 +51,26 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var path_1 = __importDefault(require("path"));
 var api_1 = require("@sasjs/api");
+var os_1 = __importDefault(require("os"));
 var yazl_1 = __importDefault(require("yazl"));
+var mockSite_1 = require("../mockSite");
 /**
  * The other half of the parity claim: the service worker is what turns an
  * /SASjsApi/ request into a response, so its framing (webout body, the _debug
@@ -87,6 +89,19 @@ var drivePath = function (relative) {
 var apiBrowserBuild = function () {
     return path_1.default.join(path_1.default.dirname(require.resolve('@sasjs/api')), '..', '..', 'build', 'browser.js');
 };
+/**
+ * The lint bundle the site ships, built once for the suite from the installed
+ * packages - the same call `sasjs build` makes, so the worker under test answers
+ * the code routes with the code the site carries.
+ */
+var lintBundlePath;
+var lintBundle = function () {
+    if (!lintBundlePath) {
+        lintBundlePath = path_1.default.join(os_1.default.tmpdir(), "sasjs-lint-".concat(process.pid, ".js"));
+        (0, mockSite_1.buildLintBundle)(lintBundlePath);
+    }
+    return lintBundlePath;
+};
 var loadWorker = function () {
     jest.resetModules();
     var handlers = {};
@@ -108,6 +123,13 @@ var loadWorker = function () {
             return;
         if (path.includes('api-browser'))
             return require(apiBrowserBuild());
+        if (path.includes('lint-browser')) {
+            // the bundle assigns globalThis.SASjsCode, and this harness keeps the
+            // worker's `self` apart from the module global
+            require(lintBundle());
+            self.SASjsCode = global.SASjsCode;
+            return;
+        }
         require('../assets/runtime-core.js');
         // The corpus needs the same drive with its writes refused, without building
         // a second site. The flag is flipped after the case has seeded, because a
@@ -133,10 +155,20 @@ var loadWorker = function () {
         };
     };
     require('../assets/sw.js');
-    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+    global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
+        var target;
         var _a;
         return __generator(this, function (_b) {
-            return [2 /*return*/, String(url).includes('vfs-seed')
+            target = typeof input === 'string' ? input : (input && input.url) || String(input);
+            // a navigation back to the site root: the static host's copy of the page
+            if (new URL(target, origin).pathname === '/')
+                return [2 /*return*/, new Response('<html><body>static page</body></html>', {
+                        status: 200,
+                        headers: { 'content-type': 'text/html' }
+                    })];
+            if (target.includes('index.html'))
+                return [2 /*return*/, new Response('<!doctype html><html><head><title>App</title></head><body>home</body></html>', { status: 200, headers: { 'content-type': 'text/html' } })];
+            return [2 /*return*/, target.includes('vfs-seed')
                     ? jsonResponse({
                         files: (_a = {},
                             _a[drivePath('services/public/getdata.js')] = '_webout = "seeded";',
@@ -699,85 +731,204 @@ describe('service worker host', function () {
                 }
             });
         }); });
-        it('answers the documented 501 for the capabilities a static origin lacks', function () { return __awaiter(void 0, void 0, void 0, function () {
-            var dispatch, cases, cases_1, cases_1_1, _a, method, url, capability, response, _b, e_1_1, _c, _d, url, response, _e, e_2_1;
-            var e_1, _f, e_2, _g;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
+        it('answers the Admin reports from the worker activity log', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, empty, _a, afterFirst, _b, listed, lines, infoLines, diagnostics, report, logs, _c, tail, tailBody, wrongName, missing;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         dispatch = seeded().dispatch;
-                        cases = [
-                            ['GET', '/SASjsApi/admin/diagnostics', 'admin service'],
-                            ['GET', '/SASjsApi/admin/logs', 'admin service'],
-                            ['GET', '/SASjsApi/admin/logs/app.log', 'admin service'],
-                            [
-                                'POST',
-                                '/SASjsApi/authConfig/synchroniseWithLDAP',
-                                'directory service'
-                            ]
-                        ];
-                        _h.label = 1;
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/diagnostics')];
                     case 1:
-                        _h.trys.push([1, 7, 8, 9]);
-                        cases_1 = __values(cases), cases_1_1 = cases_1.next();
-                        _h.label = 2;
+                        empty = _d.sent();
+                        _a = expect;
+                        return [4 /*yield*/, empty.json()];
                     case 2:
-                        if (!!cases_1_1.done) return [3 /*break*/, 6];
-                        _a = __read(cases_1_1.value, 3), method = _a[0], url = _a[1], capability = _a[2];
-                        return [4 /*yield*/, dispatch(url, { method: method })];
+                        _a.apply(void 0, [(_d.sent()).logs]).toEqual({
+                            folder: 'worker memory',
+                            fileCount: 0,
+                            totalBytes: 0,
+                            newestFile: null,
+                            newestModified: null
+                        });
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
                     case 3:
-                        response = _h.sent();
-                        expect(response.status).toBe(501);
+                        afterFirst = _d.sent();
                         _b = expect;
-                        return [4 /*yield*/, response.json()];
+                        return [4 /*yield*/, afterFirst.json()];
                     case 4:
-                        _b.apply(void 0, [(_h.sent()).message]).toContain(capability);
-                        _h.label = 5;
+                        _b.apply(void 0, [(_d.sent()).files.length]).toBe(1);
+                        // the file's mtime is the last write, not the moment a report was read:
+                        // /info was the request immediately before this listing
+                        return [4 /*yield*/, dispatch('/SASjsApi/info')];
                     case 5:
-                        cases_1_1 = cases_1.next();
-                        return [3 /*break*/, 2];
-                    case 6: return [3 /*break*/, 9];
+                        // the file's mtime is the last write, not the moment a report was read:
+                        // /info was the request immediately before this listing
+                        _d.sent();
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
+                    case 6: return [4 /*yield*/, (_d.sent()).json()];
                     case 7:
-                        e_1_1 = _h.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 9];
-                    case 8:
-                        try {
-                            if (cases_1_1 && !cases_1_1.done && (_f = cases_1.return)) _f.call(cases_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
+                        listed = (_d.sent())
+                            .files[0];
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/app.log?lines=20')];
+                    case 8: return [4 /*yield*/, (_d.sent()).json()];
                     case 9:
-                        _h.trys.push([9, 15, 16, 17]);
-                        _c = __values(['/SASjsApi/code/lint', '/SASjsApi/code/format']), _d = _c.next();
-                        _h.label = 10;
+                        lines = (_d.sent()).content.split('\n');
+                        infoLines = lines.filter(function (line) {
+                            return line.includes('GET /SASjsApi/info 200');
+                        });
+                        expect(infoLines.length).toBe(1);
+                        expect(infoLines[0].startsWith(listed.modified)).toBe(true);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/diagnostics')];
                     case 10:
-                        if (!!_d.done) return [3 /*break*/, 14];
-                        url = _d.value;
-                        return [4 /*yield*/, dispatch(url, runRequest({ code: 'data a;' }))];
+                        diagnostics = _d.sent();
+                        expect(diagnostics.status).toBe(200);
+                        return [4 /*yield*/, diagnostics.json()];
                     case 11:
-                        response = _h.sent();
-                        expect(response.status).toBe(501);
-                        _e = expect;
-                        return [4 /*yield*/, response.json()];
+                        report = _d.sent();
+                        expect(report.server.mode).toBe('browser');
+                        expect(report.filesystem).toBeNull();
+                        expect(report.logs.fileCount).toBe(1);
+                        expect(typeof report.memory.heapTotalBytes).toBe('number');
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs')];
                     case 12:
-                        _e.apply(void 0, [(_h.sent()).message]).toContain('code service');
-                        _h.label = 13;
+                        logs = _d.sent();
+                        _c = expect;
+                        return [4 /*yield*/, logs.json()];
                     case 13:
-                        _d = _c.next();
-                        return [3 /*break*/, 10];
-                    case 14: return [3 /*break*/, 17];
+                        _c.apply(void 0, [(_d.sent()).files.map(function (file) { return file.name; })]).toEqual([
+                            'app.log'
+                        ]);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/app.log?lines=5')];
+                    case 14:
+                        tail = _d.sent();
+                        return [4 /*yield*/, tail.json()];
                     case 15:
-                        e_2_1 = _h.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 17];
+                        tailBody = _d.sent();
+                        expect(tail.status).toBe(200);
+                        expect(tailBody.content).toContain('GET /SASjsApi/info 200');
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/secret.txt')];
                     case 16:
-                        try {
-                            if (_d && !_d.done && (_g = _c.return)) _g.call(_c);
-                        }
-                        finally { if (e_2) throw e_2.error; }
+                        wrongName = _d.sent();
+                        expect(wrongName.status).toBe(400);
+                        return [4 /*yield*/, dispatch('/SASjsApi/admin/logs/other.log')];
+                    case 17:
+                        missing = _d.sent();
+                        expect(missing.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('imports the fixture directory, and unpublishes the site itself', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, synced, _a, unpublished, _b, other;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/authConfig/synchroniseWithLDAP', { method: 'POST' })];
+                    case 1:
+                        synced = _c.sent();
+                        expect(synced.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, synced.json()];
+                    case 2:
+                        _a.apply(void 0, [_c.sent()]).toEqual({ userCount: 0, groupCount: 0 });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
+                                method: 'DELETE',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    streamServiceName: 'Test',
+                                    appLoc: appLoc
+                                })
+                            })];
+                    case 3:
+                        unpublished = _c.sent();
+                        expect(unpublished.status).toBe(200);
+                        _b = expect;
+                        return [4 /*yield*/, unpublished.json()];
+                    case 4:
+                        _b.apply(void 0, [_c.sent()]).toEqual({ status: 'success' });
+                        return [4 /*yield*/, dispatch('/SASjsApi/drive/deploy', {
+                                method: 'DELETE',
+                                headers: { 'content-type': 'application/json' },
+                                body: JSON.stringify({
+                                    streamServiceName: 'Other',
+                                    appLoc: '/Public/app/other'
+                                })
+                            })];
+                    case 5:
+                        other = _c.sent();
+                        expect(other.status).toBe(404);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('lints and formats a buffer with the bundled linter', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var dispatch, linted, diagnostics, formatted, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        dispatch = seeded().dispatch;
+                        return [4 /*yield*/, dispatch('/SASjsApi/code/lint', runRequest({ code: 'data a;\nrun;\n' }))];
+                    case 1:
+                        linted = _b.sent();
+                        expect(linted.status).toBe(200);
+                        return [4 /*yield*/, linted.json()];
+                    case 2:
+                        diagnostics = _b.sent();
+                        expect(Array.isArray(diagnostics)).toBe(true);
+                        expect(diagnostics.length).toBeGreaterThan(0);
+                        expect(diagnostics[0].message).toContain('Doxygen');
+                        return [4 /*yield*/, dispatch('/SASjsApi/code/format', runRequest({ code: 'data a;set b;run;' }))];
+                    case 3:
+                        formatted = _b.sent();
+                        expect(formatted.status).toBe(200);
+                        _a = expect;
+                        return [4 /*yield*/, formatted.text()];
+                    case 4:
+                        _a.apply(void 0, [_b.sent()]).toContain('@brief');
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it('serves the build page at the home route, and falls back when it fails', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, _a, runtime, original, fallback, body;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        worker = seeded();
+                        return [4 /*yield*/, worker.dispatch('/')];
+                    case 1:
+                        response = _b.sent();
+                        expect(response.status).toBe(200);
+                        expect(response.headers.get('content-type')).toContain('text/html');
+                        _a = expect;
+                        return [4 /*yield*/, response.text()];
+                    case 2:
+                        _a.apply(void 0, [_b.sent()]).toContain('<body>home</body>');
+                        runtime = worker.self.SASjsMockRuntime;
+                        original = runtime.ensureReady;
+                        runtime.ensureReady = function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                throw new Error('home route exploded');
+                            });
+                        }); };
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, , 6, 7]);
+                        return [4 /*yield*/, worker.dispatch('/')];
+                    case 4:
+                        fallback = _b.sent();
+                        expect(fallback.status).toBe(200);
+                        return [4 /*yield*/, fallback.text()];
+                    case 5:
+                        body = _b.sent();
+                        expect(body).toContain('static page');
+                        expect(body).not.toContain('home route exploded');
+                        return [3 /*break*/, 7];
+                    case 6:
+                        runtime.ensureReady = original;
                         return [7 /*endfinally*/];
-                    case 17: return [2 /*return*/];
+                    case 7: return [2 /*return*/];
                 }
             });
         }); });
@@ -1856,7 +2007,7 @@ describe('service worker host', function () {
         }); });
     });
     describe('conformance corpus', function () {
-        var e_3, _a;
+        var e_1, _a;
         /**
          * The corpus is what "the same API" means: the cases @sasjs/api runs against
          * its own services, and against a live sasjs/server, run here against this
@@ -1865,7 +2016,7 @@ describe('service worker host', function () {
          * used to have - and it is a test rather than a review.
          */
         var httpFor = function (testCase) {
-            var e_4, _a;
+            var e_2, _a;
             var _b;
             var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
             var query = new URLSearchParams();
@@ -1876,12 +2027,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                 }
-                finally { if (e_4) throw e_4.error; }
+                finally { if (e_2) throw e_2.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var init = { method: method };
@@ -1912,8 +2063,8 @@ describe('service worker host', function () {
          * does.
          */
         var seedDrive = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
-            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_5_1;
-            var e_6, _g, e_5, _h;
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_3_1;
+            var e_4, _g, e_3, _h;
             return __generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
@@ -1925,12 +2076,12 @@ describe('service worker host', function () {
                                     text["/sasjs/drive/files".concat(file)] = contents;
                             }
                         }
-                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
                             }
-                            finally { if (e_6) throw e_6.error; }
+                            finally { if (e_4) throw e_4.error; }
                         }
                         return [4 /*yield*/, runtime.load(text)];
                     case 1:
@@ -1953,14 +2104,14 @@ describe('service worker host', function () {
                         return [3 /*break*/, 3];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_5_1 = _j.sent();
-                        e_5 = { error: e_5_1 };
+                        e_3_1 = _j.sent();
+                        e_3 = { error: e_3_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
                             if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_3) throw e_3.error; }
                         return [7 /*endfinally*/];
                     case 9: return [2 /*return*/];
                 }
@@ -2028,12 +2179,12 @@ describe('service worker host', function () {
                 _loop_1(testCase);
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (DRIVE_CORPUS_1_1 && !DRIVE_CORPUS_1_1.done && (_a = DRIVE_CORPUS_1.return)) _a.call(DRIVE_CORPUS_1);
             }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_1) throw e_1.error; }
         }
     });
 });

package/package.json

@@ -78,6 +78,7 @@
     "axios": "1.20.0",
     "chalk": "4.1.2",
     "dotenv": "18.0.8",
+    "esbuild": "0.28.2",
     "js-base64": "3.9.4",
     "jsdom": "26.0.0",
     "lodash.uniqby": "4.7.0",
@@ -124,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.15.0"
+  "version": "6.16.0"
 }