@sasjs/cli 6.14.0 → 6.16.0

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 };
 };
@@ -391,6 +530,37 @@ var EXECUTABLE_TYPES = [
     'text/javascript',
     'application/javascript'
 ];
+/**
+ * Tells the interface that this page is answered by the browser host.
+ *
+ * A mock site is the server's own interface running against a service worker,
+ * and nothing in the document said so: the API answers the same routes, the same
+ * mode and the same run times a desktop server does, so an interface could not
+ * tell a visitor what they were looking at. sasjs/server reads the tag and, where
+ * it is absent, knows the server answered the page.
+ *
+ * The insertion is reported when the page has no `<head>`, the way the other two
+ * rewrites report markup they could not find - silently leaving the tag off a
+ * page the browser host cannot mark is what the reader of the absence rule would
+ * misread as "a server answered this". The check for an existing tag is scoped
+ * to the head, because a page may mention the tag in a script or a template
+ * without carrying it, and a document-wide test would then insert nothing.
+ */
+var HOST_TAG = '<meta name="sasjs-host" content="browser" />';
+var HOST_TAG_PATTERN = /<meta\s+name=["']sasjs-host["']/i;
+var markBrowserHost = function (html, warnings) {
+    var head = /<head(\s[^>]*)?>/i.exec(html);
+    if (!head) {
+        warnings.push('no <head> element found - the sasjs-host tag was not added, so the page will read as server-answered');
+        return html;
+    }
+    var start = head.index + head[0].length;
+    var close = html.toLowerCase().indexOf('</head>', start);
+    var inHead = close < 0 ? html.slice(start) : html.slice(start, close);
+    if (HOST_TAG_PATTERN.test(inHead))
+        return html;
+    return html.slice(0, start) + HOST_TAG + html.slice(start);
+};
 /**
  * Points the app at its own origin and replaces its script tags with the boot
  * loader. Both changes are reported when the expected markup is absent, rather
@@ -399,14 +569,7 @@ var EXECUTABLE_TYPES = [
 var patchIndexHtml = function (html, version) {
     var warnings = [];
     var patched = html;
-    // States where this page's API comes from, for anything in the page that
-    // wants to say so: the server's own interface reads it to describe the host
-    // it is running on, and a browser host is a different thing to explain than a
-    // server process. Absence means the server answered the page.
-    if (!/<meta\s+name=["']sasjs-host["']/i.test(patched))
-        patched = patched.replace(/<head(\s[^>]*)?>/i, function (head) {
-            return "".concat(head, "\n    <meta name=\"sasjs-host\" content=\"browser\" />");
-        });
+    patched = markBrowserHost(patched, warnings);
     if (/<sasjs[^>]*>/i.test(patched)) {
         patched = patched.replace(/(<sasjs[^>]*?)\sserverurl="[^"]*"/i, '$1 serverurl=""');
         patched = patched.replace(/(<sasjs[^>]*?)\sloginmechanism="[^"]*"/i, '$1 loginmechanism="Default"');
@@ -417,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;
@@ -442,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 '';
@@ -484,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) {
@@ -573,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'));
@@ -606,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)); })
@@ -616,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) {
@@ -649,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) {
@@ -368,18 +391,91 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('states in the page that the API is answered here', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var html;
+        var html, tag;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
                 case 1:
                     _a.sent();
                     html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
-                    // The interface reads this to tell a browser host from a server: the API
-                    // cannot, because a browser host answers the same routes and the same
-                    // /SASjsApi/info shape. Only the host knows, so the host says.
+                    tag = '<meta name="sasjs-host" content="browser" />';
+                    expect(html).toContain(tag);
+                    expect(html.indexOf(tag)).toBeLessThan(html.indexOf('</head>'));
+                    // once: the tag it inserts is the one the guard then finds
+                    expect(html.split('sasjs-host').length - 1).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a page that already carries the host tag alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head>',
+                        '<meta name="sasjs-host" content="browser">',
+                        '</head><body><script src="main.abc123.js"></script></body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html.split('sasjs-host').length - 1).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('inserts the tag when the page only mentions it outside the head', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        '<script src="main.abc123.js"></script>',
+                        '<template><meta name="sasjs-host" content="browser"></template>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    // the template's copy is not the page's tag: the head gets its own
+                    expect(html.split('sasjs-host').length - 1).toBe(2);
+                    expect(html.indexOf('content="browser" />')).toBeLessThan(html.indexOf('</head>'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('marks a page whose head is never closed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), '<!doctype html><html><head><title>App</title><body><script src="main.abc123.js"></script></body></html>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
                     expect(html).toContain('<meta name="sasjs-host" content="browser" />');
-                    expect(html.indexOf('sasjs-host')).toBeLessThan(html.indexOf('</head>'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('warns when a page has no head to mark', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), '<!doctype html><html><body><script src="main.abc123.js"></script></body></html>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _b.sent();
+                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('no <head> element found'));
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).not.toContain('sasjs-host');
                     return [2 /*return*/];
             }
         });