@oxyhq/bloom 0.50.2 → 0.51.1

package/src/__tests__/TabBarGlassFallback.test.tsx

@@ -0,0 +1,234 @@
+import React from 'react';
+import type { ReactTestInstance } from 'react-test-renderer';
+import { render } from '@testing-library/react-native';
+
+import type { TabBarSurfaceProps } from '../tab-bar/shared';
+import type { TabBarTheme } from '../tab-bar/types';
+
+/**
+ * The native capsule surface must DEGRADE, never crash, when `expo-glass-effect`
+ * is not really usable.
+ *
+ * This is the one thing the rest of the tab-bar suite structurally cannot see.
+ * `TabBar.test.tsx` renders the native surface against the manual mock in
+ * `__mocks__/expo-glass-effect.ts`, which is a HEALTHY install reporting
+ * `isLiquidGlassAvailable() === false` — so it only ever exercises the branch a
+ * correctly-packaged Android device takes. Every failure mode below is a
+ * different install: the module resolved but handed back no exports, or the JS
+ * package is there while the native module is not.
+ *
+ * Each case is re-mocked into its own module registry because both hazards live at
+ * MODULE scope. `Animated.createAnimatedComponent(GlassView)` runs on import, and
+ * on iOS `isLiquidGlassAvailable()` reaches a native module through
+ * `requireNativeModule`, which throws by contract when it is absent. Mocking after
+ * the module under test was imported would test a render branch and miss both.
+ *
+ * The two counter-tests at the end are what keep the rest honest: a guard that
+ * always fell through to the solid surface would satisfy every other assertion
+ * here while silently deleting the glass look on every iOS 26 device.
+ */
+
+/** Every export may be absent — that is the whole point of these fixtures. */
+interface GlassEffectModule {
+  GlassView?: unknown;
+  isLiquidGlassAvailable?: () => boolean;
+  isGlassEffectAPIAvailable?: () => boolean;
+}
+
+/**
+ * A host tag stands in for the real `GlassView` component: under the reanimated
+ * mock `createAnimatedComponent` is the identity, so whatever the package exports
+ * IS the element type, and a string host is the cheapest valid one to assert on.
+ * It matches the tag the manual mock renders.
+ */
+const GLASS_HOST = 'GlassView';
+
+const THEME: TabBarTheme = {
+  activeTint: 'rgb(20 20 20)',
+  inactiveTint: 'rgb(120 120 120)',
+  highlight: 'rgb(230 230 230)',
+  glassTint: 'rgba(255, 255, 255, 0.55)',
+  solidFallback: 'rgb(246 246 246)',
+};
+
+const STYLE = { borderRadius: 29 };
+
+function flattenStyle(style: unknown): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  const visit = (s: unknown): void => {
+    if (Array.isArray(s)) s.forEach(visit);
+    else if (s && typeof s === 'object') Object.assign(out, s);
+  };
+  visit(style);
+  return out;
+}
+
+/** Every host node rendered as `tag`. */
+function hosts(root: ReactTestInstance, tag: string): ReactTestInstance[] {
+  return root.findAll((node) => typeof node.type === 'string' && node.type === tag);
+}
+
+/**
+ * Render `surface.native.tsx` against a given `expo-glass-effect`.
+ *
+ * Only the surface comes from the isolated registry — testing-library registers
+ * suite-level hooks when it loads, so it has to be imported at the top of the file
+ * rather than inside a test. Nothing in the rendered tree calls a hook, and the
+ * surface renders host strings from the reanimated mock, so the two registries
+ * never have to agree on a React instance. `times` re-renders within one registry,
+ * for the assertion about module-scoped memoization.
+ */
+function renderNativeSurface(glassEffect: GlassEffectModule, times = 1): ReactTestInstance {
+  let root: ReactTestInstance | undefined;
+
+  jest.isolateModules(() => {
+    jest.doMock('expo-glass-effect', () => glassEffect);
+
+    const { TabBarSurface } = require('../tab-bar/surface.native') as {
+      TabBarSurface: React.ComponentType<TabBarSurfaceProps>;
+    };
+
+    for (let i = 0; i < times; i += 1) {
+      root = render(<TabBarSurface theme={THEME} style={STYLE} />).UNSAFE_root;
+    }
+  });
+
+  if (!root) throw new Error('the native surface did not render');
+  return root;
+}
+
+/** Assert the tree is the opaque non-glass surface, filled from the theme. */
+function expectSolidFallback(root: ReactTestInstance): void {
+  expect(hosts(root, GLASS_HOST)).toHaveLength(0);
+  const surface = hosts(root, 'Animated.View')[0];
+  expect(surface).toBeTruthy();
+  expect(flattenStyle(surface?.props.style).backgroundColor).toBe(THEME.solidFallback);
+  // The animated capsule radius must survive the fallback — the pill still
+  // reshapes as the bar minimizes.
+  expect(flattenStyle(surface?.props.style).borderRadius).toBe(STYLE.borderRadius);
+}
+
+describe('TabBarSurface (native) — degrading when glass is unusable', () => {
+  let warn: jest.SpyInstance<void, Parameters<typeof console.warn>>;
+
+  beforeEach(() => {
+    jest.resetModules();
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+  });
+
+  it('falls back when the module resolved without GlassView', () => {
+    // `createAnimatedComponent(undefined)` produces an element type React rejects
+    // with "Element type is invalid … but got: undefined" — and it happens at
+    // import, so the whole screen the bar is on goes down with it.
+    expectSolidFallback(
+      renderNativeSurface({ GlassView: undefined, isLiquidGlassAvailable: () => true }),
+    );
+  });
+
+  it('falls back when the module delivered no exports at all', () => {
+    // A stub, an alias, or a resolver that landed on a platform-specific file:
+    // there is no `isLiquidGlassAvailable` to call either, so calling it blindly
+    // is a TypeError.
+    expectSolidFallback(renderNativeSurface({}));
+  });
+
+  it('falls back when the native module is missing from the build', () => {
+    // On iOS `isLiquidGlassAvailable()` resolves `ExpoGlassEffect` through
+    // `requireNativeModule`, which THROWS by contract when the module is not in
+    // the binary — an OTA JS update landing on a binary built before the package
+    // was linked reaches exactly this state.
+    expectSolidFallback(
+      renderNativeSurface({
+        GlassView: GLASS_HOST,
+        isLiquidGlassAvailable: () => {
+          throw new Error("Cannot find native module 'ExpoGlassEffect'");
+        },
+      }),
+    );
+  });
+
+  it('reports the missing native module instead of swallowing it', () => {
+    renderNativeSurface({
+      GlassView: GLASS_HOST,
+      isLiquidGlassAvailable: () => {
+        throw new Error("Cannot find native module 'ExpoGlassEffect'");
+      },
+    });
+
+    expect(warn).toHaveBeenCalledTimes(1);
+    const [message, detail] = warn.mock.calls[0] ?? [];
+    expect(String(message)).toContain('expo-glass-effect');
+    expect(String(detail)).toContain("Cannot find native module 'ExpoGlassEffect'");
+  });
+
+  it('falls back when the platform has no glass API (iOS 26 betas)', () => {
+    // Upstream's own guard: on those builds `isLiquidGlassAvailable()` answers
+    // true while touching `GlassView` crashes NATIVELY, below JS.
+    expectSolidFallback(
+      renderNativeSurface({
+        GlassView: GLASS_HOST,
+        isLiquidGlassAvailable: () => true,
+        isGlassEffectAPIAvailable: () => false,
+      }),
+    );
+  });
+
+  it('renders real glass when the package is fully there', () => {
+    const root = renderNativeSurface({
+      GlassView: GLASS_HOST,
+      isLiquidGlassAvailable: () => true,
+      isGlassEffectAPIAvailable: () => true,
+    });
+
+    const glass = hosts(root, GLASS_HOST)[0];
+    expect(glass).toBeTruthy();
+    expect(glass?.props.glassEffectStyle).toBe('regular');
+    expect(flattenStyle(glass?.props.style).backgroundColor).toBe(THEME.glassTint);
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it('renders glass on a version that predates isGlassEffectAPIAvailable', () => {
+    // The probe first shipped in 0.1.9, so the `>=0.1.9` peer floor guarantees it
+    // — but a peer range only WARNS, so a consumer can still resolve an older
+    // copy. A missing probe means "not applicable", never "unavailable"; treating
+    // it as the latter would delete the glass look on every working device.
+    expect(
+      hosts(
+        renderNativeSurface({ GlassView: GLASS_HOST, isLiquidGlassAvailable: () => true }),
+        GLASS_HOST,
+      ),
+    ).toHaveLength(1);
+  });
+
+  it('probes availability once per session, not once per render', () => {
+    let probes = 0;
+    renderNativeSurface(
+      {
+        GlassView: GLASS_HOST,
+        isLiquidGlassAvailable: () => {
+          probes += 1;
+          return true;
+        },
+      },
+      3,
+    );
+    expect(probes).toBe(1);
+  });
+
+  it('reuses the neutral surface rather than a second implementation', () => {
+    // Two copies of the fallback would drift: the neutral variant is what web
+    // bundlers and a consumer's `tsc` resolve, and it must paint exactly what an
+    // Android device paints.
+    jest.isolateModules(() => {
+      const { TabBarSurface } = require('../tab-bar/surface') as { TabBarSurface: unknown };
+      const { SolidTabBarSurface } = require('../tab-bar/surface-solid') as {
+        SolidTabBarSurface: unknown;
+      };
+      expect(TabBarSurface).toBe(SolidTabBarSurface);
+    });
+  });
+});

package/src/__tests__/TabBarReanimatedDeps.test.ts

@@ -0,0 +1,130 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+/**
+ * Every reanimated mapper in the tab bar must pass a NON-EMPTY dependency array.
+ *
+ * On web WITHOUT the react-native-worklets babel plugin — the production reality
+ * for every Oxy RN-Web app — reanimated cannot auto-detect which shared values a
+ * worklet reads, so it drives the mapper off its deps array instead. A missing or
+ * empty array means the mapper runs ONCE and freezes at the first frame: the
+ * shared values keep animating underneath, the DOM never updates. For this
+ * component that means a bar that never minimizes, a highlight that never moves
+ * and a scroll handler bound to the first render's state — with no error
+ * anywhere. Native (plugin present) auto-tracks and ignores the extra deps, so
+ * listing them is correct on both platforms.
+ *
+ * This is deliberately STRICTER than the repo-wide `animated-style-deps` guard,
+ * which only checks that the values a mapper reads appear in the deps it
+ * declares. Here every mapper must carry a real deps array whether or not the
+ * regex can see a `.value` read inside it, and `useAnimatedScrollHandler` — which
+ * the repo-wide guard does not scan at all — is included, because
+ * `useMinimizeOnScroll` is the single entry point through which every screen
+ * drives the bar.
+ *
+ * Jest cannot catch this class at all: the reanimated mock resolves mappers
+ * synchronously, so a frozen mapper and a working one render identically. Source
+ * analysis is the only automatable check; the real behaviour is verified in a
+ * foregrounded browser tab.
+ */
+
+const SRC = join(__dirname, '..');
+const ROOTS = ['tab-bar', 'progressive-blur'] as const;
+const MAPPERS = [
+  'useAnimatedStyle',
+  'useAnimatedScrollHandler',
+  'useDerivedValue',
+  'useAnimatedProps',
+] as const;
+
+/**
+ * Floors for the self-check, not exact counts — a new mapper or module must not
+ * fail this suite, but a walk that silently stops finding things must.
+ */
+const MIN_FILES = 16;
+const MIN_MAPPERS = 7;
+
+type Offender = { location: string; mapper: string; problem: string };
+
+/** Comments legitimately discuss mappers and show them in examples. */
+function stripComments(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, (block) => '\n'.repeat((block.match(/\n/g) ?? []).length))
+    .replace(/^[ \t]*\/\/.*$/gm, '');
+}
+
+function sourceFiles(dir: string): string[] {
+  return readdirSync(dir).flatMap((entry) => {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      return entry === '__tests__' ? [] : sourceFiles(full);
+    }
+    return /\.tsx?$/.test(entry) ? [full] : [];
+  });
+}
+
+/** Text between the parens of the call starting at `start`, paren-balanced. */
+function callText(source: string, start: number): string {
+  const open = source.indexOf('(', start);
+  let depth = 0;
+  for (let i = open; i < source.length; i++) {
+    if (source[i] === '(') depth += 1;
+    else if (source[i] === ')') {
+      depth -= 1;
+      if (depth === 0) return source.slice(open + 1, i);
+    }
+  }
+  return source.slice(open + 1);
+}
+
+function analyse(): { offenders: Offender[]; files: number; calls: number } {
+  const offenders: Offender[] = [];
+  const scanned = ROOTS.flatMap((root) => sourceFiles(join(SRC, root)));
+  let calls = 0;
+
+  for (const file of scanned) {
+    const source = stripComments(readFileSync(file, 'utf8'));
+
+    for (const mapper of MAPPERS) {
+      // `\b` before the name so `useAnimatedStyleX` can never match.
+      for (const call of source.matchAll(new RegExp(`\\b${mapper}\\s*\\(`, 'g'))) {
+        if (call.index === undefined) continue;
+        calls += 1;
+
+        const text = callText(source, call.index);
+        const line = source.slice(0, call.index).split('\n').length;
+        const location = `${relative(SRC, file)}:${line}`;
+
+        // Trailing comma after the deps array is idiomatic and must parse.
+        const deps = [...text.matchAll(/,\s*(\[[\s\S]*?\])\s*,?\s*$/g)].pop();
+        if (!deps) {
+          offenders.push({ location, mapper, problem: 'no deps array' });
+          continue;
+        }
+        if ((deps[1] ?? '').replace(/\s/g, '') === '[]') {
+          offenders.push({ location, mapper, problem: 'empty deps array' });
+        }
+      }
+    }
+  }
+
+  return { offenders, files: scanned.length, calls };
+}
+
+const { offenders, files, calls } = analyse();
+
+describe('tab-bar reanimated mapper dependency arrays', () => {
+  it('walked a plausible number of source files (guards against a broken walk)', () => {
+    expect(files).toBeGreaterThanOrEqual(MIN_FILES);
+  });
+
+  it('found a plausible number of mapper call sites (guards against a vacuous pass)', () => {
+    // Without this, a broken regex would make the real assertion below pass by
+    // finding nothing at all.
+    expect(calls).toBeGreaterThanOrEqual(MIN_MAPPERS);
+  });
+
+  it('has no mapper with a missing or empty deps array', () => {
+    expect(offenders.map((o) => `${o.location} ${o.mapper} — ${o.problem}`)).toEqual([]);
+  });
+});

package/src/__tests__/TabBarWebFork.test.ts

@@ -0,0 +1,243 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Structural guard for the tab bar's platform split.
+ *
+ * `@oxyhq/bloom/tab-bar` has to resolve cleanly in four places at once: Metro on
+ * iOS/Android (platform extensions), a web bundler (the `browser` export
+ * condition), a non-Metro bundler reading the published `lib/`, and a consumer's
+ * `tsc` (which follows the `"react-native"` source condition). Three packages
+ * break that the moment they appear outside a `.native` file:
+ * `expo-glass-effect` and `expo-symbols` are native-only, and `expo-router` /
+ * `react-native-screens` belong solely to the opt-in
+ * `@oxyhq/bloom/tab-bar/expo-router` subpath so the core bar stays usable in an
+ * app with no router at all.
+ *
+ * None of that is observable from a jest render — a missing `.web` retarget or a
+ * leaked native import fails at a consumer's BUILD, in a repo that isn't this
+ * one. Hence source/contract assertions.
+ *
+ * Every assertion below matches on real import/export/require STATEMENTS, never
+ * on bare substrings: the doc comments in these files name all four packages on
+ * purpose (explaining why they are absent), so `includes('expo-symbols')` would
+ * report a failure that is actually the documentation doing its job.
+ */
+
+const SRC = join(__dirname, '..');
+const REPO_ROOT = join(SRC, '..');
+
+const read = (rel: string) => readFileSync(join(SRC, rel), 'utf8');
+
+/** Packages that must never be reached from a neutral or web module. */
+const PLATFORM_ONLY = [
+  'expo-glass-effect',
+  'expo-symbols',
+  'expo-router',
+  'react-native-screens',
+] as const;
+
+/**
+ * Files resolved by a web bundler, a non-Metro bundler, or a consumer's `tsc`.
+ * `expo-router/index.ts` and its siblings are deliberately absent — that subpath
+ * is where the router packages are allowed to live.
+ */
+const NEUTRAL_AND_WEB_FILES = [
+  'tab-bar/index.ts',
+  'tab-bar/index.web.tsx',
+  'tab-bar/types.ts',
+  'tab-bar/shared.ts',
+  'tab-bar/TabBarBase.tsx',
+  'tab-bar/minimize-context.tsx',
+  'tab-bar/surface.tsx',
+  'tab-bar/surface-solid.tsx',
+  'tab-bar/surface.web.tsx',
+  'tab-bar/glyph.tsx',
+  'progressive-blur/index.web.tsx',
+  'progressive-blur/shared.ts',
+  'progressive-blur/types.ts',
+] as const;
+
+/**
+ * Blank out comments so a doc comment discussing a package is not mistaken for
+ * an import of it. Line comments are matched only when they START the line, so
+ * a `//` inside a string literal (a URL) survives untouched.
+ */
+function stripComments(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/^[ \t]*\/\/.*$/gm, '');
+}
+
+/** Every module specifier the file actually imports, re-exports or requires. */
+function moduleSpecifiers(source: string): string[] {
+  const code = stripComments(source);
+  const patterns = [
+    /\bfrom\s*['"]([^'"]+)['"]/g, // import … from 'x' / export … from 'x'
+    /\bimport\s*['"]([^'"]+)['"]/g, // bare side-effect import 'x'
+    /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g,
+    /\bimport\(\s*['"]([^'"]+)['"]\s*\)/g,
+  ];
+  const found = new Set<string>();
+  for (const pattern of patterns) {
+    for (const match of code.matchAll(pattern)) {
+      if (match[1]) found.add(match[1]);
+    }
+  }
+  return [...found];
+}
+
+/** True when `specifier` resolves to `pkg` (bare or a subpath of it). */
+function isFrom(specifier: string, pkg: string): boolean {
+  return specifier === pkg || specifier.startsWith(`${pkg}/`);
+}
+
+describe('tab-bar platform split', () => {
+  it('the extractor sees real imports and ignores commented-out ones', () => {
+    // Self-check: if `moduleSpecifiers` breaks, every assertion below would
+    // pass vacuously by finding nothing.
+    const probe = [
+      "/* a doc comment naming expo-symbols and expo-router */",
+      "// import { Nope } from 'react-native-screens';",
+      "import { A } from 'react-native';",
+      "export type { B } from './types';",
+      "const c = require('expo-glass-effect');",
+    ].join('\n');
+    expect(moduleSpecifiers(probe).sort()).toEqual([
+      './types',
+      'expo-glass-effect',
+      'react-native',
+    ]);
+  });
+
+  it.each(NEUTRAL_AND_WEB_FILES)('%s imports no native-only or router package', (file) => {
+    const specifiers = moduleSpecifiers(read(file));
+    const leaked = specifiers.filter((s) => PLATFORM_ONLY.some((pkg) => isFrom(s, pkg)));
+    expect(leaked).toEqual([]);
+  });
+
+  it('the web progressive blur drops expo-blur for one masked backdrop-filter', () => {
+    // Ten stacked BlurViews would be ten composited backdrop passes per frame.
+    expect(moduleSpecifiers(read('progressive-blur/index.web.tsx'))).not.toContain('expo-blur');
+    expect(moduleSpecifiers(read('progressive-blur/index.tsx'))).toContain('expo-blur');
+  });
+
+  it('the native surface and glyph are the ONLY holders of the native packages', () => {
+    // The guard above only proves absence; this proves the split is real rather
+    // than the feature having quietly lost its native path.
+    expect(moduleSpecifiers(read('tab-bar/surface.native.tsx'))).toContain('expo-glass-effect');
+    expect(moduleSpecifiers(read('tab-bar/glyph.native.tsx'))).toContain('expo-symbols');
+  });
+
+  it('the native surface takes its fallback from surface-solid, never ./surface', () => {
+    // Metro resolves a bare `./surface` to `surface.native.tsx` from ANY caller,
+    // so importing the neutral sibling by that name would be a self-import — which
+    // is the entire reason `surface-solid.tsx` exists as a separate name.
+    const specifiers = moduleSpecifiers(read('tab-bar/surface.native.tsx'));
+    expect(specifiers).toContain('./surface-solid');
+    expect(specifiers).not.toContain('./surface');
+    // And the neutral variant must be that same component, not a second copy.
+    expect(moduleSpecifiers(read('tab-bar/surface.tsx'))).toContain('./surface-solid');
+  });
+
+  it('the router packages live only under tab-bar/expo-router', () => {
+    const router = moduleSpecifiers(read('tab-bar/expo-router/RouterTabBar.tsx'));
+    expect(router.some((s) => isFrom(s, 'expo-router'))).toBe(true);
+    const screen = moduleSpecifiers(read('tab-bar/expo-router/fading-tab-screen.tsx'));
+    expect(screen).toContain('react-native-screens');
+  });
+
+  it('the default entry imports the platform pieces BY BARE NAME (Metro picks .native)', () => {
+    const specifiers = moduleSpecifiers(read('tab-bar/index.ts'));
+    expect(specifiers).toContain('./surface');
+    expect(specifiers).toContain('./glyph');
+    expect(specifiers).toContain('../progressive-blur');
+    // A `.web` path here would pin every platform to the web fork.
+    expect(specifiers).not.toContain('./surface.web');
+  });
+
+  it('the web entry imports the web pieces by their FULL .web name', () => {
+    // Inside the published `lib/` every file is plain `.js`, and no web bundler
+    // resolves a bare `./surface` to the `.web` sibling — only Metro does.
+    const specifiers = moduleSpecifiers(read('tab-bar/index.web.tsx'));
+    expect(specifiers).toContain('./surface.web');
+    expect(specifiers).toContain('../progressive-blur/index.web');
+    expect(specifiers).not.toContain('./surface');
+    // `./glyph` has no web fork: the neutral file already renders `item.icon`,
+    // which is the correct web behaviour.
+    expect(specifiers).toContain('./glyph');
+  });
+});
+
+describe('tab-bar published surface', () => {
+  const pkg = JSON.parse(readFileSync(join(REPO_ROOT, 'package.json'), 'utf8')) as {
+    exports: Record<string, { browser?: { import?: string; require?: string } }>;
+    peerDependencies: Record<string, string>;
+    peerDependenciesMeta: Record<string, { optional?: boolean }>;
+  };
+
+  it('exports ./tab-bar with a browser condition → index.web.js', () => {
+    const entry = pkg.exports['./tab-bar'];
+    expect(entry).toBeDefined();
+    expect(entry?.browser?.import).toBe('./lib/module/tab-bar/index.web.js');
+    expect(entry?.browser?.require).toBe('./lib/commonjs/tab-bar/index.web.js');
+  });
+
+  it('exports ./progressive-blur with a browser condition → index.web.js', () => {
+    expect(pkg.exports['./progressive-blur']?.browser?.import).toBe(
+      './lib/module/progressive-blur/index.web.js',
+    );
+  });
+
+  it('exports ./tab-bar/expo-router with NO browser condition', () => {
+    // The router adapter is universal — it only re-binds `TabBar`/`TabBarButton`,
+    // whose own entry already resolves per platform. There is no `.web` sibling,
+    // so a browser condition would point at a file bob never emits.
+    const entry = pkg.exports['./tab-bar/expo-router'];
+    expect(entry).toBeDefined();
+    expect(entry?.browser).toBeUndefined();
+  });
+
+  it('declares the two Apple-only native peers REQUIRED, keeping their ranges', () => {
+    // `expo-glass-effect` and `expo-symbols` are imported STATICALLY, by
+    // `tab-bar/surface.native` and `tab-bar/glyph.native`. That is what settles
+    // this: optional means "you may omit this", but omitting it does not degrade
+    // — the native bundle fails to RESOLVE the specifier and the build dies. An
+    // optional peer plus a static import is an incoherent pair, and the only
+    // thing marking them optional would achieve is silencing the one warning
+    // that tells a consumer their build is about to break. Declared the same way
+    // `expo-blur` already is, for the same reason.
+    //
+    // The RANGE carries the second half: both files import symbols that arrived
+    // after 1.0 — `isGlassEffectAPIAvailable` first shipped in
+    // expo-glass-effect 0.1.9 — so an older installed copy is a real
+    // incompatibility, not merely an absent one.
+    for (const peer of ['expo-glass-effect', 'expo-symbols']) {
+      expect(pkg.peerDependencies[peer]).toMatch(/^>=\d/);
+      expect(pkg.peerDependenciesMeta[peer]).toBeUndefined();
+    }
+  });
+
+  it('keeps the cross-platform native peers REQUIRED', () => {
+    // `expo-blur` and `expo-image` are apple+android native modules imported from
+    // platform-NEUTRAL files (`progressive-blur/index.tsx`,
+    // `frosted-icon-button/FrostedIconButton.tsx`, `zoomable-image-gallery/`), so
+    // every native platform genuinely needs them. Marking them optional would
+    // silence the one warning that tells a consumer their build is about to fail.
+    for (const peer of ['expo-blur', 'expo-image']) {
+      expect(pkg.peerDependencies[peer]).toBeDefined();
+      expect(pkg.peerDependenciesMeta[peer]).toBeUndefined();
+    }
+  });
+
+  it('the generator lists exactly the right subpaths as web-forked', () => {
+    const gen = readFileSync(join(REPO_ROOT, 'scripts/generate-platform-exports.mjs'), 'utf8');
+    const block = /const WEB_FORKED_SUBPATHS = new Set\(\[([\s\S]*?)\]\);/.exec(gen)?.[1];
+    expect(block).toBeDefined();
+    const listed = [...(block ?? '').matchAll(/^\s*'([^']+)',/gm)].map((m) => m[1]);
+    expect(listed).toContain('./tab-bar');
+    expect(listed).toContain('./progressive-blur');
+    // `assertWebSourceExists()` throws for this one — it has no `.web` sibling.
+    expect(listed).not.toContain('./tab-bar/expo-router');
+  });
+});