@oxyhq/bloom 1.9.2 → 1.10.1

package/lib/typescript/module/layout/bottom-edge.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The bottom edge's OCCUPANCY — how much of it is already claimed by a floating
+ * surface, so the next surface can stack above it instead of underneath it.
+ *
+ * ## The problem
+ *
+ * `windowEdgeGap` tells a surface where the window edge is. It cannot tell it
+ * that a tab bar is already parked there. Nothing could, so nothing did: Bloom's
+ * `Fab` anchored itself 16px off the edge and landed squarely behind the
+ * floating tab bar, and every app that hit it patched around Bloom instead —
+ * Mention grew a `BottomBarAwareFab` that read `useTabBarFootprint()` and lifted
+ * the FAB by hand, on web only, leaving native broken across seven screens.
+ *
+ * A z-index cannot rescue that placement either. The tab bar host is the last
+ * sibling of the app shell, so it paints above every descendant regardless of
+ * what they claim; the FAB has to be somewhere ELSE, not merely on top.
+ *
+ * ## The model
+ *
+ * A surface that parks at the bottom edge CLAIMS its footprint. A surface that
+ * wants to avoid it READS the total and offsets itself. Neither one imports the
+ * other, so a consumer composes them in any combination — a tab bar with no FAB,
+ * a FAB with no tab bar, both, or a third surface written later — and the
+ * geometry still resolves.
+ *
+ * Claims combine with MAX, not sum. Every claim is measured from the same window
+ * edge, so two surfaces at that edge overlap rather than stack; the tallest is
+ * what a new surface has to clear. Summing would strand it at twice the height.
+ *
+ * ## Why an external store
+ *
+ * The claim set is mutable state living outside React. Reading it in a memoized
+ * position is exactly the stale-read the React Compiler produces, so it is read
+ * through `useSyncExternalStore` and never touched directly. The store is
+ * created per provider (not at module scope) so tests, and any app mounting two
+ * roots, stay isolated from each other.
+ */
+import { type PropsWithChildren } from 'react';
+/**
+ * Wrap the app once — `BloomProvider` already does. Rendering a second one
+ * scopes a nested subtree to its own claims, which is a real (if rare) thing to
+ * want: a bottom-edge surface inside a full-screen modal should not be offset by
+ * the tab bar the modal is covering.
+ */
+export declare function BottomEdgeProvider({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+export declare namespace BottomEdgeProvider {
+    var displayName: string;
+}
+/**
+ * How much of the bottom edge is already occupied, in px.
+ *
+ * Add it to whatever offset the surface would otherwise use:
+ *
+ * ```tsx
+ * const occupied = useBottomEdgeInset();
+ * <View style={{ position: 'absolute', bottom: windowEdgeGap(insets.bottom) + occupied }} />
+ * ```
+ *
+ * `0` outside a provider, and `0` on the first commit even inside one — a claim
+ * registers in an effect, so a reader mounted in the same commit as its claimant
+ * settles one frame later. That is a layout offset rather than a measurement, so
+ * the settle is invisible in practice; nothing here waits on a real layout pass.
+ */
+export declare function useBottomEdgeInset(): number;
+/**
+ * Claim `height` px of the bottom edge for as long as the caller is mounted.
+ *
+ * The claimant owns its own placement — claiming does not move it. It declares
+ * the space it occupies so that everything reading `useBottomEdgeInset()` stays
+ * off it. Pass the FULL footprint (the surface's height plus the gap it holds
+ * off the window edge), which is the same number the surface positions itself
+ * with.
+ *
+ * A no-op outside a provider, so a surface stays usable standalone.
+ */
+export declare function useClaimBottomEdge(height: number): void;
+//# sourceMappingURL=bottom-edge.d.ts.map

package/lib/typescript/module/layout/bottom-edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bottom-edge.d.ts","sourceRoot":"","sources":["../../../../src/layout/bottom-edge.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAOL,KAAK,iBAAiB,EACvB,MAAM,OAAO,CAAC;AAsDf;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,2CAGjE;yBAHe,kBAAkB;;;AAYlC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAO3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CASvD"}

package/lib/typescript/module/layout/edge.d.ts

@@ -0,0 +1,56 @@
+/**
+ * How far a floating surface sits from a window edge.
+ *
+ * ## The rule this file encodes
+ *
+ * A floating surface CLEARS THE OS'S RESERVED BAND IN FULL. The safe-area inset
+ * is the space the platform has reserved for its own affordance — the iOS home
+ * indicator, the Android gesture handle — and a surface that sits inside it is
+ * sitting on top of a system control.
+ *
+ * Bloom used to answer this question three times, differently:
+ *
+ *   - a detached `BottomSheet`  `insets.bottom + 16`
+ *   - the toast stack           `bottom > 0 ? bottom + 8 : 16`
+ *   - the floating tab bar      `max(bottom - 16, 12)`
+ *
+ * The tab bar was the only one that SUBTRACTED, and subtracting is what put it
+ * on the Android gesture handle: a gesture-navigation device reserves ~24dp, the
+ * bar absorbed 16 of it, hit its own 12dp floor, and landed inside the band with
+ * the handle drawn through it. The other two were never reachable by that bug
+ * because they add.
+ *
+ * One function now answers it for all three, and the additive `gap` reproduces
+ * the sheet and the toast exactly — only the tab bar moves.
+ */
+/**
+ * Breathing room from a window edge where the platform reserves nothing at all
+ * (web, a browser with no visual viewport inset, an Android device with the
+ * gesture bar hidden).
+ *
+ * It is also the FLOOR for every surface: a small-but-nonzero inset must never
+ * pull a surface closer to the edge than a device reporting no inset would.
+ */
+export declare const EDGE_GAP = 16;
+/**
+ * The distance a floating surface holds off a window edge, given that edge's
+ * safe-area inset.
+ *
+ * `gap` is the surface's own breathing room ON TOP of the reserved band, not an
+ * allowance to spend inside it — a bigger `gap` floats the surface further from
+ * the affordance, never closer. Pass `0` for a surface that should hug the safe
+ * area (the tab bar), a positive number for one that should stand clear of it (a
+ * detached sheet, a toast stack).
+ *
+ * ```ts
+ * windowEdgeGap(insets.bottom)      // 34pt iOS · 24dp Android · 16 web
+ * windowEdgeGap(insets.bottom, 16)  // 50pt iOS · 40dp Android · 16 web
+ * ```
+ *
+ * Anything laying out AROUND such a surface wants its total footprint (this gap
+ * plus the surface's own height) and must get it from the surface — never by
+ * adding `insets.bottom` to a hardcoded height, which double-counts the inset
+ * because the inset is already folded in here.
+ */
+export declare function windowEdgeGap(inset: number, gap?: number): number;
+//# sourceMappingURL=edge.d.ts.map

package/lib/typescript/module/layout/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../../../src/layout/edge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,SAAI,GAAG,MAAM,CAE5D"}

package/lib/typescript/module/layout/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Window-edge geometry, shared by every floating surface.
+ *
+ * `edge` answers "how far from the edge"; `bottom-edge` answers "what is already
+ * parked there". A surface that floats at the bottom needs both.
+ */
+export { EDGE_GAP, windowEdgeGap } from './edge';
+export { BottomEdgeProvider, useBottomEdgeInset, useClaimBottomEdge } from './bottom-edge';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/layout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/layout/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC"}

package/lib/typescript/module/provider/BloomProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BloomProvider.d.ts","sourceRoot":"","sources":["../../../../src/provider/BloomProvider.tsx"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,aAAa,EACb,OAAc,EACd,GAAG,UAAU,EACd,EAAE,kBAAkB,2CA2BpB;yBAhCe,aAAa"}
+{"version":3,"file":"BloomProvider.d.ts","sourceRoot":"","sources":["../../../../src/provider/BloomProvider.tsx"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,aAAa,EACb,OAAc,EACd,GAAG,UAAU,EACd,EAAE,kBAAkB,2CAoCpB;yBAzCe,aAAa"}

package/lib/typescript/module/tab-bar/TabBarBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TabBarBase.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/TabBarBase.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,OAAO,CAAC;AAiBf,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EAkBL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAe,MAAM,SAAS,CAAC;AA+iB3E;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAC1C,IAAI,EAAE,aAAa,CAAC,oBAAoB,CAAC;YAElB,WAAW;;EAGnC;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC;YAC1C,iBAAiB;;EAG/C"}
+{"version":3,"file":"TabBarBase.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/TabBarBase.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,OAAO,CAAC;AAmBf,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EAiBL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAe,MAAM,SAAS,CAAC;AAujB3E;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAC1C,IAAI,EAAE,aAAa,CAAC,oBAAoB,CAAC;YAElB,WAAW;;EAGnC;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC;YAC1C,iBAAiB;;EAG/C"}

package/lib/typescript/module/tab-bar/shared.d.ts

@@ -26,15 +26,6 @@ export declare const HIGHLIGHT_MINIMIZED: number;
 export declare const BLUR_BLEED = 44;
 /** Label type size. Small by design — the icon carries the meaning. */
 export declare const LABEL_FONT_SIZE = 9.5;
-/**
- * Vertical gap between the bottom of the pill and the bottom of the window.
- *
- * The safe-area inset is folded in HERE, which is why anything accounting for
- * the bar in its own layout must go through `useTabBarFootprint` (which derives
- * its number from this same function) rather than adding `insets.bottom` to a
- * hardcoded height — that double-counts the inset.
- */
-export declare function tabBarBottomGap(bottomInset: number): number;
 /**
  * Slide spring: interruptible by design — rapid tab-hopping retargets with
  * preserved velocity. Slight under-damping gives the pill a tiny settle, safe

package/lib/typescript/module/tab-bar/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/shared.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAWvD,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,4EAA4E;AAC5E,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,qEAAqE;AACrE,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,8DAA8D;AAC9D,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B;;;GAGG;AACH,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,WAAW,QAA0B,CAAC;AACnD,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,QAA2C,CAAC;AAC3E,eAAO,MAAM,mBAAmB,QAA6B,CAAC;AAC9D,iEAAiE;AACjE,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,uEAAuE;AACvE,eAAO,MAAM,eAAe,MAAM,CAAC;AAWnC;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;CAAwC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;CAAoB,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAM3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAC/B,WAAW,CAQb;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAe5E;AAaD,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,KAAK,EAAE,WAAW,CAAC;IACnB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,SAAS,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/shared.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAWvD,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,4EAA4E;AAC5E,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,qEAAqE;AACrE,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,8DAA8D;AAC9D,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,SAAS,KAAK,CAAC;AAC5B;;;GAGG;AACH,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,eAAO,MAAM,WAAW,QAA0B,CAAC;AACnD,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,4EAA4E;AAC5E,eAAO,MAAM,kBAAkB,QAA2C,CAAC;AAC3E,eAAO,MAAM,mBAAmB,QAA6B,CAAC;AAC9D,iEAAiE;AACjE,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,uEAAuE;AACvE,eAAO,MAAM,eAAe,MAAM,CAAC;AAGnC;;;;GAIG;AACH,eAAO,MAAM,YAAY;;;CAAwC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc;;CAAoB,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAM3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,EACnB,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAC/B,WAAW,CAQb;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAe5E;AAaD,MAAM,WAAW,kBAAkB;IACjC,yEAAyE;IACzE,KAAK,EAAE,WAAW,CAAC;IACnB;;;;;;;;;;;;OAYG;IACH,KAAK,EAAE,SAAS,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB"}

package/lib/typescript/module/tab-bar/use-footprint.d.ts

@@ -13,15 +13,19 @@
  * const footprint = useTabBarFootprint();
  *
  * <Animated.ScrollView contentContainerStyle={{ paddingBottom: footprint + 12 }} />
- * <Fab style={{ position: 'absolute', right: 16, bottom: footprint }} />
  * ```
  *
- * The value ALREADY INCLUDES the bottom safe-area inset — the bar folds the
- * inset into its own gap, so this is measured from the true window edge, not
- * from the safe area. Never write `footprint + insets.bottom`: that counts the
- * home indicator twice and strands a visible band of dead space under every
- * list (114px accounted for a 76px bar on an iOS device or PWA). Whatever you
- * add on top is your own clearance — never the inset a second time.
+ * A FAB no longer needs this hook at all — `Fab` reads the bottom edge's
+ * occupancy itself (see `layout/bottom-edge`), which is what the bar publishes
+ * this exact number to. Reach for the hook when laying out something that is not
+ * a Bloom surface.
+ *
+ * The value ALREADY INCLUDES the bottom safe-area inset — `windowEdgeGap` clears
+ * the OS's reserved band in full — so this is measured from the true window
+ * edge, not from the safe area. Never write `footprint + insets.bottom`: that
+ * counts the home indicator twice and strands a visible band of dead space under
+ * every list. Whatever you add on top is your own clearance, never the inset a
+ * second time.
  *
  * It is the EXPANDED height, deliberately. The bar minimizes while scrolling
  * down and re-expands on the way up, so measuring the minimized height would

package/lib/typescript/module/tab-bar/use-footprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-footprint.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/use-footprint.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAG3C"}
+{"version":3,"file":"use-footprint.d.ts","sourceRoot":"","sources":["../../../../src/tab-bar/use-footprint.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAO3C"}

package/lib/typescript/module/theme/color-scope/ColorScope.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColorScope.web.d.ts","sourceRoot":"","sources":["../../../../../src/theme/color-scope/ColorScope.web.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsE,MAAM,OAAO,CAAC;AAI3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAgBrD,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,yGAAyG;IACzG,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAuBD,wBAAgB,eAAe,CAAC,EAC9B,WAAW,EACX,OAAe,EACf,KAAK,EACL,QAAQ,GACT,EAAE,oBAAoB,2CAoDtB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,YAAY,GAAG,KAAK,CAAC,aAAa,CAYjF"}
+{"version":3,"file":"ColorScope.web.d.ts","sourceRoot":"","sources":["../../../../../src/theme/color-scope/ColorScope.web.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsE,MAAM,OAAO,CAAC;AAI3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAgBrD,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,WAAW,EAAE,YAAY,GAAG,SAAS,CAAC;IACtC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,yGAAyG;IACzG,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AA+BD,wBAAgB,eAAe,CAAC,EAC9B,WAAW,EACX,OAAe,EACf,KAAK,EACL,QAAQ,GACT,EAAE,oBAAoB,2CAsDtB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,YAAY,GAAG,KAAK,CAAC,aAAa,CAYjF"}

package/lib/typescript/module/toast/Positioner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Positioner.d.ts","sourceRoot":"","sources":["../../../../src/toast/Positioner.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAa/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAwB5C,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAC/B,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CA4DlE,CAAC"}
+{"version":3,"file":"Positioner.d.ts","sourceRoot":"","sources":["../../../../src/toast/Positioner.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAc/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAwB5C,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAC/B,KAAK,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CAgElE,CAAC"}

package/lib/typescript/module/toast/container-geometry.d.ts

@@ -43,19 +43,28 @@ import type { ToastPosition } from './types';
  */
 export declare const getContainerStyle: () => ViewStyle;
 /**
- * How far the stack sits from its screen edge. A falsy `offset` means "derive from
- * the safe area": `inset + 8`, or 16 when there is no inset.
+ * How far the stack sits from its screen edge.
  *
- * `Positioner` applies this over ONE of `getContainerStyle`'s four pinned edges;
- * `calculateOutsidePressableArea` reads the same numbers as a plain edge distance.
+ * The gap is the shared `windowEdgeGap` rule with the stack's own breathing room
+ * on top, so the stack clears the OS's reserved band the same way a detached
+ * sheet and the tab bar do. `offset` overrides that gap outright — it is the
+ * consumer saying where the stack goes.
+ *
+ * `bottomEdgeInset` is separate from both, and additive to either: it is not a
+ * gap preference but an OBSTRUCTION — whatever floating surface has already
+ * claimed the bottom edge (see `layout/bottom-edge`). A floating tab bar occupies
+ * ~82dp on a gesture-navigation Android device while this stack sat at 32dp, so
+ * every bottom toast rendered on top of the bar until the stack started reading
+ * it. An explicit `offset` does not excuse the stack from clearing it.
  */
-export declare const getInsetValues: ({ position, offset, safeAreaInsets, }: {
+export declare const getInsetValues: ({ position, offset, safeAreaInsets, bottomEdgeInset, }: {
     position: ToastPosition;
     offset?: number;
     safeAreaInsets?: {
         top: number;
         bottom: number;
     };
+    bottomEdgeInset?: number;
 }) => {
     top?: number;
     bottom?: number;

package/lib/typescript/module/toast/container-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"container-geometry.d.ts","sourceRoot":"","sources":["../../../../src/toast/container-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,QAAO,SASnC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,uCAI5B;IACD,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAClD,KAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAclC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,8DAM3C;IACD,QAAQ,EAAE,aAAa,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD,KAAG,SA2CH,CAAC"}
+{"version":3,"file":"container-geometry.d.ts","sourceRoot":"","sources":["../../../../src/toast/container-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,QAAO,SASnC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,wDAK5B;IACD,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,KAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAYlC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAI,8DAM3C;IACD,QAAQ,EAAE,aAAa,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAChD,KAAG,SA2CH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "1.9.2",
+  "version": "1.10.1",
   "packageManager": "bun@1.3.14",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
@@ -258,6 +258,20 @@
         "default": "./lib/commonjs/button/index.js"
       }
     },
+    "./layout": {
+      "react-native": {
+        "types": "./lib/typescript/module/layout/index.d.ts",
+        "default": "./src/layout/index.ts"
+      },
+      "import": {
+        "types": "./lib/typescript/module/layout/index.d.ts",
+        "default": "./lib/module/layout/index.js"
+      },
+      "require": {
+        "types": "./lib/typescript/commonjs/layout/index.d.ts",
+        "default": "./lib/commonjs/layout/index.js"
+      }
+    },
     "./fab": {
       "react-native": {
         "types": "./lib/typescript/module/fab/index.d.ts",

package/src/__tests__/support/collision-fixture-barrel.ts

@@ -0,0 +1,20 @@
+/**
+ * A barrel that DELIBERATELY offers one name from two declarations, so that
+ * `barrel-name-collisions.test.ts` can prove its detector fires. It reproduces
+ * the shipped `Item` shape: a star export carrying `Item` from `item/`, and an
+ * explicit re-export binding that same name to a different component.
+ *
+ * Nothing imports this at runtime. bob's `exclude` keeps it out of `lib/`, and
+ * `files: ["src", …]` does ship it inside the tarball's `src/` like the other
+ * test files there — but no entry point reaches it, so no bundler links it, and
+ * `package.json#exports` never names it.
+ *
+ * The `Card` lines below are the other half of the
+ * control: one name offered twice from ONE declaration, which the detector must
+ * stay quiet about — otherwise its cheapest fix would be deleting a legitimate
+ * redundant re-export.
+ */
+export * from '../../item';
+export { Card as Item } from '../../card';
+export { Card } from '../../card';
+export * from '../../card';

package/src/__tests__/support/constructed-style-sheets.ts

@@ -0,0 +1,68 @@
+/**
+ * A spec-shaped stand-in for constructed stylesheets, for the jsdom suites.
+ *
+ * jsdom 26 ships the `CSSStyleSheet` CONSTRUCTOR but neither `replaceSync` nor
+ * `document.adoptedStyleSheets`, so every jsdom test takes Bloom's `<style>`
+ * fallback. That makes the whole CSP-safe path — the reason
+ * `styles/adopt-style-sheet.ts` exists — invisible to jest unless a test
+ * installs the API itself. Without this, a mutation that deleted the adoption
+ * branch entirely would leave the suite green.
+ *
+ * Not collected as a suite: jest's `testMatch` wants `*.test.ts` / `*.spec.ts`.
+ */
+
+export interface FakeStyleSheet {
+  /** The CSS most recently handed to `replaceSync`. */
+  cssText: string;
+  /** How many times the sheet has been re-parsed, so a test can prove it wasn't. */
+  replaceSyncCalls: number;
+  replaceSync(css: string): void;
+}
+
+export interface ConstructedStyleSheetsHarness {
+  /** The document's adopted sheets, read live (the code reassigns the array). */
+  adopted(): readonly FakeStyleSheet[];
+  /** Drop the API again, restoring jsdom's own `CSSStyleSheet`. */
+  uninstall(): void;
+}
+
+export function installConstructedStyleSheets(): ConstructedStyleSheetsHarness {
+  class FakeCSSStyleSheet implements FakeStyleSheet {
+    cssText = '';
+    replaceSyncCalls = 0;
+
+    replaceSync(css: string): void {
+      this.cssText = css;
+      this.replaceSyncCalls += 1;
+    }
+  }
+
+  const previousConstructor = Object.getOwnPropertyDescriptor(
+    globalThis,
+    'CSSStyleSheet',
+  );
+
+  Object.defineProperty(globalThis, 'CSSStyleSheet', {
+    value: FakeCSSStyleSheet,
+    writable: true,
+    configurable: true,
+  });
+  Object.defineProperty(document, 'adoptedStyleSheets', {
+    value: [],
+    writable: true,
+    configurable: true,
+  });
+
+  return {
+    adopted: () =>
+      document.adoptedStyleSheets as unknown as readonly FakeStyleSheet[],
+    uninstall: () => {
+      Reflect.deleteProperty(document, 'adoptedStyleSheets');
+      if (previousConstructor) {
+        Object.defineProperty(globalThis, 'CSSStyleSheet', previousConstructor);
+      } else {
+        Reflect.deleteProperty(globalThis, 'CSSStyleSheet');
+      }
+    },
+  };
+}

package/src/__tests__/support/press-host.ts

@@ -0,0 +1,30 @@
+/**
+ * Pressing a component's OWN host node, and proving the component is what
+ * installed the handler being measured.
+ *
+ * `fireEvent.press` walks UP from the element it is handed to the nearest
+ * ancestor carrying an `onPress` prop, and it does not stop at host nodes — a
+ * COMPOSITE counts, because `getEventHandler` only reads `element.props`. So
+ * `<Thing onPress={fn}>` written in a test's own JSX catches the press itself.
+ * Measured on `ProfileCard`: with the handler deleted from the component the
+ * card rendered as an inert `View`, and the test still reported exactly one
+ * call. Green, and measuring nothing. Nine suites had the same shape.
+ *
+ * Asserting the host node's own `onPress` FIRST closes both halves:
+ *
+ *  - a component that installs no handler at all fails here, and
+ *  - a component that installs one which drops the caller's fails on the call
+ *    count, because `fireEvent` now finds a handler AT the node and never walks
+ *    past it to the test's own JSX.
+ *
+ * `host` must therefore be the node the component itself made pressable — the
+ * one carrying its `testID` / `accessibilityLabel` — not a `Text` deep inside
+ * it, or the walk-up is back and so is the hole.
+ */
+import { fireEvent } from '@testing-library/react-native';
+import type { ReactTestInstance } from 'react-test-renderer';
+
+export function pressHost(host: ReactTestInstance): void {
+  expect(typeof host.props.onPress).toBe('function');
+  fireEvent.press(host);
+}

package/src/__tests__/support/rendered-style.ts

@@ -0,0 +1,99 @@
+/**
+ * Reading what actually landed on a rendered node — shared by every suite that
+ * asserts the "className lands on the node the parent lays out" rule.
+ *
+ * Three components had the same two-node defect (`Button`, then `Fab` and
+ * `FrostedIconButton`), and asserting it needs the same two things each time:
+ * the HOST tree (composites do not appear in `toJSON()`, so a wrapper is only
+ * visible there) and a deep flatten of the `style` prop, because react-native-css
+ * merges a caller's class in as a `{ $$css: true, className }` descriptor
+ * ALONGSIDE the style objects rather than in a prop of its own.
+ */
+import type { ReactTestRendererJSON } from 'react-test-renderer';
+
+export type StyleEntry = Record<string, unknown>;
+
+export interface HostNode {
+  type: string;
+  props: Record<string, unknown>;
+  children: Array<HostNode | string> | null;
+}
+
+/**
+ * Deep-flatten an RN `style` prop (nested arrays, `false`/`null` holes) into the
+ * list of style objects that actually reached the node.
+ */
+export function styleEntries(style: unknown, out: StyleEntry[] = []): StyleEntry[] {
+  if (!style || typeof style !== 'object') return out;
+  if (Array.isArray(style)) {
+    for (const entry of style) styleEntries(entry, out);
+    return out;
+  }
+  out.push(style as StyleEntry);
+  return out;
+}
+
+/** Every style key/value that landed on a node, later entries winning. */
+export function resolvedStyle(style: unknown): StyleEntry {
+  return Object.assign({}, ...styleEntries(style)) as StyleEntry;
+}
+
+/** The class tokens react-native-css accepted for a node, in arrival order. */
+export function classNamesOn(style: unknown): string[] {
+  return styleEntries(style)
+    .filter((entry) => entry.$$css === true && typeof entry.className === 'string')
+    .map((entry) => String(entry.className));
+}
+
+export function isHostNode(value: unknown): value is HostNode {
+  return (
+    typeof value === 'object' && value !== null && typeof (value as HostNode).type === 'string'
+  );
+}
+
+/** Walk the HOST tree (composites are absent from `toJSON()`) for a testID. */
+export function findHost(
+  node: ReactTestRendererJSON | ReactTestRendererJSON[] | unknown,
+  testID: string,
+): HostNode | null {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      const hit = findHost(child, testID);
+      if (hit) return hit;
+    }
+    return null;
+  }
+  if (!isHostNode(node)) return null;
+  if (node.props.testID === testID) return node;
+  return findHost(node.children, testID);
+}
+
+/**
+ * Every host node in a rendered tree, in document order.
+ *
+ * The reason to walk `toJSON()` rather than `UNSAFE_root.findAll` is that the
+ * latter yields COMPOSITE instances too, so a `memo(fn)` component contributes
+ * two matches for one rendered element and every count is silently doubled —
+ * which reads as "the component rendered the thing twice", not as an artefact
+ * of the query.
+ */
+export function hostNodes(tree: unknown, out: HostNode[] = []): HostNode[] {
+  if (Array.isArray(tree)) {
+    for (const child of tree) hostNodes(child, out);
+    return out;
+  }
+  if (!isHostNode(tree)) return out;
+  out.push(tree);
+  return hostNodes(tree.children, out);
+}
+
+/**
+ * The host nodes a parent laid out. Callers assert the LENGTH themselves —
+ * "exactly one" is the property, and a helper that returned only the first would
+ * hide the second.
+ */
+export function renderedChildren(tree: unknown, hostTestID: string): HostNode[] {
+  const host = findHost(tree, hostTestID);
+  if (host === null) throw new Error(`no host rendered for testID "${hostTestID}"`);
+  return (host.children ?? []).filter(isHostNode);
+}

package/src/__tests__/support/unread-hook-fixture.ts

@@ -0,0 +1,33 @@
+/**
+ * A module that DELIBERATELY throws away one of the values a hook hands back, so
+ * `hook-subscriptions-are-read.test.ts` can prove its detector fires. It carries
+ * both halves of the control: `unreadFlag` is bound and never read, which the
+ * detector must report, and `readFlag` is bound and read, which it must stay
+ * quiet about — otherwise the cheapest way to green the gate would be deleting a
+ * binding that is doing its job.
+ *
+ * Nothing imports this at runtime. bob's `exclude` keeps it out of `lib/`, and
+ * `files: ["src", …]` does ship it inside the tarball's `src/` like the other
+ * 137 test files there — but no entry point reaches it, so no bundler links it.
+ * It is a plain `.ts` with no React import because the
+ * detector reads source, never types: a call named `use…` bound to a name is all
+ * the shape there is.
+ *
+ * The destructuring RENAMES, which is not decoration — it reproduces the shipped
+ * shape (`const { state: pressed, onIn: onPressIn } = useInteractionState()`) and
+ * it is what keeps the control honest. A hook declared in the same file as its
+ * caller mentions its own property names in its return type and its return
+ * object, and the detector counts every occurrence of a spelling as a possible
+ * read, so an unrenamed fixture would be silently unreportable for a reason no
+ * real call site has.
+ */
+
+/** Stands in for a real subscription — a hook by name, with two return values. */
+function useFixtureInteractionState(): { first: boolean; second: boolean } {
+  return { first: false, second: false };
+}
+
+export function fixtureComponentBody(): boolean {
+  const { first: readFlag, second: unreadFlag } = useFixtureInteractionState();
+  return readFlag;
+}

package/src/bottom-sheet/BottomSheetBase.tsx

@@ -27,6 +27,7 @@ import Animated, {
     withTiming,
 } from 'react-native-reanimated';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { EDGE_GAP, windowEdgeGap } from '../layout/edge';
 import { Backdrop, BACKDROP_DIM_OPACITY } from '../overlay';
 import { useTheme } from '../theme/use-theme';
 import type { BottomSheetRef, BottomSheetProps, BottomSheetShellProps, BottomSheetBaseProps } from './types';
@@ -526,21 +527,30 @@ export const BottomSheetBase = forwardRef((props: BottomSheetBaseProps, ref: Rea
         };
     }, [translateY, screenHeightSV, keyboardHeight]);
 
+    // The shared window-edge rule, resolved on the JS thread: `windowEdgeGap` is
+    // not a worklet, so the worklets below capture the number rather than call it.
+    //
+    // A detached sheet deliberately does NOT read `useBottomEdgeInset()`. It is a
+    // modal surface rendered in the portal ABOVE whatever owns the bottom edge and
+    // it covers that surface — offsetting it by a tab bar it is already hiding
+    // would float it off the bottom of the screen for nothing.
+    const detachedGap = detached ? windowEdgeGap(insets.bottom, EDGE_GAP) : 0;
+
     const sheetHeightStyle = useAnimatedStyle(() => ({
-        maxHeight: screenHeightSV.value - keyboardHeight.value - insets.top - (detached ? insets.bottom + 16 : 0),
-    }), [insets.top, insets.bottom, detached, screenHeightSV, keyboardHeight]);
+        maxHeight: screenHeightSV.value - keyboardHeight.value - insets.top - detachedGap,
+    }), [insets.top, detachedGap, screenHeightSV, keyboardHeight]);
 
     const sheetMarginStyle = useAnimatedStyle(() => {
         // Only add margin when detached, otherwise extend behind safe area
         if (detached) {
             return {
-                marginBottom: keyboardHeight.value > 0 ? 16 : insets.bottom + 16,
+                marginBottom: keyboardHeight.value > 0 ? EDGE_GAP : detachedGap,
             };
         }
         return {
             marginBottom: 0,
         };
-    }, [insets.bottom, detached, keyboardHeight]);
+    }, [detachedGap, detached, keyboardHeight]);
 
     const handleBackdropPress = useCallback(() => {
         // Always animate close on backdrop press