@lowdefy/shell 3.23.3 → 7.2.0

package/src/sync/fetchPage.test.js

@@ -0,0 +1,84 @@
+/*
+  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 { LowdefyInternalError, RequestError, UserError } from '@lowdefy/errors';
+
+import fetchPage from './fetchPage.js';
+
+const apiBase = 'https://field.example.com';
+
+function answer({ status = 200, body, headers = {} }) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    headers: { get: (name) => headers[name] ?? null },
+    json: async () => body,
+  };
+}
+
+function fetchWith(res) {
+  return jest.fn(async () => res);
+}
+
+test('a page answer is returned with its build and etag', async () => {
+  const pageConfig = { id: 'jobs', _buildId: 'b1' };
+  const result = await fetchPage({
+    apiBase,
+    fetchWithAuth: fetchWith(answer({ body: { pageConfig }, headers: { etag: '"p1"' } })),
+    path: 'jobs',
+  });
+  expect(result).toEqual({ page: { buildId: 'b1', etag: '"p1"', pageConfig } });
+});
+
+test('lowdefy dev installing plugins is an expected outcome that names them, never a page', async () => {
+  const error = await fetchPage({
+    apiBase,
+    fetchWithAuth: fetchWith(answer({ body: { installing: true, packages: ['@acme/blocks'] } })),
+    path: 'jobs',
+  }).catch((caught) => caught);
+  expect(error).toBeInstanceOf(UserError);
+  expect(error.message).toBe(
+    'Lowdefy dev is installing @acme/blocks for "/jobs". Try again once the install finishes.'
+  );
+});
+
+test('an answer with no page config is a fault, never a page', async () => {
+  const error = await fetchPage({
+    apiBase,
+    fetchWithAuth: fetchWith(answer({ body: { pageId: 'jobs' } })),
+    path: 'jobs',
+  }).catch((caught) => caught);
+  expect(error).toBeInstanceOf(LowdefyInternalError);
+  expect(error.message).toBe(
+    'The app\'s server answered the page request for "/jobs" with no page config.'
+  );
+});
+
+test('a server error keeps its class and status', async () => {
+  const error = await fetchPage({
+    apiBase,
+    fetchWithAuth: fetchWith(
+      answer({
+        status: 500,
+        body: { '~e': { name: 'RequestError', message: 'Page failed.', isLowdefyError: true } },
+      })
+    ),
+    path: 'jobs',
+  }).catch((caught) => caught);
+  expect(error).toBeInstanceOf(RequestError);
+  expect(error.status).toBe(500);
+});

package/src/sync/fetchRoot.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 { parseCallerStamp } from '@lowdefy/helpers';
+
+import readServerError from '../host/readServerError.js';
+
+// GET /api/mobile/root, revalidated with the ETag of the root the shell holds. Returns
+// { notModified, root, etag, stamp }: on a 304 the held root is current and root is null. The
+// stamp is the caller the server answered as, whichever the status.
+async function fetchRoot({ apiBase, etag, fetchWithAuth }) {
+  const headers = etag ? { 'If-None-Match': etag } : {};
+  const res = await fetchWithAuth(`${apiBase}/api/mobile/root`, { method: 'GET', headers });
+  const stamp = parseCallerStamp(res.headers.get('x-lowdefy-caller'));
+  if (res.status === 304) {
+    return { notModified: true, root: null, etag, stamp };
+  }
+  if (res.status === 404) {
+    throw new Error('This app has no mobile pages.');
+  }
+  if (!res.ok) {
+    throw await readServerError({
+      res,
+      message: `The app's server answered ${res.status} to the mobile root request.`,
+    });
+  }
+  return { notModified: false, root: await res.json(), etag: res.headers.get('etag'), stamp };
+}
+
+export default fetchRoot;

package/src/sync/fetchUser.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 readServerError from '../host/readServerError.js';
+
+// GET /api/user: the caller the pages render (the _user operator, and the caller the core checks
+// each response's stamp against).
+async function fetchUser({ apiBase, fetchWithAuth }) {
+  const res = await fetchWithAuth(`${apiBase}/api/user`, { method: 'GET', headers: {} });
+  if (!res.ok) {
+    throw await readServerError({
+      res,
+      message: `The app's server answered ${res.status} to the user request.`,
+    });
+  }
+  const body = await res.json();
+  return body.user ?? null;
+}
+
+export default fetchUser;

package/src/sync/runLimited.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.
+*/
+
+// Runs fn over every item, at most `limit` at a time. Resolves once all have settled; a failed
+// item does not stop the others, and the failures are returned.
+async function runLimited({ items, limit, fn }) {
+  const queue = [...items];
+  const failures = [];
+  async function worker() {
+    while (queue.length > 0) {
+      const item = queue.shift();
+      try {
+        await fn(item);
+      } catch (error) {
+        failures.push({ item, error });
+      }
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, queue.length) }, () => worker()));
+  return failures;
+}
+
+export default runLimited;

package/src/sync/toRootConfig.js

@@ -0,0 +1,35 @@
+/*
+  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 root config @lowdefy/client-native renders pages with, from the mobile root. The web menus
+// (_menu) have no mobile counterpart; the mobile frame is the shell's. The theme
+// ({ darkMode, light, dark }) and the Tailwind class map style the blocks. A root cached from a
+// server built before they were served has no class map or i18n.
+function toRootConfig(root) {
+  return {
+    classMap: root.classMap ?? {},
+    events: root.events,
+    home: { configured: true, pageId: root.homePageId },
+    i18n: root.i18n ?? {},
+    lowdefyApp: root.lowdefyApp ?? {},
+    lowdefyGlobal: root.lowdefyGlobal ?? {},
+    menus: [],
+    pagePaths: Object.fromEntries(root.pageIndex.map((entry) => [entry.pageId, entry.path])),
+    theme: root.theme ?? {},
+  };
+}
+
+export default toRootConfig;

package/src/test/createFakeNetwork.js

@@ -0,0 +1,40 @@
+/*
+  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 ONLINE = { type: 'WIFI', isConnected: true, isInternetReachable: true };
+
+// expo-network as createNetworkStatus reads it, with the phone's network state set by the test.
+function createFakeNetwork({ state: initial = ONLINE } = {}) {
+  const listeners = new Set();
+  let state = initial;
+  return {
+    addNetworkStateListener(listener) {
+      listeners.add(listener);
+      return { remove: () => listeners.delete(listener) };
+    },
+    getNetworkStateAsync: async () => state,
+    // The phone's network changes, as expo-network reports it.
+    change(next) {
+      state = next;
+      listeners.forEach((listener) => listener(next));
+    },
+    listening: () => listeners.size > 0,
+  };
+}
+
+export const OFFLINE = { type: 'NONE', isConnected: false, isInternetReachable: false };
+export { ONLINE };
+export default createFakeNetwork;

package/src/test/createFakeSecureStore.js

@@ -0,0 +1,40 @@
+/*
+  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';
+
+// expo-secure-store over a Map, keyed as the native module keys items: by key and by whether the
+// item is behind biometrics (a protected item is a different Keychain service on iOS).
+function createFakeSecureStore() {
+  const items = new Map();
+  function itemKey(key, options = {}) {
+    return `${key}|${options.requireAuthentication === true ? 'auth' : 'no-auth'}`;
+  }
+  return {
+    items,
+    AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY: 'AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY',
+    WHEN_UNLOCKED_THIS_DEVICE_ONLY: 'WHEN_UNLOCKED_THIS_DEVICE_ONLY',
+    getItemAsync: jest.fn(async (key, options) => items.get(itemKey(key, options))?.value ?? null),
+    setItemAsync: jest.fn(async (key, value, options) => {
+      items.set(itemKey(key, options), { value, options });
+    }),
+    deleteItemAsync: jest.fn(async (key, options) => {
+      items.delete(itemKey(key, options));
+    }),
+  };
+}
+
+export default createFakeSecureStore;

package/src/test/createFakeServer.js

@@ -0,0 +1,98 @@
+/*
+  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';
+
+function createResponse({ body = null, headers = {}, status = 200 }) {
+  const lowerHeaders = Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value])
+  );
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    headers: { get: (name) => lowerHeaders[name.toLowerCase()] ?? null },
+    json: async () => structuredClone(body),
+  };
+}
+
+function header(init, name) {
+  const entry = Object.entries(init?.headers ?? {}).find(
+    ([key]) => key.toLowerCase() === name.toLowerCase()
+  );
+  return entry?.[1] ?? null;
+}
+
+/**
+ * A Lowdefy server for the shell's tests. `state` holds what it serves and may be changed between
+ * calls: `caller` (the x-lowdefy-caller stamp), `user`, `root` and its `rootEtag`, `pages`
+ * ({ [path]: { pageConfig, etag } }), `buildId`, `requests` (a function answering
+ * /api/request/* calls) and `auth` (a function of { path, init } answering /api/auth/* calls with
+ * { body, headers, status }). A matching If-None-Match gets a 304. Every call is in `fetch.mock.calls`.
+ */
+function createFakeServer(initial) {
+  const state = { buildId: 'build-1', caller: '', user: null, ...initial };
+  const fetch = jest.fn(async (url, init) => {
+    const { pathname } = new URL(url);
+    const callerHeaders = { 'x-lowdefy-caller': state.caller };
+    if (pathname === '/api/mobile/root') {
+      if (header(init, 'if-none-match') === state.rootEtag) {
+        return createResponse({ status: 304, headers: { ...callerHeaders, etag: state.rootEtag } });
+      }
+      return createResponse({
+        body: state.root,
+        headers: { ...callerHeaders, etag: state.rootEtag },
+      });
+    }
+    if (pathname === '/api/user') {
+      return createResponse({ body: { user: state.user } });
+    }
+    if (pathname.startsWith('/api/page/')) {
+      const path = decodeURIComponent(pathname.slice('/api/page/'.length));
+      const page = state.pages[path];
+      if (page === undefined) {
+        return createResponse({
+          status: 404,
+          body: state.otherSurfaces?.[path] ?? { pageConfig: null },
+        });
+      }
+      if (header(init, 'if-none-match') === page.etag) {
+        return createResponse({ status: 304, headers: { ...callerHeaders, etag: page.etag } });
+      }
+      return createResponse({
+        body: { buildId: state.buildId, pageConfig: page.pageConfig },
+        headers: { ...callerHeaders, etag: page.etag },
+      });
+    }
+    if (pathname.startsWith('/api/request/')) {
+      const build = header(init, 'x-lowdefy-build');
+      if (build !== null && build !== state.buildId) {
+        return createResponse({
+          status: 409,
+          body: { name: 'UserError', message: 'Other build.', buildId: state.buildId },
+        });
+      }
+      return createResponse({ body: state.requests?.(url, init) ?? { success: true } });
+    }
+    if (pathname.startsWith('/api/auth/') && state.auth !== undefined) {
+      return createResponse(state.auth({ path: pathname.slice('/api/auth'.length), init }));
+    }
+    return createResponse({ status: 404, body: {} });
+  });
+  return { fetch, state };
+}
+
+export { header };
+export default createFakeServer;

package/src/test/createMemoryCacheStore.js

@@ -0,0 +1,59 @@
+/*
+  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 page cache held in memory, with the same methods as createSqliteCacheStore.
+function createMemoryCacheStore() {
+  const roots = new Map();
+  const pages = new Map();
+  function pagesOf(cacheKey) {
+    if (!pages.has(cacheKey)) pages.set(cacheKey, new Map());
+    return pages.get(cacheKey);
+  }
+  return {
+    roots,
+    pages,
+    async read(cacheKey) {
+      if (!roots.has(cacheKey)) return null;
+      return {
+        ...structuredClone(roots.get(cacheKey)),
+        pages: Object.fromEntries(structuredClone([...pagesOf(cacheKey).entries()])),
+      };
+    },
+    async writeRoot({ cacheKey, entry }) {
+      roots.set(cacheKey, structuredClone(entry));
+    },
+    async writePage({ cacheKey, pageId, page }) {
+      pagesOf(cacheKey).set(pageId, structuredClone(page));
+    },
+    async removeEntry({ cacheKey }) {
+      roots.delete(cacheKey);
+      pages.delete(cacheKey);
+    },
+    async removeApp({ appId }) {
+      [...roots.keys(), ...pages.keys()]
+        .filter((cacheKey) => cacheKey.startsWith(`${appId}:`))
+        .forEach((cacheKey) => {
+          roots.delete(cacheKey);
+          pages.delete(cacheKey);
+        });
+    },
+    async removePages({ cacheKey, pageIds }) {
+      pageIds.forEach((pageId) => pagesOf(cacheKey).delete(pageId));
+    },
+  };
+}
+
+export default createMemoryCacheStore;

package/src/test/createNetworkError.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.
+*/
+
+// A call that never reached the server, as the shell's fetch rejects with it (withNetworkErrors).
+function createNetworkError() {
+  const error = new TypeError('Network request failed');
+  error.isNetworkError = true;
+  return error;
+}
+
+export default createNetworkError;

package/src/test/expoImage.js

@@ -0,0 +1,42 @@
+/*
+  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 React from 'react';
+import { View } from 'react-native';
+
+// A stand-in for expo-image's Image, whose view needs a native module Jest does not have. It keeps
+// its props, so a test reads the source and fires the load and error events:
+// fireEvent(image, 'load', { cacheType: 'none' }) or fireEvent(image, 'error', { error: '' }).
+function Image({ cachePolicy, contentFit, onError, onLoad, recyclingKey, source, style, testID }) {
+  return (
+    <View
+      cachePolicy={cachePolicy}
+      contentFit={contentFit}
+      onError={onError}
+      onLoad={onLoad}
+      recyclingKey={recyclingKey}
+      source={source}
+      style={style}
+      testID={testID ?? 'expo-image'}
+    />
+  );
+}
+
+// The caches sign-out clears; a test spies on them.
+Image.clearMemoryCache = async () => true;
+Image.clearDiskCache = async () => true;
+
+export { Image };

package/src/test/expoNotifications.js

@@ -0,0 +1,40 @@
+/*
+  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 stand-in for expo-notifications: nothing is delivered, no response launched the app, and
+// permission is not granted, so no push token is registered in tests.
+const subscription = () => ({ remove: () => undefined });
+
+module.exports = {
+  DEFAULT_ACTION_IDENTIFIER: 'expo.modules.notifications.actions.DEFAULT',
+  SchedulableTriggerInputTypes: { DATE: 'date', TIME_INTERVAL: 'timeInterval' },
+  addNotificationReceivedListener: subscription,
+  addNotificationResponseReceivedListener: subscription,
+  addPushTokenListener: subscription,
+  cancelAllScheduledNotificationsAsync: async () => undefined,
+  cancelScheduledNotificationAsync: async () => undefined,
+  clearLastNotificationResponse: () => undefined,
+  dismissNotificationAsync: async () => undefined,
+  getDevicePushTokenAsync: async () => ({ data: 'device-token' }),
+  getExpoPushTokenAsync: async () => ({ data: 'ExponentPushToken[test]' }),
+  getLastNotificationResponse: () => null,
+  getPermissionsAsync: async () => ({ granted: false, status: 'undetermined' }),
+  requestPermissionsAsync: async () => ({ granted: false, status: 'denied' }),
+  scheduleNotificationAsync: async (request) => request.identifier ?? 'notification-id',
+  setBadgeCountAsync: async () => true,
+  setNotificationCategoryAsync: async () => null,
+  setNotificationHandler: () => undefined,
+};

package/src/test/expoQuickActions.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.
+*/
+
+// A stand-in for expo-quick-actions: no quick action launched the app.
+module.exports = {
+  initial: undefined,
+  setItems: async () => undefined,
+  addListener: () => ({ remove: () => undefined }),
+};

package/src/test/expoSpeechRecognition.js

@@ -0,0 +1,31 @@
+/*
+  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 stand-in for expo-speech-recognition, whose recogniser is a native module Jest does not have.
+// The native blocks' dictation hook asks it whether the phone can recognise speech; here it
+// cannot, so screens render without a mic. blocks-native's own tests drive a fuller stand-in.
+const ExpoSpeechRecognitionModule = {
+  abort: () => {},
+  addListener: () => ({ remove: () => {} }),
+  getSupportedLocales: async () => ({ locales: [], installedLocales: [] }),
+  isRecognitionAvailable: () => false,
+  requestPermissionsAsync: async () => ({ granted: false, status: 'denied' }),
+  start: () => {},
+  stop: () => {},
+  supportsOnDeviceRecognition: () => false,
+};
+
+export { ExpoSpeechRecognitionModule };

package/src/test/expoTaskManager.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.
+*/
+
+// A stand-in for expo-task-manager and expo-background-task: tasks are defined and registered on
+// nothing.
+module.exports = {
+  BackgroundTaskResult: { Success: 1, Failed: 2 },
+  defineTask: () => undefined,
+  isTaskRegisteredAsync: async () => false,
+  registerTaskAsync: async () => undefined,
+  unregisterTaskAsync: async () => undefined,
+};