@oxyhq/bloom 1.9.2 → 1.10.0

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/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.0",
   "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

package/src/fab/Fab.tsx

@@ -11,6 +11,7 @@ import {
 } from 'react-native';
 import { styled } from 'react-native-css';
 
+import { useBottomEdgeInset } from '../layout/bottom-edge';
 import { useTheme } from '../theme/use-theme';
 import { animation, borderRadius } from '../styles/tokens';
 import { bloomShadowStyle } from '../design-tokens/shadows';
@@ -65,12 +66,23 @@ const HIT_SLOP = { top: 8, bottom: 8, left: 8, right: 8 } as const;
  * the nearest positioned ancestor (the consumer's column container), NOT the
  * screen — so it never escapes a constrained layout. `static` returns no
  * positioning (consumer-controlled).
+ *
+ * `bottomEdgeInset` applies to the BOTTOM axis only, and only for a bottom
+ * placement. It is not a gap preference — `offset` is that — but the height of
+ * whatever floating surface has already claimed the bottom edge, so the FAB
+ * lands above a floating tab bar instead of behind it. A z-index cannot fix that
+ * pairing: the bar's host is the last sibling of the app shell and paints over
+ * every descendant, so the FAB has to be somewhere else, not merely on top.
  */
-function placementStyle(placement: FabPlacement, offset: number): ViewStyle {
+function placementStyle(
+  placement: FabPlacement,
+  offset: number,
+  bottomEdgeInset: number,
+): ViewStyle {
   if (placement === 'static') return {};
   const style: ViewStyle = { position: 'absolute' };
   if (placement === 'bottom-right' || placement === 'bottom-left') {
-    style.bottom = offset;
+    style.bottom = offset + bottomEdgeInset;
   } else {
     style.top = offset;
   }
@@ -145,6 +157,7 @@ const FabComponent: React.FC<FabProps> = ({
   testID,
   zIndex = DEFAULT_Z_INDEX,
 }) => {
+  const bottomEdgeInset = useBottomEdgeInset();
   const theme = useTheme();
   const sizeConfig = useMemo(() => resolveSize(size), [size]);
   const isExtended = label != null && label.length > 0;
@@ -213,7 +226,7 @@ const FabComponent: React.FC<FabProps> = ({
     <AnimatedPressable
       className={className}
       style={[
-        placementStyle(placement, offset),
+        placementStyle(placement, offset, bottomEdgeInset),
         { zIndex },
         containerStyle,
         disabled && { opacity: 0.5 },

package/src/fab/Fab.web.tsx

@@ -7,6 +7,7 @@ import React, {
   type MouseEvent,
 } from 'react';
 
+import { useBottomEdgeInset } from '../layout/bottom-edge';
 import { useTheme } from '../theme/use-theme';
 import { animation, borderRadius } from '../styles/tokens';
 import { pressedSurface } from '../theme/press-colors';
@@ -121,14 +122,24 @@ const BLOOM_FAB_CSS = interactiveWebCss({
  * Horizontal placement uses `align-self` (sticky elements can't be pushed by
  * `left`/`right` the way absolute ones are) plus an inline-edge margin for the
  * `offset`. The consumer column MUST be a flex column that fills the available
- * height, and the FAB MUST be its last child — documented in the usage story.
+ * height, and the FAB MUST be its last child — documented in the usage story. *
+ * `bottomEdgeInset` applies to the BOTTOM axis only. It is not a gap preference
+ * — `offset` is that — but the height of whatever floating surface has already
+ * claimed the bottom edge, so the FAB lands above a floating tab bar instead of
+ * behind it. A z-index cannot fix that pairing: the bar's host is the last
+ * sibling of the app shell and paints over every descendant, so the FAB has to be
+ * somewhere else, not merely on top.
  */
-function placementStyle(placement: FabPlacement, offset: number): CSSProperties {
+function placementStyle(
+  placement: FabPlacement,
+  offset: number,
+  bottomEdgeInset: number,
+): CSSProperties {
   if (placement === 'static') return {};
   const style: CSSProperties = { position: 'sticky' };
   const isBottom = placement === 'bottom-right' || placement === 'bottom-left';
   if (isBottom) {
-    style.bottom = offset;
+    style.bottom = offset + bottomEdgeInset;
     // Push the FAB to the bottom of a (flex-column) container even when the
     // content is too short to scroll, so it never floats mid-column.
     style.marginTop = 'auto';
@@ -186,6 +197,7 @@ const FabWebComponent: React.FC<FabProps> = ({
   type = 'button',
 }) => {
   useInteractiveWebCss(STYLE_ID, BLOOM_FAB_CSS);
+  const bottomEdgeInset = useBottomEdgeInset();
   const theme = useTheme();
   const reactId = useId();
   const resolvedId = id ?? `bloom-fab-${reactId}`;
@@ -220,7 +232,7 @@ const FabWebComponent: React.FC<FabProps> = ({
         variantColors.foreground,
       ),
       ['--bloom-fab-press-scale' as string]: animation.pressScale,
-      ...placementStyle(placement, offset),
+      ...placementStyle(placement, offset, bottomEdgeInset),
     };
     if (isExtended) {
       const pad = sizeConfig.diameter <= 44 ? 14 : 20;

package/src/index.ts

@@ -153,6 +153,13 @@ export type {
   SurfacePromptOptions,
 } from './surfaces';
 export * from './button';
+export {
+  EDGE_GAP,
+  windowEdgeGap,
+  BottomEdgeProvider,
+  useBottomEdgeInset,
+  useClaimBottomEdge,
+} from './layout';
 export { Fab } from './fab';
 export type { FabProps, FabVariant, FabSize, FabPlacement } from './fab';
 export { FrostedIconButton } from './frosted-icon-button';