@lowdefy/shell 3.23.3 → 7.2.0

package/src/device/tracking/index.js

@@ -0,0 +1,211 @@
+/*
+  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 Location from 'expo-location';
+import * as TaskManager from 'expo-task-manager';
+import { UserError } from '@lowdefy/errors';
+
+import callEndpoint from '../../native/callEndpoint.js';
+import createBacklog from './createBacklog.js';
+import createDeviceStore from '../../host/createDeviceStore.js';
+import { getCurrentApp, peekCurrentApp } from '../../native/currentApp.js';
+import reportShellError from '../../host/reportShellError.js';
+
+const LOCATION_TASK = 'lowdefy-location-tracking';
+const GEOFENCE_TASK = 'lowdefy-geofencing';
+const CONFIG_KEY = 'lowdefy-shell:tracking';
+const ACCURACY = {
+  low: Location.Accuracy.Low,
+  balanced: Location.Accuracy.Balanced,
+  high: Location.Accuracy.High,
+  navigation: Location.Accuracy.BestForNavigation,
+};
+
+// The device store and the backlog of posts, opened on first use: loading the module, which every
+// field-tracking shell does at launch, touches no storage.
+let stores = null;
+function getStores() {
+  if (stores === null) {
+    const kv = createDeviceStore();
+    stores = { kv, backlog: createBacklog({ key: 'lowdefy-shell:tracking-backlog', kv }) };
+  }
+  return stores;
+}
+
+function readConfig() {
+  return JSON.parse(getStores().kv.get(CONFIG_KEY) ?? '{}');
+}
+
+function writeConfig(update) {
+  getStores().kv.set(CONFIG_KEY, JSON.stringify({ ...readConfig(), ...update }));
+}
+
+// A refusal the server will repeat however often the post is sent (bad payload, missing endpoint,
+// forbidden): the post is dropped and reported, so one bad post does not hold up the backlog behind
+// it. A lost session (401), a timeout or rate limit, and server errors stay for the next wake.
+function isRefused(error) {
+  const { status } = error ?? {};
+  return status >= 400 && status < 500 && ![401, 408, 429].includes(status);
+}
+
+// Posts to an endpoint with the open app's session; on failure the post waits in the backlog for
+// the next wake. Kept posts go first, so the endpoint sees them in order.
+async function post({ endpointId, payload }) {
+  const app = await getCurrentApp();
+  const { backlog } = getStores();
+  const send = async (entry) => {
+    try {
+      await callEndpoint({ app, endpointId: entry.endpointId, payload: entry.payload });
+    } catch (error) {
+      if (!isRefused(error)) throw error;
+      reportShellError({ error, session: app.session });
+    }
+  };
+  await backlog.flush(send);
+  try {
+    await send({ endpointId, payload });
+  } catch (error) {
+    reportShellError({ error, session: app.session });
+    backlog.add({ endpointId, payload });
+  }
+}
+
+function toPoint({ coords, timestamp }) {
+  return {
+    latitude: coords.latitude,
+    longitude: coords.longitude,
+    accuracy: coords.accuracy,
+    altitude: coords.altitude,
+    heading: coords.heading,
+    speed: coords.speed,
+    timestamp: new Date(timestamp).toISOString(),
+  };
+}
+
+// Background tasks are defined when the bundle loads, so a launch in the background finds them.
+TaskManager.defineTask(LOCATION_TASK, async ({ data, error }) => {
+  const { locationEndpointId } = readConfig();
+  if (error) {
+    reportShellError({ error });
+    return;
+  }
+  if (typeof locationEndpointId !== 'string') return;
+  await post({
+    endpointId: locationEndpointId,
+    payload: { locations: data.locations.map(toPoint) },
+  });
+});
+
+TaskManager.defineTask(GEOFENCE_TASK, async ({ data, error }) => {
+  const { geofenceEndpointId } = readConfig();
+  if (error) {
+    reportShellError({ error });
+    return;
+  }
+  const event = {
+    event: data.eventType === Location.GeofencingEventType.Enter ? 'enter' : 'exit',
+    region: {
+      id: data.region.identifier,
+      latitude: data.region.latitude,
+      longitude: data.region.longitude,
+      radius: data.region.radius,
+    },
+    timestamp: new Date().toISOString(),
+  };
+  peekCurrentApp()?.triggerAppEvent({ name: 'onGeofence', event });
+  if (typeof geofenceEndpointId === 'string') {
+    await post({ endpointId: geofenceEndpointId, payload: event });
+  }
+});
+
+// Background location needs "while using" first, then "always".
+async function allowBackground() {
+  const foreground = await Location.requestForegroundPermissionsAsync();
+  if (!foreground.granted) {
+    throw new UserError('Location permission was denied.');
+  }
+  const background = await Location.requestBackgroundPermissionsAsync();
+  if (!background.granted) {
+    throw new UserError('Background location permission was denied.');
+  }
+}
+
+/**
+ * The tracking device feature (profile field-tracking): location tracking and geofences that keep
+ * running with the app closed. Points and region changes post to the app's endpoints (with the
+ * session token the profile keeps readable after first unlock); posts that fail wait for the next
+ * wake. iOS watches at most 20 regions.
+ */
+const tracking = {
+  async startTracking({
+    accuracy = 'balanced',
+    distanceInterval = 50,
+    endpointId,
+    notificationBody = 'Recording your trip.',
+    notificationTitle = 'Location on',
+    timeInterval = 60,
+  }) {
+    await allowBackground();
+    writeConfig({ locationEndpointId: endpointId });
+    await Location.startLocationUpdatesAsync(LOCATION_TASK, {
+      accuracy: ACCURACY[accuracy] ?? ACCURACY.balanced,
+      distanceInterval,
+      timeInterval: timeInterval * 1000,
+      deferredUpdatesInterval: timeInterval * 1000,
+      pausesUpdatesAutomatically: true,
+      showsBackgroundLocationIndicator: true,
+      foregroundService: { notificationTitle, notificationBody },
+    });
+    return { tracking: true };
+  },
+  async stopTracking() {
+    if (await Location.hasStartedLocationUpdatesAsync(LOCATION_TASK)) {
+      await Location.stopLocationUpdatesAsync(LOCATION_TASK);
+    }
+    return { tracking: false };
+  },
+  async startGeofencing({ endpointId, regions }) {
+    if (regions.length > 20) {
+      throw new Error(`StartGeofencing watches at most 20 regions. Received ${regions.length}.`);
+    }
+    await allowBackground();
+    writeConfig({ geofenceEndpointId: endpointId ?? null });
+    await Location.startGeofencingAsync(
+      GEOFENCE_TASK,
+      regions.map((region) => ({
+        identifier: region.id,
+        latitude: region.latitude,
+        longitude: region.longitude,
+        radius: region.radius,
+        notifyOnEnter: true,
+        notifyOnExit: true,
+      }))
+    );
+    return { regions: regions.length };
+  },
+  async stopGeofencing() {
+    if (await Location.hasStartedGeofencingAsync(GEOFENCE_TASK)) {
+      await Location.stopGeofencingAsync(GEOFENCE_TASK);
+    }
+    return { regions: 0 };
+  },
+};
+
+// The `field-tracking` profile's device features (profiles.js TRACKING_ENTRY).
+const features = { tracking };
+const hosts = [];
+
+export { features, hosts };

package/src/device/tracking/index.test.js

@@ -0,0 +1,110 @@
+/*
+  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 mockTasks = {};
+const mockValues = new Map();
+const mockApp = { triggerAppEvent: jest.fn() };
+
+jest.mock('expo-task-manager', () => ({
+  defineTask: (name, task) => {
+    mockTasks[name] = task;
+  },
+}));
+jest.mock('expo-location', () => ({
+  Accuracy: {},
+  GeofencingEventType: { Enter: 1, Exit: 2 },
+}));
+jest.mock('../../host/createDeviceStore.js', () => () => ({
+  get: (key) => mockValues.get(key) ?? null,
+  set: (key, value) => mockValues.set(key, value),
+}));
+jest.mock('../../native/currentApp.js', () => ({
+  getCurrentApp: async () => mockApp,
+  peekCurrentApp: () => mockApp,
+}));
+jest.mock('../../native/callEndpoint.js', () => jest.fn());
+
+const callEndpoint = require('../../native/callEndpoint.js');
+const createNetworkError = require('../../test/createNetworkError.js').default;
+
+require('./index.js');
+
+function refusal(status) {
+  return Object.assign(new Error(`answered ${status}`), { status });
+}
+
+function backlog() {
+  return JSON.parse(mockValues.get('lowdefy-shell:tracking-backlog') ?? '[]');
+}
+
+const locations = [{ coords: { latitude: 1, longitude: 2 }, timestamp: Date.UTC(2026, 0, 1) }];
+
+beforeEach(() => {
+  mockValues.clear();
+  mockValues.set('lowdefy-shell:tracking', JSON.stringify({ locationEndpointId: 'trip' }));
+});
+
+test('a location post that fails waits in the backlog and goes first on the next wake', async () => {
+  callEndpoint.mockRejectedValueOnce(createNetworkError());
+  await mockTasks['lowdefy-location-tracking']({ data: { locations } });
+  expect(backlog()).toHaveLength(1);
+  callEndpoint.mockResolvedValue(null);
+  await mockTasks['lowdefy-location-tracking']({ data: { locations } });
+  expect(backlog()).toEqual([]);
+  expect(callEndpoint).toHaveBeenCalledTimes(3);
+  expect(callEndpoint.mock.calls[1][0]).toMatchObject({ app: mockApp, endpointId: 'trip' });
+});
+
+test('a post the server refuses is dropped, so it does not hold up the backlog', async () => {
+  mockValues.set(
+    'lowdefy-shell:tracking-backlog',
+    JSON.stringify([{ endpointId: 'trip', payload: { bad: true } }])
+  );
+  callEndpoint.mockRejectedValueOnce(refusal(400)).mockResolvedValueOnce(null);
+  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+  await mockTasks['lowdefy-location-tracking']({ data: { locations } });
+  expect(backlog()).toEqual([]);
+  expect(callEndpoint).toHaveBeenCalledTimes(2);
+  // Dropped, but reported: the app's endpoint or payload needs fixing.
+  expect(consoleError).toHaveBeenCalledWith(expect.objectContaining({ status: 400 }));
+  consoleError.mockRestore();
+});
+
+test('a post refused for a lost session stays for the next wake', async () => {
+  callEndpoint.mockRejectedValueOnce(refusal(401));
+  const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+  await mockTasks['lowdefy-location-tracking']({ data: { locations } });
+  expect(backlog()).toHaveLength(1);
+  consoleError.mockRestore();
+});
+
+test('a geofence crossing raises onGeofence and posts to its endpoint', async () => {
+  mockValues.set('lowdefy-shell:tracking', JSON.stringify({ geofenceEndpointId: 'fence' }));
+  callEndpoint.mockResolvedValue(null);
+  await mockTasks['lowdefy-geofencing']({
+    data: {
+      eventType: 1,
+      region: { identifier: 'depot', latitude: 1, longitude: 2, radius: 100 },
+    },
+  });
+  expect(mockApp.triggerAppEvent).toHaveBeenCalledWith(
+    expect.objectContaining({ name: 'onGeofence' })
+  );
+  expect(callEndpoint.mock.calls[0][0]).toMatchObject({
+    endpointId: 'fence',
+    payload: { event: 'enter', region: { id: 'depot' } },
+  });
+});

package/src/host/createDeviceStore.js

@@ -0,0 +1,32 @@
+/*
+  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 { Storage } from 'expo-sqlite/kv-store';
+
+// The host store that lasts on the device ({ get, set, remove, keys }), over SQLite's key-value
+// store. The core namespaces its keys per app and user.
+function createDeviceStore() {
+  return {
+    get: (key) => Storage.getItemSync(key),
+    set: (key, value) => Storage.setItemSync(key, String(value)),
+    remove: (key) => {
+      Storage.removeItemSync(key);
+    },
+    keys: () => Storage.getAllKeysSync(),
+  };
+}
+
+export default createDeviceStore;

package/src/host/createMemoryStore.js

@@ -0,0 +1,32 @@
+/*
+  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.
+*/
+
+// A host store held in memory, for the session store: it lasts as long as the app runs.
+function createMemoryStore() {
+  const stored = new Map();
+  return {
+    get: (key) => stored.get(key) ?? null,
+    set: (key, value) => {
+      stored.set(key, String(value));
+    },
+    remove: (key) => {
+      stored.delete(key);
+    },
+    keys: () => [...stored.keys()],
+  };
+}
+
+export default createMemoryStore;

package/src/host/createNetworkStatus.js

@@ -0,0 +1,94 @@
+/*
+  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 isOnline from './isOnline.js';
+
+/**
+ * The shell's one online state. The NoConnection banner and the app's `online` and `offline`
+ * events (createShellHost) read it, and two sources feed it:
+ * - the phone's network, through expo-network, read while anything subscribes;
+ * - Lowdefy Dev's network injection (`setInjectedOffline`), since a simulator or emulator shares
+ *   the computer's network and cannot go offline itself. A release shell never sets it.
+ *
+ * The shell is online when the phone's network is up and nothing injected offline. Subscribers
+ * hear only changes, as a browser fires `online` and `offline`.
+ *
+ * @param {Object} params
+ * @param {Object} params.network expo-network: `addNetworkStateListener` and
+ *   `getNetworkStateAsync`.
+ */
+function createNetworkStatus({ network }) {
+  const listeners = new Set();
+  let deviceOnline = true;
+  let injectedOffline = false;
+  let online = true;
+  let stopListening = null;
+
+  function settle() {
+    const next = deviceOnline && !injectedOffline;
+    if (next === online) return;
+    online = next;
+    [...listeners].forEach((listener) => listener(online));
+  }
+
+  function setDeviceState(state) {
+    deviceOnline = isOnline(state);
+    settle();
+  }
+
+  // Reads the phone's network until stopped. A change heard before the first read answers is
+  // newer than that read, so the read is then dropped.
+  function listen() {
+    let heard = false;
+    let active = true;
+    const subscription = network.addNetworkStateListener((state) => {
+      heard = true;
+      setDeviceState(state);
+    });
+    network.getNetworkStateAsync().then((state) => {
+      if (active && !heard) setDeviceState(state);
+    });
+    return () => {
+      active = false;
+      subscription.remove();
+    };
+  }
+
+  // Calls the listener with the new online state on every change; returns the function that
+  // stops it.
+  function subscribe(listener) {
+    if (listeners.size === 0) {
+      stopListening = listen();
+    }
+    listeners.add(listener);
+    return () => {
+      if (!listeners.delete(listener)) return;
+      if (listeners.size === 0) {
+        stopListening();
+        stopListening = null;
+      }
+    };
+  }
+
+  function setInjectedOffline(offline) {
+    injectedOffline = offline;
+    settle();
+  }
+
+  return { isOnline: () => online, setInjectedOffline, subscribe };
+}
+
+export default createNetworkStatus;

package/src/host/createNetworkStatus.test.js

@@ -0,0 +1,94 @@
+/*
+  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 createFakeNetwork, { OFFLINE, ONLINE } from '../test/createFakeNetwork.js';
+import createNetworkStatus from './createNetworkStatus.js';
+
+// Lets the first read of the phone's network answer.
+const settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+test('the phone going offline and back is heard by subscribers, once per change', async () => {
+  const network = createFakeNetwork();
+  const status = createNetworkStatus({ network });
+  const listener = jest.fn();
+  status.subscribe(listener);
+  await settle();
+  expect(status.isOnline()).toBe(true);
+  network.change(OFFLINE);
+  network.change(OFFLINE);
+  expect(status.isOnline()).toBe(false);
+  network.change(ONLINE);
+  expect(listener.mock.calls).toEqual([[false], [true]]);
+});
+
+test('the first read of the phone network sets the state', async () => {
+  const status = createNetworkStatus({ network: createFakeNetwork({ state: OFFLINE }) });
+  const listener = jest.fn();
+  status.subscribe(listener);
+  expect(status.isOnline()).toBe(true);
+  await settle();
+  expect(status.isOnline()).toBe(false);
+  expect(listener).toHaveBeenCalledWith(false);
+});
+
+test('a change heard before the first read answers wins over that read', async () => {
+  const network = createFakeNetwork({ state: OFFLINE });
+  const status = createNetworkStatus({ network });
+  status.subscribe(() => undefined);
+  network.change(ONLINE);
+  network.getNetworkStateAsync = async () => OFFLINE;
+  await settle();
+  expect(status.isOnline()).toBe(true);
+});
+
+test('injected offline takes the shell offline while the phone is online, until it is lifted', async () => {
+  const status = createNetworkStatus({ network: createFakeNetwork() });
+  const listener = jest.fn();
+  status.subscribe(listener);
+  await settle();
+  status.setInjectedOffline(true);
+  expect(status.isOnline()).toBe(false);
+  status.setInjectedOffline(false);
+  expect(status.isOnline()).toBe(true);
+  expect(listener.mock.calls).toEqual([[false], [true]]);
+});
+
+test('lifting injected offline leaves the shell offline while the phone is offline', async () => {
+  const network = createFakeNetwork();
+  const status = createNetworkStatus({ network });
+  status.subscribe(() => undefined);
+  await settle();
+  status.setInjectedOffline(true);
+  network.change(OFFLINE);
+  status.setInjectedOffline(false);
+  expect(status.isOnline()).toBe(false);
+});
+
+test('the phone network is read only while something subscribes', async () => {
+  const network = createFakeNetwork();
+  const status = createNetworkStatus({ network });
+  expect(network.listening()).toBe(false);
+  const first = status.subscribe(() => undefined);
+  const second = status.subscribe(() => undefined);
+  expect(network.listening()).toBe(true);
+  first();
+  first();
+  expect(network.listening()).toBe(true);
+  second();
+  expect(network.listening()).toBe(false);
+});

package/src/host/createRouterAdapter.js

@@ -0,0 +1,33 @@
+/*
+  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 { router } from 'expo-router';
+
+import toRouterHref from '../navigation/toRouterHref.js';
+
+// The core's router contract (push, replace, back) on Expo Router.
+function createRouterAdapter({ session }) {
+  function href(target) {
+    return toRouterHref({ ...target, root: session.getState().root });
+  }
+  return {
+    push: (target) => router.push(href(target)),
+    replace: (target) => router.replace(href(target)),
+    back: () => router.back(),
+  };
+}
+
+export default createRouterAdapter;

package/src/host/createShellFetch.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.
+*/
+
+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.
+ * - A request sent with `keepBuild: true` (the offline queue's, stamped with the build it was
+ *   queued under) keeps its stamp, so a request from an older build gets the 409 and its check.
+ *
+ * @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, { keepBuild = false, ...init } = {}) {
+    const headers = { ...init.headers };
+    const stamped = headers[BUILD_HEADER] !== undefined;
+    if (stamped && !keepBuild) {
+      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;