@oxyhq/bloom 0.79.1 → 0.80.0

package/lib/typescript/module/tabs/expo-router/RouterTabs.d.ts

@@ -0,0 +1,80 @@
+/**
+ * expo-router bindings for the in-screen tab strip.
+ *
+ * This subpath (`@oxyhq/bloom/tabs/expo-router`) is the ONLY place in the tabs
+ * feature allowed to import `expo-router`, which is why it is a separate entry:
+ * the core `@oxyhq/bloom/tabs` stays usable in an app with a different router,
+ * or none, and the optional peer is never pulled into a bundle that does not
+ * ask for it. Same split as `tab-bar` / `tab-bar/expo-router` and
+ * `scroll` / `scroll/expo-router`.
+ *
+ * Everything routing-shaped lives here on purpose: which tab the route means,
+ * what a committed swipe navigates to, and which links to warm. The strip
+ * itself stays presentational and knows only about measured geometry.
+ */
+import { type ReactNode } from 'react';
+import { type Href } from 'expo-router';
+import type { TabsProps } from '../types';
+export interface RouterTabItem {
+    /** Stable id for the tab. Used as a React key and a callback argument. */
+    value: string;
+    /** Tab label text. */
+    label: string;
+    /** The route this tab shows. Must be the tab's EXACT path. */
+    href: Href;
+    /** Icon rendered before the label. */
+    icon?: ReactNode;
+    /** Optional tally beside the label; `0` or omitted renders nothing. */
+    count?: number;
+    disabled?: boolean;
+}
+export type RouterTabsProps = Omit<TabsProps, 'value' | 'onValueChange' | 'hasSelection' | 'children'> & {
+    items: RouterTabItem[];
+    /**
+     * Called instead of navigating when the ALREADY-active tab is pressed.
+     *
+     * Without it a re-tap would push a second history entry for the route the
+     * user is already on, so Back would appear to do nothing. Re-tapping the
+     * active tab conventionally means "refresh" or "scroll to top", and that is
+     * the caller's to define.
+     */
+    onReselect?: (value: string) => void;
+    /**
+     * Enable the horizontal swipe between neighbouring tabs. Defaults to `true`.
+     *
+     * The gesture is INDICATOR-LED: the underline tracks the finger toward the
+     * neighbour and commits on release past a threshold, while the content stays
+     * where it is. That asymmetry is deliberate — the underline has somewhere
+     * real to go and can complete its journey, whereas under a `<Slot/>` there is
+     * no neighbouring screen mounted to bring in, so translating the content
+     * would only open a blank gutter on the trailing edge.
+     */
+    swipeEnabled?: boolean;
+};
+/**
+ * A tab strip whose selection IS the route.
+ *
+ * Render it in the LAYOUT that owns the tabs, above the `<Slot/>` that renders
+ * them — not inside the tab screens themselves. That placement is the whole
+ * point, and it is load-bearing twice over: a strip inside the screens is
+ * unmounted and rebuilt by every navigation, so its underline has nothing to
+ * animate from and the chrome blanks while the incoming route's chunk loads;
+ * and a GESTURE inside the screens would be destroyed by the very navigation it
+ * commits, mid-release.
+ *
+ * ```tsx
+ * // app/(app)/[username]/_layout.tsx
+ * <RouterTabs
+ *   items={[
+ *     { value: 'posts', label: 'Posts', href: `/${username}` },
+ *     { value: 'replies', label: 'Replies', href: `/${username}/replies` },
+ *   ]}
+ * />
+ * <Slot />
+ * ```
+ */
+export declare function RouterTabs({ items, onReselect, swipeEnabled, ...tabsProps }: RouterTabsProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace RouterTabs {
+    var displayName: string;
+}
+//# sourceMappingURL=RouterTabs.d.ts.map

package/lib/typescript/module/tabs/expo-router/RouterTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouterTabs.d.ts","sourceRoot":"","sources":["../../../../../src/tabs/expo-router/RouterTabs.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAA2C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGhF,OAAO,EAAuB,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAG7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,WAAW,aAAa;IAC5B,0EAA0E;IAC1E,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,IAAI,EAAE,IAAI,CAAC;IACX,sCAAsC;IACtC,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,SAAS,EAGT,OAAO,GAAG,eAAe,GAAG,cAAc,GAAG,UAAU,CACxD,GAAG;IACF,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAuCF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,EACzB,KAAK,EACL,UAAU,EACV,YAAmB,EACnB,GAAG,SAAS,EACb,EAAE,eAAe,2CAwIjB;yBA7Ie,UAAU"}

package/lib/typescript/module/tabs/expo-router/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Entry for `@oxyhq/bloom/tabs/expo-router`. The component lives in a sibling
+ * module because this file is the published entry path and must stay stable;
+ * the split also keeps the router binding in one place, which is what the
+ * optional-peer allowlist asserts about.
+ */
+export { RouterTabs } from './RouterTabs';
+export type { RouterTabItem, RouterTabsProps } from './RouterTabs';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/tabs/expo-router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/tabs/expo-router/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/lib/typescript/module/tabs/types.d.ts

@@ -1,10 +1,38 @@
 import type { StyleProp, ViewStyle, TextStyle } from 'react-native';
 export type TabsVariant = 'underline' | 'filled' | 'outlined';
 export interface TabsProps {
-    /** The currently selected tab value. */
-    value: string;
-    /** Called when a tab is selected. */
-    onValueChange: (value: string) => void;
+    /**
+     * The currently selected tab value — the CONTROLLED path, where the bar owns
+     * the underline and reports presses through {@link TabsProps.onValueChange}.
+     *
+     * OMIT it for the focus-driven path, where each trigger supplies its own
+     * {@link TabsTriggerProps.isFocused} and performs its own navigation. That is
+     * how `@oxyhq/bloom/tabs/expo-router` keeps the underline correct through
+     * deep links, browser Back and back gestures — none of which pass through a
+     * press handler. Providing both would put two writers on one shared value.
+     */
+    value?: string;
+    /** Called when a tab is selected. Controlled path only. */
+    onValueChange?: (value: string) => void;
+    /**
+     * Focus-driven path only: whether ANY trigger is currently focused.
+     *
+     * `false` fades the underline out where it stands. This is not the same as
+     * "the selection moved", and it is not hypothetical: a strip rendered by a
+     * LAYOUT keeps rendering while the layout's other, non-tab children are
+     * showing — a profile's `/followers` sits beside its tab routes under one
+     * layout — and without this the underline stays parked on whichever tab was
+     * last visited, asserting a selection that is not there.
+     *
+     * Fading is the whole response; the underline is deliberately NOT moved,
+     * because there is no position that means "nowhere" and travelling to a
+     * sentinel would drag it across every tab on the way out.
+     *
+     * `RouterTabs` sets it, so an app author never passes it by hand. Defaults to
+     * `true`, which is correct for the controlled path (a `value` naming no
+     * trigger simply leaves the underline where it was, as it always has).
+     */
+    hasSelection?: boolean;
     /** Visual variant for the tab bar. */
     variant?: TabsVariant;
     /**
@@ -26,8 +54,24 @@ export interface TabsTriggerProps {
     label: string;
     /** Icon rendered before the label. */
     icon?: React.ReactNode;
+    /**
+     * Optional tally rendered as a small muted number beside the label. Omitted
+     * (or `0`) renders nothing. The underline tracks the trigger's measured
+     * width, so a count never changes where it sits.
+     */
+    count?: number;
+    /**
+     * Whether the ROUTER considers this tab focused — the focus-driven path.
+     * Supplying it makes this trigger, not the bar, the writer of the shared
+     * underline, and suppresses {@link TabsProps.onValueChange} on press because
+     * navigation is then the caller's job. Leave it `undefined` on the controlled
+     * path.
+     */
+    isFocused?: boolean;
     /** Whether this tab is disabled. */
     disabled?: boolean;
+    /** Extra press handler. Runs on both paths, before any selection is reported. */
+    onPress?: () => void;
     style?: StyleProp<ViewStyle>;
     textStyle?: StyleProp<TextStyle>;
 }

package/lib/typescript/module/tabs/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,sCAAsC;IACtC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/tabs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEpE,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE9D,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sCAAsC;IACtC,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,qDAAqD;IACrD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,IAAI,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACvB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,oCAAoC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,qBAAqB;IACrB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "0.79.1",
+  "version": "0.80.0",
   "packageManager": "bun@1.3.14",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
@@ -1154,6 +1154,20 @@
         "default": "./lib/commonjs/tabs/index.js"
       }
     },
+    "./tabs/expo-router": {
+      "react-native": {
+        "types": "./lib/typescript/module/tabs/expo-router/index.d.ts",
+        "default": "./src/tabs/expo-router/index.ts"
+      },
+      "import": {
+        "types": "./lib/typescript/module/tabs/expo-router/index.d.ts",
+        "default": "./lib/module/tabs/expo-router/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/tabs/expo-router/index.d.ts",
+        "default": "./lib/commonjs/tabs/expo-router/index.js"
+      }
+    },
     "./checkbox": {
       "react-native": {
         "types": "./lib/typescript/module/checkbox/index.d.ts",

package/src/__tests__/Tabs.test.tsx

@@ -107,4 +107,191 @@ describe('Tabs', () => {
       triggerFor(getByText('Second')).props.accessibilityState.selected,
     ).toBe(true);
   });
+
+  /**
+   * The shape a real consumer outside this repo ships, spelled out so a later
+   * refactor of the controlled path cannot break it silently. OxyPay's wallet
+   * screen (`packages/frontend/app/(tabs)/index.tsx`) renders exactly this: a
+   * controlled `value` + `onValueChange`, `variant="underline"`, a `style`
+   * override zeroing the bottom border, and label-only triggers.
+   *
+   * A Bloom bump reaches it, and it has no test of its own here — so this is
+   * the only thing standing between that screen and a silent regression.
+   */
+  it('supports the controlled call shape a published consumer uses', () => {
+    const onValueChange = jest.fn();
+    const { getByText, getByTestId } = renderWithTheme(
+      <Tabs
+        value="overview"
+        onValueChange={onValueChange}
+        variant="underline"
+        style={{ borderBottomWidth: 0 }}
+        testID="tabs"
+      >
+        <TabsTrigger value="overview" label="Overview" />
+        <TabsTrigger value="activity" label="Activity" />
+      </Tabs>,
+    );
+
+    expect(getByTestId('tabs-indicator')).toBeTruthy();
+    expect(triggerFor(getByText('Overview')).props.accessibilityState.selected).toBe(true);
+    fireEvent.press(getByText('Activity'));
+    expect(onValueChange).toHaveBeenCalledWith('activity');
+  });
+
+  describe('focus-driven path (router adapter)', () => {
+    it('takes selection from isFocused rather than the bar value', () => {
+      // No `value` at all — the router owns the selection.
+      const { getByText } = renderWithTheme(
+        <Tabs testID="tabs">
+          <TabsTrigger value="a" label="First" isFocused={false} />
+          <TabsTrigger value="b" label="Second" isFocused />
+        </Tabs>,
+      );
+      expect(triggerFor(getByText('First')).props.accessibilityState.selected).toBe(false);
+      expect(triggerFor(getByText('Second')).props.accessibilityState.selected).toBe(true);
+    });
+
+    it('does NOT report a selection on press, because the caller navigates', () => {
+      // Two writers on one underline is the bug this prevents: the router
+      // moves it via `isFocused`, so the bar must not also move it on press.
+      const onValueChange = jest.fn();
+      const onPress = jest.fn();
+      const { getByText } = renderWithTheme(
+        <Tabs onValueChange={onValueChange} testID="tabs">
+          <TabsTrigger value="a" label="First" isFocused />
+          <TabsTrigger value="b" label="Second" isFocused={false} onPress={onPress} />
+        </Tabs>,
+      );
+      fireEvent.press(getByText('Second'));
+      expect(onPress).toHaveBeenCalled();
+      expect(onValueChange).not.toHaveBeenCalled();
+    });
+
+    it('still reports a selection on press when isFocused is absent', () => {
+      // The discriminator is `isFocused` being supplied AT ALL, not its value —
+      // so a controlled bar keeps working exactly as before.
+      const onValueChange = jest.fn();
+      const { getByText } = renderWithTheme(<Bar value="a" onValueChange={onValueChange} />);
+      fireEvent.press(getByText('Second'));
+      expect(onValueChange).toHaveBeenCalledWith('b');
+    });
+  });
+
+  describe('counts', () => {
+    it('renders a count beside the label and folds it into the a11y label', () => {
+      const { getByText, queryByText } = renderWithTheme(
+        <Tabs value="a" onValueChange={() => {}} testID="tabs">
+          <TabsTrigger value="a" label="First" count={3} />
+          <TabsTrigger value="b" label="Second" count={0} />
+        </Tabs>,
+      );
+      expect(getByText('3')).toBeTruthy();
+      // A zero count renders nothing at all rather than a literal "0".
+      expect(queryByText('0')).toBeNull();
+      expect(triggerFor(getByText('First')).props.accessibilityLabel).toBe('First, 3');
+      expect(triggerFor(getByText('Second')).props.accessibilityLabel).toBe('Second');
+    });
+
+    it('caps a large tally so it cannot stretch the tab', () => {
+      const { getByText } = renderWithTheme(
+        <Tabs value="a" onValueChange={() => {}} testID="tabs">
+          <TabsTrigger value="a" label="First" count={100} />
+          <TabsTrigger value="b" label="Second" count={99} />
+        </Tabs>,
+      );
+      expect(getByText('99+')).toBeTruthy();
+      expect(getByText('99')).toBeTruthy();
+    });
+  });
+
+  /**
+   * `hasSelection` — a strip that is rendered while NOTHING it lists is showing.
+   *
+   * Not hypothetical, and the reason it exists: a routed strip lives in the
+   * LAYOUT, and a layout renders its non-tab children too. A profile's
+   * `/followers` sits beside its tab routes under one layout, so on that route
+   * every trigger reports `isFocused={false}` and, without this, the underline
+   * stays parked on whichever tab was visited last — asserting a selection that
+   * is not there.
+   *
+   * The assertion is on OPACITY rather than position on purpose: fading is the
+   * whole response, and the underline must NOT travel to a sentinel, which
+   * would drag it across every tab on the way out.
+   */
+  describe('no selection', () => {
+    /**
+     * Drive the strip and read the underline back.
+     *
+     * The re-render after each step is load-bearing, not ceremony: the
+     * reanimated jest mock evaluates `useAnimatedStyle`'s mapper at RENDER time
+     * (`useAnimatedStyle: (fn) => fn()`), so a shared value written from a
+     * layout callback is not visible in the rendered style until something
+     * renders again. Without it every assertion here reads the mount frame and
+     * "no selection" and "selection" are indistinguishable.
+     */
+    function mount(props: Partial<React.ComponentProps<typeof Bar>> = {}) {
+      const utils = renderWithTheme(<Bar value="a" {...props} />);
+      const renderOnce = (next: Partial<React.ComponentProps<typeof Bar>>) =>
+        utils.rerender(
+          <BloomThemeProvider mode="light" colorPreset="teal">
+            <Bar value="a" {...props} {...next} />
+          </BloomThemeProvider>,
+        );
+      // Twice, for the same reason the mock forces a re-render at all: a prop
+      // change is applied by an EFFECT, which runs after the render that
+      // carried it, so the first pass still renders the previous value. The
+      // second pass has identical props, so no effect re-runs and nothing is
+      // written twice — it only re-evaluates the mapper.
+      const render = (next: Partial<React.ComponentProps<typeof Bar>>) => {
+        renderOnce(next);
+        renderOnce(next);
+      };
+      return {
+        ...utils,
+        settle: () => render({}),
+        update: render,
+        measureFirstTrigger() {
+          let node: ReactTestInstance | null = triggerFor(utils.getByText('First'));
+          while (node && node.props?.onLayout === undefined) node = node.parent;
+          if (!node) throw new Error('no onLayout ancestor found for the trigger');
+          fireEvent(node, 'layout', { nativeEvent: { layout: { x: 0, width: 80 } } });
+        },
+        opacity: () =>
+          flattenStyle(utils.getByTestId('tabs-indicator').props.style).opacity,
+      };
+    }
+
+    it('starts hidden so an unmeasured strip never flashes an underline at the origin', () => {
+      expect(mount().opacity()).toBe(0);
+    });
+
+    it('shows the underline once the active trigger has been measured', () => {
+      const bar = mount();
+      bar.measureFirstTrigger();
+      bar.settle();
+      expect(bar.opacity()).toBe(1);
+    });
+
+    it('fades the underline out when hasSelection is false', () => {
+      const bar = mount();
+      bar.measureFirstTrigger();
+      bar.settle();
+      expect(bar.opacity()).toBe(1);
+
+      bar.update({ hasSelection: false });
+      expect(bar.opacity()).toBe(0);
+    });
+  });
+
+  it('names the component when a trigger is rendered outside a Tabs', () => {
+    // Without a provider the old code read a DEFAULT context and silently did
+    // nothing — a strip that renders but never moves. Failing loudly is the
+    // point; the message has to name the component to be actionable.
+    const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() =>
+      renderWithTheme(<TabsTrigger value="a" label="First" />),
+    ).toThrow(/TabsTrigger must be used within a Tabs/);
+    spy.mockRestore();
+  });
 });

package/src/__tests__/optional-peer-imports.test.ts

@@ -82,6 +82,11 @@ const ALLOWED: { peer: string; file: string; why: string }[] = [
     file: 'scroll/expo-router/index.ts',
     why: 'the whole point of this file is to BE the expo-router binding — it is reachable only from `@oxyhq/bloom/scroll/expo-router` and from BloomProvider, both of which are expo-router-only by construction; the scroll core itself no longer imports a router (see AGENTS.md "App Root Provider")',
   },
+  {
+    peer: 'expo-router',
+    file: 'tabs/expo-router/RouterTabs.tsx',
+    why: 'same shape as the scroll binding above — this file exists to BE the expo-router binding for the tab strip and is reachable only from `@oxyhq/bloom/tabs/expo-router`; the tabs core imports no router, so a consumer on a different router (or none) still gets `@oxyhq/bloom/tabs`',
+  },
 ];
 
 /**