@lowdefy/shell 0.0.0-experimental-20261019052246

package/src/host/createShellFetch.js

@@ -0,0 +1,60 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+const BUILD_HEADER = 'x-lowdefy-build';
+
+/**
+ * The fetch the core's requests and endpoint calls go through.
+ *
+ * - A page request carries the build of the root the shell holds (the core stamps the build it was
+ *   created with; the shell keeps it current without rebuilding the core).
+ * - The server refuses a page request from another build with a 409. The shell then syncs: it
+ *   refetches the root and the changed pages. When the request's own page did not change with the
+ *   build, its payload is still the shape the new build expects, so the request is retried once,
+ *   stamped with the new build. When the page changed, the 409 goes to the core, which hands it to
+ *   onBuildChanged: the screen is rebuilt on the new page and runs its requests again.
+ *
+ * @param {Object} params
+ * @param {Function} params.fetch The Fetch API, sending the shell header (withShellHeader).
+ * @param {Object} params.session The app session (createAppSession).
+ */
+function createShellFetch({ fetch, session }) {
+  return async function shellFetch(url, init = {}) {
+    const headers = { ...init.headers };
+    const stamped = headers[BUILD_HEADER] !== undefined;
+    if (stamped) {
+      headers[BUILD_HEADER] = session.getState().buildId ?? headers[BUILD_HEADER];
+    }
+    const res = await fetch(url, { ...init, headers });
+    if (res.status !== 409 || !stamped) {
+      return res;
+    }
+    const before = session.getRequestPageEntry(url);
+    try {
+      await session.sync();
+    } catch (error) {
+      return res;
+    }
+    const after = session.getRequestPageEntry(url);
+    if (before === null || after === null || before.hash !== after.hash) {
+      return res;
+    }
+    const buildId = session.getState().buildId ?? headers[BUILD_HEADER];
+    return fetch(url, { ...init, headers: { ...headers, [BUILD_HEADER]: buildId } });
+  };
+}
+
+export default createShellFetch;

package/src/host/createShellFetch.test.js

@@ -0,0 +1,150 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import createAppSession from '../session/createAppSession.js';
+import createFakeServer, { header } from '../test/createFakeServer.js';
+import createMemoryCacheStore from '../test/createMemoryCacheStore.js';
+import createMemoryStore from './createMemoryStore.js';
+import createShellFetch from './createShellFetch.js';
+import { createPages, createRoot } from '../test/fixtures.js';
+
+const apiBase = 'https://field.example.com';
+
+async function setup() {
+  const server = createFakeServer({
+    root: createRoot(),
+    rootEtag: '"root-1"',
+    pages: createPages([
+      ['today', 'today', '"p-today-1"'],
+      ['jobs', 'jobs', '"p-jobs-1"'],
+      ['jobs/{job_id}', 'job', '"p-job-1"'],
+    ]),
+    requests: () => ({ id: 'get_jobs', success: true, response: [] }),
+  });
+  const session = createAppSession({
+    apiBase,
+    app: { id: 'field' },
+    cacheStore: createMemoryCacheStore(),
+    fetch: server.fetch,
+    kv: createMemoryStore(),
+    tokenStore: { get: () => null },
+  });
+  await session.start();
+  const shellFetch = createShellFetch({ fetch: server.fetch, session });
+  return { server, session, shellFetch };
+}
+
+function deploy({ server, todayHash }) {
+  server.state.buildId = 'build-2';
+  server.state.root = createRoot({
+    buildId: 'build-2',
+    pageIndex: [
+      { path: 'today', pageId: 'today', hash: todayHash, typesKey: 'carried' },
+      { path: 'jobs', pageId: 'jobs', hash: 'h-jobs-1', typesKey: 'carried' },
+    ],
+  });
+  server.state.rootEtag = '"root-2"';
+}
+
+const requestInit = {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json', 'x-lowdefy-build': 'build-1' },
+  body: '{}',
+};
+
+test('a page request carries the build of the root the shell holds', async () => {
+  const { server, shellFetch } = await setup();
+  const res = await shellFetch(`${apiBase}/api/request/jobs/get_jobs`, {
+    ...requestInit,
+    headers: { ...requestInit.headers, 'x-lowdefy-build': 'stale-core-build' },
+  });
+  expect(res.status).toBe(200);
+  expect(header(server.fetch.mock.calls.at(-1)[1], 'x-lowdefy-build')).toBe('build-1');
+});
+
+test('a 409 syncs the root and changed pages, then retries the request once on the new build', async () => {
+  const { server, session, shellFetch } = await setup();
+  deploy({ server, todayHash: 'h-today-2' });
+  server.state.pages.today = { pageConfig: { pageId: 'today', v: 2 }, etag: '"p-today-2"' };
+  server.fetch.mockClear();
+  const res = await shellFetch(`${apiBase}/api/request/jobs/get_jobs`, requestInit);
+  expect(res.status).toBe(200);
+  expect(await res.json()).toEqual({ id: 'get_jobs', success: true, response: [] });
+  const urls = server.fetch.mock.calls.map(([url]) => new URL(url).pathname);
+  expect(urls).toEqual([
+    '/api/request/jobs/get_jobs',
+    '/api/mobile/root',
+    '/api/user',
+    '/api/page/today',
+    '/api/request/jobs/get_jobs',
+  ]);
+  expect(header(server.fetch.mock.calls.at(-1)[1], 'x-lowdefy-build')).toBe('build-2');
+  expect(session.getState().buildId).toBe('build-2');
+  expect(session.getState().pages.today.pageConfig.v).toBe(2);
+});
+
+test('a 409 for a page that changed with the build goes to the core, not retried', async () => {
+  const { server, session, shellFetch } = await setup();
+  deploy({ server, todayHash: 'h-today-2' });
+  server.fetch.mockClear();
+  const res = await shellFetch(`${apiBase}/api/request/today/get_jobs`, requestInit);
+  expect(res.status).toBe(409);
+  expect((await res.json()).buildId).toBe('build-2');
+  expect(server.fetch.mock.calls.filter(([url]) => url.includes('/api/request/'))).toHaveLength(1);
+  expect(session.getState().buildId).toBe('build-2');
+});
+
+test('a second 409 after the retry goes to the core', async () => {
+  const { server, shellFetch } = await setup();
+  deploy({ server, todayHash: 'h-today-1' });
+  const serve = server.fetch.getMockImplementation();
+  server.fetch.mockImplementation(async (url, init) => {
+    if (url.includes('/api/request/')) {
+      return {
+        ok: false,
+        status: 409,
+        headers: { get: () => null },
+        json: async () => ({ buildId: 'build-3' }),
+      };
+    }
+    return serve(url, init);
+  });
+  const res = await shellFetch(`${apiBase}/api/request/jobs/get_jobs`, requestInit);
+  expect(res.status).toBe(409);
+  expect(server.fetch.mock.calls.filter(([url]) => url.includes('/api/request/'))).toHaveLength(2);
+});
+
+test('a 409 the shell cannot sync for goes to the core', async () => {
+  const { server, shellFetch } = await setup();
+  deploy({ server, todayHash: 'h-today-1' });
+  const serve = server.fetch.getMockImplementation();
+  server.fetch.mockImplementation(async (url, init) => {
+    if (url.includes('/api/mobile/root')) throw new TypeError('Network request failed');
+    return serve(url, init);
+  });
+  const res = await shellFetch(`${apiBase}/api/request/jobs/get_jobs`, requestInit);
+  expect(res.status).toBe(409);
+});
+
+test('a call without a build stamp (an endpoint call) is never retried', async () => {
+  const { server, shellFetch } = await setup();
+  deploy({ server, todayHash: 'h-today-1' });
+  server.fetch.mockClear();
+  const res = await shellFetch(`${apiBase}/api/endpoints/save`, { method: 'POST', headers: {} });
+  expect(res.status).toBe(404);
+  expect(server.fetch).toHaveBeenCalledTimes(1);
+  expect(header(server.fetch.mock.calls[0][1], 'x-lowdefy-build')).toBeNull();
+});

package/src/host/createShellGlobals.js

@@ -0,0 +1,62 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { createNativeGlobals } from '@lowdefy/client-native';
+
+/**
+ * The host globals of one app in the shell: @lowdefy/client-native's (the shown route, window
+ * size, visibility, network and the pages' elements), and the device services the shell's native
+ * actions reach (src/actions):
+ * - `clipboard`: `{ setString(text) }`, for CopyToClipboard.
+ * - `storage`: the device store the core keeps the app's and its users' keys in
+ *   (`{ get, set, remove, keys }`), for the local storage actions. Sign-out clears the user keys
+ *   from it.
+ * - `shownScreen`: `{ instanceId }`, the route instance of the focused screen, whose page context
+ *   is keyed by it (client-native LowdefyPage); Lowdefy Dev finds the shown page's context by it.
+ *
+ * @param {Object} params
+ * @param {(url: string) => void} params.assign
+ * @param {{ setString: (text: string) => Promise<void> }} params.clipboard
+ * @param {Function} params.fetch
+ * @param {() => (string|null)} params.getInstanceId The focused screen's route instance.
+ * @param {() => string} params.getPath
+ * @param {Object} [params.network]
+ * @param {string} params.origin
+ * @param {Object} params.storage
+ */
+function createShellGlobals({
+  assign,
+  clipboard,
+  fetch,
+  getInstanceId,
+  getPath,
+  network,
+  origin,
+  storage,
+}) {
+  return {
+    ...createNativeGlobals({ assign, fetch, getPath, network, origin }),
+    clipboard,
+    shownScreen: {
+      get instanceId() {
+        return getInstanceId();
+      },
+    },
+    storage,
+  };
+}
+
+export default createShellGlobals;

package/src/host/createShellHost.js

@@ -0,0 +1,73 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { Linking } from 'react-native';
+import * as Clipboard from 'expo-clipboard';
+
+import createDeviceStore from './createDeviceStore.js';
+import createMemoryStore from './createMemoryStore.js';
+import createShellGlobals from './createShellGlobals.js';
+import getOrigin from './getOrigin.js';
+import networkStatus from './networkStatus.js';
+
+// The app's `online` and `offline` events follow the shell's one online state.
+const network = {
+  addListener: networkStatus.subscribe,
+};
+
+/**
+ * The @lowdefy/client-core host for one app in the shell. Calls are signed in with the session
+ * token as a bearer token. The core's build and caller handling lands on the session: a page
+ * request refused for another build is retried by `fetch` (createShellFetch) or rebuilds the
+ * screens (onBuildChanged); another caller resets the app (onCallerChanged).
+ */
+const clipboard = {
+  setString: (text) => Clipboard.setStringAsync(text),
+};
+
+function createShellHost({ fetch, router, session, streamFetch, tokenStore, WebSocket }) {
+  const storage = createDeviceStore();
+  return {
+    authTransport: 'bearer',
+    fetch,
+    globals: createShellGlobals({
+      assign: (url) => Linking.openURL(url),
+      clipboard,
+      fetch,
+      getInstanceId: session.getCurrentInstanceId,
+      getPath: session.getCurrentPath,
+      network,
+      origin: getOrigin(session.apiBase),
+      storage,
+    }),
+    onBuildChanged: () => {
+      session.handleBuildChanged();
+    },
+    onCallerChanged: () => {
+      session.handleCallerChanged();
+    },
+    router,
+    sessionStorage: createMemoryStore(),
+    storage,
+    // The Fetch API whose response body streams, for blocks (client-native's createStreamFetch).
+    streamFetch,
+    tokenStore,
+    WebSocket,
+    websocketUrl: (apiPath) => apiPath.replace(/^http/, 'ws'),
+  };
+}
+
+export default createShellHost;

package/src/host/createShellHost.test.js

@@ -0,0 +1,36 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { jest } from '@jest/globals';
+
+import createShellHost from './createShellHost.js';
+
+jest.mock('expo-clipboard', () => ({ setStringAsync: jest.fn(async () => true) }));
+jest.mock('./createDeviceStore.js', () => () => ({}));
+jest.mock('./networkStatus.js', () => ({ subscribe: () => () => undefined }));
+
+// Copy link and the other CopyToClipboard actions reach the phone's clipboard through the host.
+test('the host clipboard copies through expo-clipboard', async () => {
+  const Clipboard = jest.requireMock('expo-clipboard');
+  const session = {
+    apiBase: 'https://field.example.com',
+    getCurrentInstanceId: () => null,
+    getCurrentPath: () => '/',
+  };
+  const host = createShellHost({ fetch: jest.fn(), router: {}, session, tokenStore: {} });
+  await host.globals.clipboard.setString('https://field.example.com/tasks/12');
+  expect(Clipboard.setStringAsync.mock.calls).toEqual([['https://field.example.com/tasks/12']]);
+});

package/src/host/getOrigin.js

@@ -0,0 +1,26 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The origin of the app server's URL: its scheme, host and port.
+function getOrigin(url) {
+  const match = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]+/i.exec(url);
+  if (match === null) {
+    throw new Error(`Shell app url is not an absolute URL. Received ${JSON.stringify(url)}.`);
+  }
+  return match[0];
+}
+
+export default getOrigin;

package/src/host/isOnline.js

@@ -0,0 +1,22 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// An expo-network state counts as offline only when it says so: unknown reachability is online.
+function isOnline(networkState) {
+  return networkState.isConnected !== false && networkState.isInternetReachable !== false;
+}
+
+export default isOnline;

package/src/host/networkStatus.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import * as Network from 'expo-network';
+
+import createNetworkStatus from './createNetworkStatus.js';
+
+// The shell's one online state (createNetworkStatus), shared by every app the shell opens.
+const networkStatus = createNetworkStatus({ network: Network });
+
+export default networkStatus;

package/src/host/withShellHeader.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// Every call a shell makes carries x-lowdefy-shell, its version: the server serves mobile pages
+// only to shells and web pages only to browsers.
+function withShellHeader({ fetch, shellVersion }) {
+  return function shellHeaderFetch(url, init = {}) {
+    return fetch(url, { ...init, headers: { ...init.headers, 'x-lowdefy-shell': shellVersion } });
+  };
+}
+
+export default withShellHeader;

package/src/host/withShellHeader.test.js

@@ -0,0 +1,28 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { jest } from '@jest/globals';
+
+import withShellHeader from './withShellHeader.js';
+
+test('every call carries the shell version as x-lowdefy-shell', async () => {
+  const fetch = jest.fn(async () => ({ status: 200 }));
+  const shellFetch = withShellHeader({ fetch, shellVersion: '7.4.0' });
+  await shellFetch('https://app.example.com/api/page/home', { headers: { Accept: 'x' } });
+  await shellFetch('https://app.example.com/api/user');
+  expect(fetch.mock.calls[0][1].headers).toEqual({ Accept: 'x', 'x-lowdefy-shell': '7.4.0' });
+  expect(fetch.mock.calls[1][1].headers).toEqual({ 'x-lowdefy-shell': '7.4.0' });
+});

package/src/js/evaluateJsEntries.js

@@ -0,0 +1,43 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+/**
+ * The one place the shell turns `_js` source into functions. A shell is shared by every app, so
+ * it cannot carry an app's compiled clientJsMap: each mobile page, and the mobile root for the
+ * app events, carries its `_js` as `_jsEntries`, the module text the build generates
+ * (`export default { [hash]: fn }`). It is evaluated with `new Function`, as the dev server
+ * evaluates a page it builds on request (server-dev usePageConfig), and keeps the `volatile` flag
+ * the module sets for dependency tracking.
+ *
+ * Hermes must run `new Function` for this to work. Should it not, `_js` on mobile pages becomes a
+ * build error, and this function the one place that refuses it.
+ *
+ * @param {string|null|undefined} jsEntries The module text; none when the page has no `_js`.
+ * @returns {Object} `{ [hash]: fn }`, the jsMap the engine's `_js` operator reads.
+ */
+function evaluateJsEntries(jsEntries) {
+  if (type.isNone(jsEntries)) {
+    return {};
+  }
+  const define = new Function('exports', jsEntries.replace('export default', 'exports.default ='));
+  const module = {};
+  define(module);
+  return module.default;
+}
+
+export default evaluateJsEntries;

package/src/js/evaluateJsEntries.test.js

@@ -0,0 +1,48 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import evaluateJsEntries from './evaluateJsEntries.js';
+import helloJsEntries from '../../fixtures/hello.jsEntries.json';
+
+const accessors = {
+  lowdefyGlobal: (key) => ({ greeting: 'Hello from Lowdefy' })[key],
+};
+
+test('evaluateJsEntries turns the hello page module text into its _js functions', () => {
+  const jsMap = evaluateJsEntries(helloJsEntries.today);
+  expect(Object.keys(jsMap)).toEqual([
+    'HorPchxU3cTNYhB6dbx9DFcepx4=',
+    'b+IYcPY3kW9J7YdZ4RyICtelfz8=',
+  ]);
+  expect(jsMap['HorPchxU3cTNYhB6dbx9DFcepx4='](accessors)).toBe('Hello from Lowdefy');
+  expect(jsMap['b+IYcPY3kW9J7YdZ4RyICtelfz8='](accessors)).toBe(String(new Date().getFullYear()));
+});
+
+test('evaluateJsEntries keeps the volatile flag dependency tracking reads', () => {
+  const jsMap = evaluateJsEntries(helloJsEntries.today);
+  expect(jsMap['b+IYcPY3kW9J7YdZ4RyICtelfz8='].volatile).toBe(true);
+  expect(jsMap['HorPchxU3cTNYhB6dbx9DFcepx4='].volatile).toBeUndefined();
+});
+
+test('evaluateJsEntries evaluates the app events module text of the root', () => {
+  const jsMap = evaluateJsEntries(helloJsEntries.app);
+  expect(jsMap['yHZGzdxAuSQ8P5USi0AFFY81iNg='](accessors)).toBe('Hello from Lowdefy');
+});
+
+test('evaluateJsEntries gives an empty map for a page without _js', () => {
+  expect(evaluateJsEntries(undefined)).toEqual({});
+  expect(evaluateJsEntries(null)).toEqual({});
+});