@sasjs/cli 6.22.0 → 6.23.1

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

@@ -1525,6 +1525,9 @@ const api = {
     bytes: [...FILES.keys()].reduce((total, abs) => total + entrySizeAt(abs), 0)
   }),
   run: (payload) => runProgram(payload),
+  // the file a program names, so the host can tell a .sas program from a .js one
+  // and refuse the former instead of compiling SAS source as JavaScript
+  resolveProgram: (program) => resolveProgram(program),
   // the drive's bytes, for @sasjs/api's services: the rules that decide a
   // status are the package's, so this host hands over storage and nothing else
   driveStore,

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

@@ -181,19 +181,21 @@ const SEEDED_HEADER_LINE = String(R.HEADERS_SEED)
  * it.
  */
 const artifactOf = (result, debug) => {
-  if (debug)
+  if (debug) {
+    // webout SEP log SEP [listing] - the framing @sasjs/adapter and the Studio's
+    // parser both split on, so a recorded session reads the same as a real one.
+    const framed = [result.webout, LOGS_SEPARATOR, result.log, LOGS_SEPARATOR]
+
+    if (result.print) framed.push(result.print)
+
     return {
-      contents: [
-        result.webout,
-        LOGS_SEPARATOR,
-        result.log,
-        LOGS_SEPARATOR
-      ].join('\n'),
+      contents: framed.join('\n'),
       // the frame is text, and the service's own type and disposition are not
       // applied to it - a download there would put the frame in the file
       headers: { 'content-type': 'text/plain' },
       log: result.log
     }
+  }
 
   const headers = parseHeaders(result.headers)
   let contents = result.webout
@@ -231,6 +233,66 @@ const persistChanges = async () => {
     await broadcast({ type: 'sasjs-persist', files })
 }
 
+// ----------------------------------------------------------- the SAS transcript
+/**
+ * A recorded SAS session, for a project that ships one.
+ *
+ * A browser has no SAS binary. Rather than let a Run on a .sas program be a
+ * surprise, a project may record a session once and commit it as
+ * `sas-transcript.json`: the build copies it into the site and this answers a
+ * run of a program it names with that session's log, listing and webout. The
+ * recording is the demo's own data, so nothing here is invented for a project
+ * that does not ship one - those runs reach the runner and are refused exactly
+ * as before.
+ *
+ * Shape: `{ "<program path>": {"log": "...", "print": "...", "webout": "..."} }`,
+ * all three strings. The path is matched as written apart from the
+ * `/sasjs/drive/files` prefix and the `.sas` suffix, so a recording keeps the
+ * path a person sees; a bare file name is not enough, because that would answer
+ * every file of that name in the drive.
+ */
+const SAS_TRANSCRIPT = 'host/sas-transcript.json'
+let TRANSCRIPT = null
+
+const transcript = async () => {
+  if (TRANSCRIPT) return TRANSCRIPT
+  try {
+    const response = await fetch(SAS_TRANSCRIPT, { cache: 'no-cache' })
+    TRANSCRIPT = response.ok ? await response.json() : {}
+  } catch (e) {
+    TRANSCRIPT = {}
+  }
+  return TRANSCRIPT
+}
+
+/**
+ * The drive path without its mount prefix or extension.
+ *
+ * A recording is written with the path a person sees (`/sasjs/drive/files/...`,
+ * ending in `.sas`); the route hands the request the path relative to the app,
+ * and Studio asks for it without the extension. Comparing the logical path makes
+ * those the same program without widening the match to the file name alone,
+ * which would answer every `report.sas` in the drive with a session recorded for
+ * some other file.
+ */
+const logicalPath = (value) =>
+  String(value || '')
+    .replace(/^\/sasjs\/drive\/files/i, '')
+    .replace(/\.sas$/i, '')
+
+/** The recording naming this program, if the project shipped one. */
+const transcriptFor = async (programPath) => {
+  const requested = logicalPath(programPath)
+  if (!requested) return undefined
+
+  const recorded = await transcript()
+
+  for (const key of Object.keys(recorded))
+    if (logicalPath(key) === requested) return recorded[key]
+
+  return undefined
+}
+
 // ---------------------------------------------------------------- the runner
 /**
  * The work a run does, over the browser's drive.
@@ -250,6 +312,19 @@ class BrowserRuntime extends API.MemorySessionHost {
   async run(request) {
     const program = request.program || {}
     const params = Object.assign({}, request.vars || {})
+
+    // A SAS program the recording does not name. This host has no SAS binary, so
+    // the answer is the refusal a client already understands - not a JavaScript
+    // SyntaxError quoting the SAS source, which is what handing it to the runner
+    // would produce. The file is resolved because the request may name the
+    // program without its extension.
+    if (program.code === undefined) {
+      const resolved = R.resolveProgram(program.path)
+
+      if (resolved && /\.sas$/i.test(resolved))
+        throw runFailure('"runTime" must be one of [js]')
+    }
+
     const payload = { params, tables: tablesOf(request.files) }
     if (program.code !== undefined) payload.code = program.code
     else payload.program = program.path
@@ -516,8 +591,10 @@ const SERVICES = {
   identity: IDENTITY,
   records: RECORDS,
   runtime: API.createRuntimeService(IDENTITY_STORE, RUNTIME, {
-    // the one run time a browser holds; a stored program asks for another and
-    // is refused with the package's own message
+    // The one run time this host executes. A recorded SAS session is answered
+    // before the runner (see SAS_TRANSCRIPT below), not by claiming a `sas` run
+    // time - a .sas program with no recording must still be refused, and a route
+    // that accepted `sas` would compile SAS source as JavaScript instead.
     runTimes: ['js']
   }),
   session: API.createSessionService(IDENTITY_STORE, RUNTIME),
@@ -860,6 +937,33 @@ const runRoute = async (routeId, payload, subject) => {
     runRequest.program = query._program || body._program
   }
 
+  // A recorded SAS session is answered here, ahead of the run time check: a
+  // transcript is data, not a run time, and this host holds only `js`. Accepting
+  // `sas` instead would make the package compile SAS source as JavaScript and
+  // hand back a SyntaxError where every other .sas program gets a refusal.
+  // Neither a code run nor a trigger: a trigger has to answer with the session
+  // record the route builds, which a client parses as JSON, so a recording is not
+  // an answer there.
+  if (!code && !trigger) {
+    const recording = await transcriptFor(runRequest.program)
+
+    if (recording)
+      return artifactResponse(
+        artifactOf(
+          {
+            webout: recording.webout || '',
+            log: recording.log || '',
+            print: recording.print || '',
+            // the seed every session starts with, so a run without `_debug`
+            // answers text/html rather than leaving the type to the browser -
+            // the same rule runtime-core applies to a service that declares none
+            headers: SEEDED_HEADER_LINE
+          },
+          vars._debug !== undefined
+        )
+      )
+  }
+
   if (trigger) {
     runRequest.expiresAfterMins =
       query.expiresAfterMins !== undefined

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

@@ -9,6 +9,8 @@ export interface MockSiteResult {
     webFileCount: number;
     /** True when a captured drive snapshot was shipped with the site. */
     snapshot: boolean;
+    /** True when a recorded SAS session was shipped, for .sas runs to answer. */
+    sasTranscript: boolean;
 }
 /**
  * The webout() block is the one @sasjs/utils generates for the server, emitted

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

@@ -594,13 +594,55 @@ var markBrowserHost = function (html, warnings) {
         return html;
     return html.slice(0, start) + HOST_TAG + html.slice(start);
 };
+/**
+ * Each app script's URL carries a hash of the script's own contents.
+ *
+ * A static host caches an asset for as long as it says to, and GitHub Pages says
+ * two hours - while the app's bundle name never changes from one build to the
+ * next. So a publish that changes only the app reuses the previous URL, and a
+ * visitor inside that window runs the previous build against the new page: the
+ * screens the new build adds simply never appear, and the ones it removed keep
+ * working. Only the host's own files were versioned before (`?v=` on boot.js and
+ * the worker's imports), and those change with the CLI, not with the app.
+ *
+ * A src that names no file in the output is left alone: a page may load a
+ * script from somewhere this build does not own, and guessing a version for it
+ * would break it.
+ *
+ * The tags in the page are all this covers. A chunk the entry point loads later
+ * - `import('./chunk.js')`, a lazy route - keeps its own URL and is cached for
+ * the same window, because the request for it is made by the bundle's runtime
+ * and never passes through this file. Versioning those would mean rewriting the
+ * chunk map inside the bundle, which is the bundler's business, not the host's;
+ * a page whose chunks matter more than its entry should name them in the page,
+ * where this does reach them.
+ */
+var versionScripts = function (scripts, outputFolder) {
+    return scripts.map(function (script) {
+        var src = script.src;
+        if (!src)
+            return script;
+        var _a = __read(src.split('?'), 2), pathname = _a[0], query = _a[1];
+        var file = path_1.default.join(outputFolder, pathname.replace(/^(\.\/|\/)/, ''));
+        if (!fs_1.default.existsSync(file))
+            return script;
+        var hash = (0, crypto_1.createHash)('md5')
+            .update(fs_1.default.readFileSync(file))
+            .digest('hex')
+            .slice(0, 10);
+        return Object.assign({}, script, {
+            src: "".concat(pathname, "?v=").concat(hash).concat(query ? "&".concat(query) : '')
+        });
+    });
+};
 /**
  * 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
  * than producing a site that silently talks to a real server.
  */
-var patchIndexHtml = function (html, version, basePath) {
+var patchIndexHtml = function (html, version, basePath, outputFolder) {
     if (basePath === void 0) { basePath = ''; }
+    if (outputFolder === void 0) { outputFolder = ''; }
     var warnings = [];
     var patched = html;
     patched = markBrowserHost(patched, warnings);
@@ -657,7 +699,10 @@ var patchIndexHtml = function (html, version, basePath) {
         return '';
     });
     if (scripts.length) {
-        var tag = bootTag(scripts, version, basePath);
+        var versioned = outputFolder
+            ? versionScripts(scripts, outputFolder)
+            : scripts;
+        var tag = bootTag(versioned, version, basePath);
         patched = /<\/body>/i.test(patched)
             ? patched.replace(/<\/body>/i, "".concat(tag, "\n</body>"))
             : patched + tag;
@@ -683,7 +728,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, buildStamp, 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, transcriptSource, hasTranscript, indexPath, _d, patched, warnings;
         var e_8, _e;
         var _f, _g, _h, _j, _k, _l;
         return __generator(this, function (_m) {
@@ -854,6 +899,10 @@ function buildMockSite(target) {
                     if (hasSnapshot) {
                         fs_1.default.copyFileSync(snapshotSource, path_1.default.join(hostFolder, 'vfs-snapshot.json'));
                     }
+                    transcriptSource = path_1.default.join(buildFolder, 'sas-transcript.json');
+                    hasTranscript = fs_1.default.existsSync(transcriptSource);
+                    if (hasTranscript)
+                        fs_1.default.copyFileSync(transcriptSource, path_1.default.join(hostFolder, 'sas-transcript.json'));
                     // 3. the drive, laid out from the compile output
                     fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-seed.json'), JSON.stringify({ format: exports.DRIVE_FORMAT, files: seed }));
                     fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'mock-config.json'), JSON.stringify({
@@ -863,11 +912,12 @@ function buildMockSite(target) {
                         jsPrograms: jsPrograms,
                         programFolders: PROGRAM_FOLDERS,
                         snapshot: hasSnapshot,
+                        sasTranscript: hasTranscript,
                         buildStamp: buildStamp,
                         builtAt: new Date().toISOString()
                     }, null, 2));
                     indexPath = path_1.default.join(outputFolder, 'index.html');
-                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath), patched = _d.patched, warnings = _d.warnings;
+                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath, outputFolder), patched = _d.patched, warnings = _d.warnings;
                     fs_1.default.writeFileSync(indexPath, patched);
                     warnings.forEach(function (warning) { var _a; return (_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn(warning); });
                     return [2 /*return*/, {
@@ -876,7 +926,8 @@ function buildMockSite(target) {
                             driveEntries: driveEntries,
                             jsPrograms: jsPrograms,
                             webFileCount: webFileCount,
-                            snapshot: hasSnapshot
+                            snapshot: hasSnapshot,
+                            sasTranscript: hasTranscript
                         }];
             }
         });

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

@@ -468,7 +468,7 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('points the app at itself and installs the boot loader', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var html;
+        var html, specs;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
@@ -486,7 +486,60 @@ describe('browser-hosted build', function () {
                     // the app's own tags are replayed by the loader, in the order the page has
                     // them, and are gone from the page itself
                     expect(html).not.toContain('<script src="main.abc123.js"');
-                    expect(html).toContain('"src":"main.abc123.js","type":"module"');
+                    specs = JSON.parse(html
+                        .match(/data-scripts='([^']*)'/)[1]
+                        .replace(/&#39;/g, "'")
+                        .replace(/&amp;/g, '&'));
+                    expect(specs).toHaveLength(1);
+                    expect(specs[0].type).toBe('module');
+                    expect(specs[0].src).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A publish that changes only the app has to reach a reader whose browser
+     * still holds the previous copy. The host caches an asset for two hours and the
+     * bundle's name never changes, so the URL is what has to change.
+     */
+    it('gives each app script a URL that follows its contents', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var specs, first;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    specs = function () {
+                        var html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                        var tag = html.match(/data-scripts='([^']*)'/);
+                        return JSON.parse(tag[1].replace(/&#39;/g, "'").replace(/&amp;/g, '&'));
+                    };
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    first = specs()[0].src;
+                    expect(first).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    // the same file twice: nothing about the URL changes
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 2:
+                    // the same file twice: nothing about the URL changes
+                    _a.sent();
+                    expect(specs()[0].src).toBe(first);
+                    // a different bundle: a different URL, which is the caching bust
+                    write(path_1.default.join(root, 'client', 'dist', 'main.abc123.js'), 'console.log(2)\n');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 3:
+                    _a.sent();
+                    expect(specs()[0].src).not.toBe(first);
+                    // and a script this build does not own is left exactly as the page asked
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\"></sasjs>"),
+                        '<script src="https://cdn.example.com/lib.js"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 4:
+                    _a.sent();
+                    expect(specs()[0].src).toBe('https://cdn.example.com/lib.js');
                     return [2 /*return*/];
             }
         });
@@ -642,6 +695,43 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    it('ships a recorded SAS session when the project has one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var recording, result;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    recording = (_a = {},
+                        _a["/sasjs/drive/files".concat(appLoc, "/services/public/report.sas")] = {
+                            log: 'NOTE: Copyright (c) 2016 by SAS Institute Inc., Cary, NC, USA.',
+                            print: 'The SAS System',
+                            webout: '{"SYSSITE":"00000000"}'
+                        },
+                        _a);
+                    write(path_1.default.join(root, 'sasjsbuild', 'sas-transcript.json'), JSON.stringify(recording));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    expect(result.sasTranscript).toBe(true);
+                    expect(JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'sas-transcript.json'), 'utf8'))).toEqual(recording);
+                    expect(readConfig().sasTranscript).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('ships no recording when the project has none', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.sasTranscript).toBe(false);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'host', 'sas-transcript.json'))).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('ships no snapshot when the project has none', function () { return __awaiter(void 0, void 0, void 0, function () {
         var result;
         return __generator(this, function (_a) {

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

@@ -163,7 +163,7 @@ var loadWorker = function (base) {
     };
     require('../assets/sw.js');
     global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
-        var target;
+        var target, fixture;
         var _a;
         return __generator(this, function (_b) {
             target = typeof input === 'string' ? input : (input && input.url) || String(input);
@@ -175,6 +175,10 @@ var loadWorker = function (base) {
                     })];
             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' } })];
+            if (target.includes('sas-transcript')) {
+                fixture = global.__sasTranscript;
+                return [2 /*return*/, fixture ? jsonResponse(fixture) : new Response('', { status: 404 })];
+            }
             return [2 /*return*/, target.includes('vfs-seed')
                     ? jsonResponse({
                         files: (_a = {},
@@ -286,6 +290,104 @@ describe('service worker host', function () {
             }
         });
     }); });
+    it('answers a recorded SAS session with its log, listing and webout', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    // A browser has no SAS binary. A project may ship the transcript of one real
+                    // session, and a program it names is answered with it - framed the way the
+                    // adapter and the Studio split the three parts: webout SEP log SEP listing.
+                    ;
+                    global.__sasTranscript = (_a = {},
+                        _a["".concat(appLoc, "/services/public/report.sas")] = {
+                            webout: '{"SYSSITE":"00000000"}',
+                            log: 'NOTE: Copyright (c) 2016 by SAS Institute Inc., Cary, NC, USA.',
+                            print: 'The SAS System\n\n  Obs    customer\n    1    Northwind Ltd'
+                        },
+                        _a);
+                    worker = loadWorker();
+                    worker.runtime.load((_b = {},
+                        _b[drivePath('services/public/report.sas')] = 'data work.class; run;',
+                        _b));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/report")) +
+                            '&_debug=131')];
+                case 1:
+                    response = _c.sent();
+                    expect(response.status).toBe(200);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _c.sent();
+                    expect(body).toContain('NOTE: Copyright');
+                    expect(body).toContain('Northwind Ltd');
+                    expect(body).toContain('"SYSSITE":"00000000"');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('gives a recorded run the seeded content type when not debugging', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    // Without `_debug` the body is the webout alone, and it still has to carry
+                    // the type a session is seeded with - an empty header set leaves the choice
+                    // to the browser, which is the case the seed exists to prevent.
+                    ;
+                    global.__sasTranscript = (_b = {},
+                        _b["".concat(appLoc, "/services/public/report.sas")] = {
+                            webout: '{"SYSSITE":"00000000"}',
+                            log: 'NOTE: recorded',
+                            print: 'The SAS System'
+                        },
+                        _b);
+                    worker = loadWorker();
+                    worker.runtime.load((_c = {},
+                        _c[drivePath('services/public/report.sas')] = 'data work.class; run;',
+                        _c));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/report")))];
+                case 1:
+                    response = _d.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, [_d.sent()]).toBe('{"SYSSITE":"00000000"}');
+                    delete global.__sasTranscript;
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a .sas program no recording names, as it always did', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, response, body;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = loadWorker();
+                    worker.runtime.load((_a = {},
+                        _a[drivePath('services/public/other.sas')] = 'data work.class; run;',
+                        _a));
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/execute?_program=' +
+                            encodeURIComponent("".concat(appLoc, "/services/public/other")))];
+                case 1:
+                    response = _b.sent();
+                    expect(response.status).toBe(400);
+                    return [4 /*yield*/, response.text()];
+                case 2:
+                    body = _b.sent();
+                    expect(body).toContain('runTime');
+                    expect(body).not.toContain('SyntaxError');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     /**
      * A worker whose drive holds one service that answers with a download, the
      * way a streaming service does on the server: the body goes to the webout
@@ -1059,6 +1161,41 @@ describe('service worker host', function () {
                 }
             });
         }); });
+        it('keeps a trigger a JSON answer, not the recorded transcript', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response, body;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // A recording answers a run, not a trigger: the trigger route answers with
+                        // the session record a client parses as JSON, so returning the framed
+                        // webout there would break triggerProgram and the Studio.
+                        ;
+                        global.__sasTranscript = (_a = {},
+                            _a["".concat(appLoc, "/services/public/report.sas")] = {
+                                webout: '{"SYSSITE":"00000000"}',
+                                log: 'NOTE: recorded',
+                                print: 'The SAS System'
+                            },
+                            _a);
+                        worker = loadWorker();
+                        worker.runtime.load((_b = {},
+                            _b[drivePath('services/public/report.sas')] = 'data work.class; run;',
+                            _b));
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/stp/trigger?_program=' +
+                                encodeURIComponent("".concat(appLoc, "/services/public/report")), runRequest({ params: {} }))];
+                    case 1:
+                        response = _c.sent();
+                        expect(response.headers.get('content-type')).toContain('application/json');
+                        return [4 /*yield*/, response.json()];
+                    case 2:
+                        body = _c.sent();
+                        expect(body).not.toHaveProperty('webout');
+                        delete global.__sasTranscript;
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         it('refuses a deploy upload with no archive, and one that is not a zip', function () { return __awaiter(void 0, void 0, void 0, function () {
             var dispatch, empty, _a, form, notZip, _b;
             return __generator(this, function (_c) {

package/package.json

@@ -125,5 +125,5 @@
     "ws": "8.21.0",
     "nanoid": "3.3.18"
   },
-  "version": "6.22.0"
+  "version": "6.23.1"
 }