@ankhorage/expo-runtime 2.5.1 → 2.7.0

package/src/generatedAppOutput.test.ts

@@ -6,6 +6,7 @@ import {
   resolveExpoRuntimeGeneratedAppOutput,
   resolveExpoRuntimeNativeOutput,
 } from './generatedAppOutput';
+import { EXPO_PLATFORM } from './platform';
 import type { ExpoRuntimePlan } from './resolveExpoRuntimePlan';
 
 const EMPTY_PLAN: ExpoRuntimePlan = {
@@ -32,7 +33,7 @@ const CAMERA_PLAN: ExpoRuntimePlan = {
   dependencies: [
     {
       name: 'expo-camera',
-      version: '~17.0.10',
+      version: EXPO_PLATFORM.packages.camera.version,
       reasons: ['capability:barcodeScanner'],
     },
     {
@@ -42,13 +43,16 @@ const CAMERA_PLAN: ExpoRuntimePlan = {
     },
   ],
   nativeConfig: {
-    androidPermissions: ['android.permission.CAMERA'],
+    androidPermissions: [],
     configHints: ['cameraPermission'],
     plugins: [
       {
         name: 'expo-camera',
         options: {
           cameraPermission: 'Allow camera access to scan barcodes.',
+          barcodeScannerEnabled: true,
+          microphonePermission: false,
+          recordAudioAndroid: false,
         },
       },
       {
@@ -62,10 +66,18 @@ const CAMERA_PLAN: ExpoRuntimePlan = {
   needsPermissionsProvider: true,
 };
 
-describe('generatedAppOutput', () => {
+describe('generated App config output', () => {
   test('keeps Expo config plugins as a distinct external ecosystem concept', () => {
     expect(resolveExpoRuntimeConfigPluginOutput(CAMERA_PLAN)).toEqual([
-      ['expo-camera', { cameraPermission: 'Allow camera access to scan barcodes.' }],
+      [
+        'expo-camera',
+        {
+          barcodeScannerEnabled: true,
+          cameraPermission: 'Allow camera access to scan barcodes.',
+          microphonePermission: false,
+          recordAudioAndroid: false,
+        },
+      ],
       'expo-something',
     ]);
   });
@@ -78,11 +90,13 @@ describe('generatedAppOutput', () => {
       configPlugins: [],
     });
   });
+});
 
+describe('generated App dependency output', () => {
   test('maps runtime dependencies into a package dependency map', () => {
     expect(resolveExpoRuntimeDependencyMap(CAMERA_PLAN)).toEqual({
       '@ankhorage/expo-runtime': '^0.0.7',
-      'expo-camera': '~17.0.10',
+      'expo-camera': EXPO_PLATFORM.packages.camera.version,
     });
   });
 
@@ -91,18 +105,23 @@ describe('generatedAppOutput', () => {
       [
         'expo-camera',
         {
+          barcodeScannerEnabled: true,
           cameraPermission: 'Allow camera access to scan barcodes.',
+          microphonePermission: false,
+          recordAudioAndroid: false,
         },
       ],
       'expo-something',
     ]);
   });
+});
 
+describe('combined generated App output', () => {
   test('combines dependency, native and layout output', () => {
     expect(resolveExpoRuntimeGeneratedAppOutput(CAMERA_PLAN)).toEqual({
       dependencies: {
         '@ankhorage/expo-runtime': '^0.0.7',
-        'expo-camera': '~17.0.10',
+        'expo-camera': EXPO_PLATFORM.packages.camera.version,
       },
       layoutIntegration: {
         imports: ["import { ExpoRuntimeProviders } from '@ankhorage/expo-runtime';"],
@@ -111,12 +130,15 @@ describe('generatedAppOutput', () => {
         providerEnd: ['</ExpoRuntimeProviders>'],
       },
       native: {
-        androidPermissions: ['android.permission.CAMERA'],
+        androidPermissions: [],
         configPlugins: [
           [
             'expo-camera',
             {
+              barcodeScannerEnabled: true,
               cameraPermission: 'Allow camera access to scan barcodes.',
+              microphonePermission: false,
+              recordAudioAndroid: false,
             },
           ],
           'expo-something',

package/src/mediaPicker/documentPicker.ts

@@ -5,18 +5,13 @@ import {
   isRequestedMediaKind,
   resolveDocumentPickerMimeTypes,
 } from './mediaKinds';
-import {
-  type ArrayBufferReadable,
-  readSelectedMediaBytes,
-  type SelectedMediaByteSource,
-} from './readSelectedBytes';
+import { readSelectedMediaBytes, type SelectedMediaByteSource } from './readSelectedBytes';
 import type { ExpoMediaPickerInput, ExpoMediaPickerResult } from './types';
 
 interface DocumentPickerAssetLike extends SelectedMediaByteSource {
   readonly name: string;
   readonly mimeType?: string;
   readonly size?: number;
-  readonly file?: ArrayBufferReadable;
 }
 
 interface DocumentPickerResultLike {

package/src/mediaPicker/photoLibraryPicker.ts

@@ -1,11 +1,7 @@
 import type { MediaAssetKind } from '@ankhorage/contracts';
 
 import { isRequestedMediaKind } from './mediaKinds';
-import {
-  type ArrayBufferReadable,
-  readSelectedMediaBytes,
-  type SelectedMediaByteSource,
-} from './readSelectedBytes';
+import { readSelectedMediaBytes, type SelectedMediaByteSource } from './readSelectedBytes';
 import type { ExpoMediaPickerInput, ExpoMediaPickerResult } from './types';
 
 export type ExpoPhotoLibraryMediaType = 'images' | 'videos';
@@ -18,7 +14,6 @@ interface PhotoLibraryAssetLike extends SelectedMediaByteSource {
   readonly height: number;
   readonly duration?: number | null;
   readonly type?: 'image' | 'video' | 'livePhoto' | 'pairedVideo' | null;
-  readonly file?: ArrayBufferReadable;
 }
 
 interface PhotoLibraryResultLike {

package/src/mediaPicker/readSelectedBytes.ts

@@ -1,17 +1,17 @@
-export interface ArrayBufferReadable {
+interface ArrayBufferReadable {
   arrayBuffer(): Promise<ArrayBuffer>;
 }
 
 export interface SelectedMediaByteSource {
   readonly uri: string;
-  readonly file?: ArrayBufferReadable;
+  readonly file?: unknown;
 }
 
 export async function readSelectedMediaBytes(
   source: SelectedMediaByteSource,
 ): Promise<Uint8Array | null> {
   try {
-    if (source.file) {
+    if (isArrayBufferReadable(source.file)) {
       return new Uint8Array(await source.file.arrayBuffer());
     }
     const { File } = await import('expo-file-system');
@@ -20,3 +20,12 @@ export async function readSelectedMediaBytes(
     return null;
   }
 }
+
+function isArrayBufferReadable(value: unknown): value is ArrayBufferReadable {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'arrayBuffer' in value &&
+    typeof value.arrayBuffer === 'function'
+  );
+}

package/src/oauthBrowserRuntime.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from 'bun:test';
 import { resolveExpoOAuthBrowserRuntimeReadinessFromEnvironment } from './oauthBrowserRuntimeCore';
 
 describe('Expo OAuth browser runtime readiness', () => {
-  test('allows an SDK 54 custom native build with an embedded Expo config', () => {
+  test('allows a custom native build with an embedded Expo config', () => {
     expect(
       resolveExpoOAuthBrowserRuntimeReadinessFromEnvironment({
         appOwnership: null,

package/src/planning.ts

@@ -21,6 +21,8 @@ export {
 export type {
   ExpoRuntimeAdapterId,
   ExpoRuntimePlan,
+  ExpoRuntimePlanningManifest,
+  ExpoRuntimePlanningScreen,
   ExpoRuntimeProviderId,
 } from './resolveExpoRuntimePlan';
 export { resolveExpoRuntimePlan } from './resolveExpoRuntimePlan';

package/src/platform.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from 'bun:test';
+
+import { EXPO_PLATFORM } from './platform';
+
+describe('EXPO_PLATFORM', () => {
+  test('represents the supported Expo 57 native platform without a tvOS claim', () => {
+    expect(EXPO_PLATFORM.sdk).toBe(57);
+    expect(EXPO_PLATFORM.architecture).toBe('new-architecture-only');
+    expect(EXPO_PLATFORM.platforms).toEqual({
+      android: {
+        minimumVersion: 7,
+        minimumApiLevel: 24,
+        compileSdk: 36,
+        targetSdk: 36,
+        edgeToEdge: true,
+      },
+      ios: {
+        minimumVersion: '16.4',
+        minimumXcodeVersion: '26.4',
+      },
+    });
+    expect('tvos' in EXPO_PLATFORM.platforms).toBe(false);
+  });
+
+  test('keeps the Hermes fix, React Native and Node policy in one contract', () => {
+    expect(EXPO_PLATFORM.runtime.expo).toEqual({ name: 'expo', version: '~57.0.15' });
+    expect(EXPO_PLATFORM.runtime.reactNative).toEqual({
+      name: 'react-native',
+      version: '0.86.2',
+    });
+    expect(EXPO_PLATFORM.tooling.node).toEqual({ lts: 24, version: '24.x' });
+    expect(EXPO_PLATFORM.animation.worklets.version).toBe('0.10.1');
+  });
+});

package/src/platform.ts

@@ -0,0 +1,88 @@
+export interface ExpoPlatformPackage {
+  readonly name: string;
+  readonly version: string;
+}
+
+function definePackage(name: string, version: string): ExpoPlatformPackage {
+  return { name, version };
+}
+
+/**
+ * The canonical Ankhorage projection of the supported Expo platform.
+ *
+ * Package versions come from Expo SDK 57's bundled native module map. Keep this
+ * structure as the only hand-maintained Expo compatibility authority in this
+ * repository; generated manifests and runtime planning derive from it.
+ */
+export const EXPO_PLATFORM = {
+  sdk: 57,
+  architecture: 'new-architecture-only',
+  runtime: {
+    expo: definePackage('expo', '~57.0.15'),
+    react: definePackage('react', '19.2.3'),
+    reactDom: definePackage('react-dom', '19.2.3'),
+    reactNative: definePackage('react-native', '0.86.2'),
+    reactNativeWeb: definePackage('react-native-web', '~0.21.0'),
+  },
+  tooling: {
+    node: {
+      lts: 24,
+      version: '24.x',
+    },
+    nodeTypes: definePackage('@types/node', '^24.13.3'),
+    typescript: definePackage('typescript', '~6.0.3'),
+    expoDoctor: definePackage('expo-doctor', '1.20.2'),
+  },
+  navigation: {
+    expoRouter: definePackage('expo-router', '~57.0.15'),
+    screens: definePackage('react-native-screens', '~4.26.0'),
+    safeArea: definePackage('react-native-safe-area-context', '~5.7.0'),
+  },
+  animation: {
+    reanimated: definePackage('react-native-reanimated', '4.5.1'),
+    worklets: definePackage('react-native-worklets', '0.10.1'),
+    gestureHandler: definePackage('react-native-gesture-handler', '~2.32.0'),
+  },
+  ui: {
+    svg: definePackage('react-native-svg', '15.15.4'),
+  },
+  packages: {
+    metroRuntime: definePackage('@expo/metro-runtime', '~57.0.12'),
+    asset: definePackage('expo-asset', '~57.0.13'),
+    audio: definePackage('expo-audio', '~57.0.4'),
+    authSession: definePackage('expo-auth-session', '~57.0.8'),
+    camera: definePackage('expo-camera', '~57.0.4'),
+    constants: definePackage('expo-constants', '~57.0.13'),
+    devClient: definePackage('expo-dev-client', '~57.0.14'),
+    documentPicker: definePackage('expo-document-picker', '~57.0.1'),
+    fileSystem: definePackage('expo-file-system', '~57.0.5'),
+    font: definePackage('expo-font', '~57.0.1'),
+    imagePicker: definePackage('expo-image-picker', '~57.0.12'),
+    linearGradient: definePackage('expo-linear-gradient', '~57.0.1'),
+    linking: definePackage('expo-linking', '~57.0.7'),
+    localization: definePackage('expo-localization', '~57.0.1'),
+    location: definePackage('expo-location', '~57.0.12'),
+    mediaLibrary: definePackage('expo-media-library', '~57.0.4'),
+    notifications: definePackage('expo-notifications', '~57.0.13'),
+    secureStore: definePackage('expo-secure-store', '~57.0.1'),
+    splashScreen: definePackage('expo-splash-screen', '~57.0.7'),
+    statusBar: definePackage('expo-status-bar', '~57.0.1'),
+    updates: definePackage('expo-updates', '~57.0.16'),
+    webBrowser: definePackage('expo-web-browser', '~57.0.2'),
+  },
+  platforms: {
+    android: {
+      minimumVersion: 7,
+      minimumApiLevel: 24,
+      compileSdk: 36,
+      targetSdk: 36,
+      edgeToEdge: true,
+    },
+    ios: {
+      minimumVersion: '16.4',
+      minimumXcodeVersion: '26.4',
+    },
+  },
+} as const;
+
+export type ExpoPlatform = typeof EXPO_PLATFORM;

package/src/resolveExpoRuntimePlan.test.ts

@@ -1,16 +1,26 @@
-import type { AppManifest } from '@ankhorage/contracts';
 import { Permission } from '@ankhorage/permissions';
 import { EXPO_PERMISSION_SUPPORT } from '@ankhorage/permissions/expo/manifest';
 import { describe, expect, test } from 'bun:test';
 
-import { resolveExpoRuntimePlan } from './resolveExpoRuntimePlan';
+import { EXPO_PLATFORM } from './platform';
+import { type ExpoRuntimePlanningManifest, resolveExpoRuntimePlan } from './resolveExpoRuntimePlan';
+
+describe('resolveExpoRuntimePlan permissions', () => {
+  test('accepts a minimal screens-only planning manifest', () => {
+    const manifest: ExpoRuntimePlanningManifest = {
+      screens: {
+        home: {
+          requires: { permissions: [{ permission: 'camera' }] },
+        },
+      },
+    };
+
+    expect(resolveExpoRuntimePlan(manifest).permissions).toEqual([{ permission: 'camera' }]);
+  });
 
-describe('resolveExpoRuntimePlan', () => {
   test('resolves camera permission through Expo permission metadata', () => {
     const plan = resolveExpoRuntimePlan(
-      withFirstScreenRequirements({
-        permissions: [{ permission: 'camera' }],
-      }),
+      withFirstScreenRequirements({ permissions: [{ permission: 'camera' }] }),
     );
 
     expect(plan.dependencies.map((dependency) => dependency.name)).toEqual([
@@ -21,22 +31,28 @@ describe('resolveExpoRuntimePlan', () => {
     expect(plan.providers).toEqual(['permissions']);
     expect(plan.needsPermissionsProvider).toBe(true);
     expect(plan.nativeConfig.configHints).toEqual(['cameraPermission']);
-    expect(plan.nativeConfig.androidPermissions).toEqual(['android.permission.CAMERA']);
+    expect(plan.nativeConfig.androidPermissions).toEqual([]);
     expect(plan.nativeConfig.plugins).toEqual([
       {
         name: 'expo-camera',
         options: {
+          barcodeScannerEnabled: false,
           cameraPermission: 'Allow camera access.',
+          microphonePermission: false,
+          recordAudioAndroid: false,
         },
       },
     ]);
+    expect(plan.dependencies.find(({ name }) => name === 'expo-camera')?.version).toBe(
+      EXPO_PLATFORM.packages.camera.version,
+    );
   });
+});
 
+describe('resolveExpoRuntimePlan barcode capability', () => {
   test('resolves barcodeScanner capability with implied camera permission and adapter wiring', () => {
     const plan = resolveExpoRuntimePlan(
-      withFirstScreenRequirements({
-        capabilities: [{ capability: 'barcodeScanner' }],
-      }),
+      withFirstScreenRequirements({ capabilities: [{ capability: 'barcodeScanner' }] }),
     );
 
     expect(plan.impliedPermissions).toEqual([{ permission: 'camera' }]);
@@ -51,12 +67,78 @@ describe('resolveExpoRuntimePlan', () => {
       {
         name: 'expo-camera',
         options: {
+          barcodeScannerEnabled: true,
           cameraPermission: 'Allow camera access to scan barcodes.',
+          microphonePermission: false,
+          recordAudioAndroid: false,
         },
       },
     ]);
   });
 
+  test('lets barcodeScanner capability override camera-only scanner disabling', () => {
+    const plan = resolveExpoRuntimePlan(
+      withFirstScreenRequirements({
+        capabilities: [{ capability: 'barcodeScanner' }],
+        permissions: [{ permission: 'camera' }],
+      }),
+    );
+
+    expect(plan.nativeConfig.plugins).toContainEqual({
+      name: 'expo-camera',
+      options: {
+        barcodeScannerEnabled: true,
+        cameraPermission: 'Allow camera access to scan barcodes.',
+        microphonePermission: false,
+        recordAudioAndroid: false,
+      },
+    });
+  });
+});
+
+describe('resolveExpoRuntimePlan Expo 57 plugin coverage', () => {
+  test('keeps microphone-only native configuration free of background audio behavior', () => {
+    const plan = resolveExpoRuntimePlan(
+      withFirstScreenRequirements({ permissions: [{ permission: 'microphone' }] }),
+    );
+
+    expect(plan.nativeConfig.plugins).toEqual([
+      {
+        name: 'expo-audio',
+        options: {
+          enableBackgroundPlayback: false,
+          enableBackgroundRecording: false,
+          microphonePermission: 'Allow microphone access.',
+          recordAudioAndroid: true,
+        },
+      },
+    ]);
+  });
+
+  test('translates every supported permission into current Expo 57 packages and plugins', () => {
+    const plan = resolveExpoRuntimePlan(
+      withFirstScreenRequirements({
+        permissions: [
+          { permission: 'microphone' },
+          { permission: 'mediaLibrary' },
+          { permission: 'mediaLibraryWrite' },
+          { permission: 'locationForeground' },
+          { permission: 'locationBackground' },
+          { permission: 'notifications' },
+        ],
+      }),
+    );
+
+    expect(plan.diagnostics).toEqual([]);
+    expect(plan.dependencies.map(({ name, version }) => ({ name, version }))).toEqual(
+      SUPPORTED_PERMISSION_DEPENDENCIES,
+    );
+    expect(plan.nativeConfig.androidPermissions).toEqual([]);
+    expect(plan.nativeConfig.plugins).toEqual(SUPPORTED_PERMISSION_PLUGINS);
+  });
+});
+
+describe('resolveExpoRuntimePlan diagnostics and deduplication', () => {
   test('dedupes repeated permission and capability requirements', () => {
     const plan = resolveExpoRuntimePlan(
       withAllScreenRequirements({
@@ -76,9 +158,7 @@ describe('resolveExpoRuntimePlan', () => {
 
   test('surfaces unsupported permission support explicitly', () => {
     const plan = resolveExpoRuntimePlan(
-      withFirstScreenRequirements({
-        permissions: [{ permission: 'camera' }],
-      }),
+      withFirstScreenRequirements({ permissions: [{ permission: 'camera' }] }),
       {
         permissionSupport: {
           ...EXPO_PERMISSION_SUPPORT,
@@ -100,12 +180,12 @@ describe('resolveExpoRuntimePlan', () => {
     expect(plan.dependencies).toEqual([]);
     expect(plan.providers).toEqual([]);
   });
+});
 
+describe('resolveExpoRuntimePlan platform-neutral permissions', () => {
   test('does not add runtime packages or providers for clipboard permissions', () => {
     const plan = resolveExpoRuntimePlan(
-      withFirstScreenRequirements({
-        permissions: [{ permission: 'clipboard' }],
-      }),
+      withFirstScreenRequirements({ permissions: [{ permission: 'clipboard' }] }),
     );
 
     expect(plan.dependencies).toEqual([]);
@@ -114,99 +194,72 @@ describe('resolveExpoRuntimePlan', () => {
   });
 });
 
-function withAllScreenRequirements(requirements: TestScreenRequirements): AppManifest {
+const SUPPORTED_PERMISSION_DEPENDENCIES = [
+  { name: '@ankhorage/expo-runtime', version: '^2.7.0' },
+  { name: '@ankhorage/permissions', version: '^0.2.2' },
+  { name: 'expo-audio', version: EXPO_PLATFORM.packages.audio.version },
+  { name: 'expo-location', version: EXPO_PLATFORM.packages.location.version },
+  { name: 'expo-media-library', version: EXPO_PLATFORM.packages.mediaLibrary.version },
+  { name: 'expo-notifications', version: EXPO_PLATFORM.packages.notifications.version },
+];
+
+const SUPPORTED_PERMISSION_PLUGINS = [
+  {
+    name: 'expo-audio',
+    options: {
+      enableBackgroundPlayback: false,
+      enableBackgroundRecording: false,
+      microphonePermission: 'Allow microphone access.',
+      recordAudioAndroid: true,
+    },
+  },
+  {
+    name: 'expo-location',
+    options: {
+      isAndroidBackgroundLocationEnabled: true,
+      isAndroidForegroundServiceEnabled: true,
+      isIosBackgroundLocationEnabled: true,
+      locationAlwaysAndWhenInUsePermission: 'Allow location access.',
+      locationWhenInUsePermission: 'Allow location access while using the app.',
+    },
+  },
+  {
+    name: 'expo-media-library',
+    options: {
+      photosPermission: 'Allow photo library access.',
+      savePhotosPermission: 'Allow saving to the photo library.',
+    },
+  },
+  { name: 'expo-notifications' },
+];
+
+interface TestScreenRequirements {
+  readonly capabilities?: NonNullable<
+    ExpoRuntimePlanningManifest['screens'][string]['requires']
+  >['capabilities'];
+  readonly permissions?: NonNullable<
+    ExpoRuntimePlanningManifest['screens'][string]['requires']
+  >['permissions'];
+}
+
+function withFirstScreenRequirements(
+  requirements: TestScreenRequirements,
+): ExpoRuntimePlanningManifest {
   return {
-    ...BASE_MANIFEST,
     screens: {
-      home: {
-        ...BASE_MANIFEST.screens.home,
-        requires: requirements,
-      },
-      settings: {
-        ...BASE_MANIFEST.screens.settings,
-        requires: requirements,
-      },
+      home: { requires: requirements },
+      settings: {},
     },
   };
 }
 
-function withFirstScreenRequirements(requirements: TestScreenRequirements): AppManifest {
+function withAllScreenRequirements(
+  requirements: TestScreenRequirements,
+): ExpoRuntimePlanningManifest {
   return {
-    ...BASE_MANIFEST,
     screens: {
-      ...BASE_MANIFEST.screens,
-      home: {
-        ...BASE_MANIFEST.screens.home,
-        requires: requirements,
-      },
+      home: { requires: requirements },
+      settings: { requires: requirements },
     },
   };
 }
-
-interface TestScreenRequirements {
-  readonly capabilities?: readonly [{ readonly capability: 'barcodeScanner' }];
-  readonly permissions?: readonly [{ readonly permission: 'camera' | 'clipboard' }];
-}
-
-const BASE_MANIFEST = {
-  metadata: {
-    name: 'Test App',
-    slug: 'test-app',
-    version: '1.0.0',
-    themeId: 'default',
-    created: '2026-06-10T00:00:00.000Z',
-    updated: '2026-06-10T00:00:00.000Z',
-  },
-  navigator: {
-    type: 'stack',
-    routes: [
-      { name: 'index', screenId: 'home' },
-      { name: 'settings', screenId: 'settings' },
-    ],
-  },
-  screens: {
-    home: {
-      id: 'home',
-      name: 'Home',
-      title: 'Home',
-      root: { id: 'home-root', type: 'Screen' },
-    },
-    settings: {
-      id: 'settings',
-      name: 'Settings',
-      title: 'Settings',
-      root: { id: 'settings-root', type: 'Screen' },
-    },
-  },
-  themes: [
-    {
-      id: 'default',
-      name: 'Default',
-      light: {
-        primaryColor: '#0f172a',
-        harmony: 'analogous',
-      },
-      dark: {
-        primaryColor: '#0f172a',
-        harmony: 'analogous',
-      },
-    },
-  ],
-  activeThemeId: 'default',
-  activeThemeMode: 'light',
-  infra: {
-    modules: [],
-  },
-  settings: {
-    localization: {
-      defaultLocale: 'en',
-      locales: ['en'],
-    },
-    authFlow: {
-      signInRoute: '',
-      signUpRoute: '/sign-up',
-      signOutRoute: '/sign-out',
-      postSignInRoute: '/',
-    },
-  },
-} satisfies AppManifest;