@oxyhq/bloom 0.3.3 → 0.3.5

package/lib/commonjs/fonts/FontLoader.native.js

@@ -4,11 +4,54 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.FontLoader = FontLoader;
-var _react = _interopRequireDefault(require("react"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
 var _expoFont = require("expo-font");
 var _fontAssets = require("./font-assets.js");
 var _jsxRuntime = require("react/jsx-runtime");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * React Native's `Text` exposes a static `defaultProps` for app-wide prop
+ * defaults. The public type definition omits it (it's an implementation
+ * detail, not part of the stable API), so we describe it locally rather
+ * than casting to `any`.
+ */
+
+/**
+ * Mutates `Text.defaultProps.style` so every native `<Text>` in the consuming
+ * app inherits Bloom's sans font (Inter). The Bloom family name is prepended
+ * to any existing default style so caller-provided `style` (which React
+ * applies AFTER `defaultProps.style`) still wins for overrides.
+ *
+ * Idempotent: re-invoking it after the first apply is a no-op because the
+ * first style entry will already be the Bloom default we added.
+ */
+function applyDefaultTextFont() {
+  const TextWithDefaults = _reactNative.Text;
+  const existing = TextWithDefaults.defaultProps?.style;
+  const bloomDefault = {
+    fontFamily: 'Inter'
+  };
+
+  // Detect whether we've already prepended ourselves. `existing` may be an
+  // array (multiple style fragments), a single object, a registered style
+  // number, or undefined. Only the array/object cases need inspection — if
+  // it's a number, we can't read the contents so we just prepend.
+  if (Array.isArray(existing)) {
+    const first = existing[0];
+    if (first && typeof first === 'object' && !Array.isArray(first) && first.fontFamily === bloomDefault.fontFamily) {
+      return;
+    }
+  } else if (existing && typeof existing === 'object' && existing.fontFamily === bloomDefault.fontFamily) {
+    return;
+  }
+  const nextStyle = existing == null ? bloomDefault : [bloomDefault, existing];
+  TextWithDefaults.defaultProps = {
+    ...TextWithDefaults.defaultProps,
+    style: nextStyle
+  };
+}
+
 /**
  * Native font loader. Calls `expo-font`'s `useFonts` with the Bloom font
  * asset map and gates `children` on the load result. The hook is invoked
@@ -16,6 +59,16 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
  * fonts get loaded. This keeps Hook order stable across renders and means
  * `<BloomThemeProvider fonts={false}>` still gets fonts pre-loaded if the
  * provider tree ever flips `fonts` back on.
+ *
+ * Once the bundled fonts report `loaded === true`, this component also
+ * mutates `Text.defaultProps.style` to prepend `{ fontFamily: 'Inter' }`
+ * so every native `<Text>` in the consuming app inherits Bloom's sans
+ * family without callers needing to import `<Text>` from `@oxyhq/bloom`.
+ * The mutation is gated by a `useRef` so it runs at most once per
+ * FontLoader instance, and the underlying apply is idempotent — the
+ * Bloom default is prepended to any caller `defaultProps.style`, so
+ * per-call `style` overrides (which React applies after `defaultProps`)
+ * still take precedence.
  */
 function FontLoader({
   enabled,
@@ -23,6 +76,11 @@ function FontLoader({
   children
 }) {
   const [loaded] = (0, _expoFont.useFonts)(_fontAssets.FONT_ASSETS);
+  const defaultsApplied = (0, _react.useRef)(false);
+  if (loaded && !defaultsApplied.current) {
+    defaultsApplied.current = true;
+    applyDefaultTextFont();
+  }
   if (!enabled) return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
     children: children
   });

package/lib/commonjs/fonts/FontLoader.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","_interopRequireDefault","require","_expoFont","_fontAssets","_jsxRuntime","e","__esModule","default","FontLoader","enabled","fallback","children","loaded","useFonts","FONT_ASSETS","jsx","Fragment"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.native.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAF,OAAA;AAA4C,IAAAG,WAAA,GAAAH,OAAA;AAAA,SAAAD,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAc5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAAC;EAAEC,OAAO;EAAEC,QAAQ;EAAEC;AAA0B,CAAC,EAAE;EAC3E,MAAM,CAACC,MAAM,CAAC,GAAG,IAAAC,kBAAQ,EAACC,uBAAW,CAAC;EACtC,IAAI,CAACL,OAAO,EAAE,oBAAO,IAAAL,WAAA,CAAAW,GAAA,EAAAX,WAAA,CAAAY,QAAA;IAAAL,QAAA,EAAGA;EAAQ,CAAG,CAAC;EACpC,IAAI,CAACC,MAAM,EAAE,oBAAO,IAAAR,WAAA,CAAAW,GAAA,EAAAX,WAAA,CAAAY,QAAA;IAAAL,QAAA,EAAGD,QAAQ,IAAI;EAAI,CAAG,CAAC;EAC3C,oBAAO,IAAAN,WAAA,CAAAW,GAAA,EAAAX,WAAA,CAAAY,QAAA;IAAAL,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}
+{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_expoFont","_fontAssets","_jsxRuntime","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","applyDefaultTextFont","TextWithDefaults","Text","existing","defaultProps","style","bloomDefault","fontFamily","Array","isArray","first","nextStyle","FontLoader","enabled","fallback","children","loaded","useFonts","FONT_ASSETS","defaultsApplied","useRef","current","jsx","Fragment"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.native.tsx"],"mappings":"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","ignoreList":[]}

package/lib/commonjs/theme/set-color-scheme-safe.js

@@ -7,15 +7,33 @@ exports.setColorSchemeSafe = setColorSchemeSafe;
 var _reactNative = require("react-native");
 /**
  * Safely set the color scheme via Appearance API.
- * On Android (RN 0.83+), Appearance.setColorScheme has a Kotlin non-null
- * annotation on `style`. Passing null for 'system' crashes.
- * Workaround: resolve the system preference and pass 'light'/'dark' instead.
  *
- * On react-native-web, Appearance.setColorScheme is not implemented at all
- * (it's `undefined`), which crashes with "setColorScheme is not a function".
- * Appearance.getColorScheme() still works on web, so reading the system
- * preference is fine — it's only the setter that's missing. The browser /
- * electron controls the color scheme anyway, so we just bail out on web.
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
  */
 function setColorSchemeSafe(mode) {
   if (_reactNative.Platform.OS === 'web') {
@@ -23,10 +41,14 @@ function setColorSchemeSafe(mode) {
   }
   const effectiveMode = mode === 'adaptive' ? 'system' : mode;
   if (effectiveMode === 'system') {
-    const resolved = _reactNative.Appearance.getColorScheme() ?? 'light';
-    _reactNative.Appearance.setColorScheme(resolved);
-  } else {
-    _reactNative.Appearance.setColorScheme(effectiveMode);
+    // Clear any prior app-level override so useColorScheme() tracks the
+    // OS. iOS honors 'unspecified' as a sentinel to fall back to the
+    // system preference; Android does not (see note above).
+    if (_reactNative.Platform.OS === 'ios') {
+      _reactNative.Appearance.setColorScheme('unspecified');
+    }
+    return;
   }
+  _reactNative.Appearance.setColorScheme(effectiveMode);
 }
 //# sourceMappingURL=set-color-scheme-safe.js.map

package/lib/commonjs/theme/set-color-scheme-safe.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","setColorSchemeSafe","mode","Platform","OS","effectiveMode","resolved","Appearance","getColorScheme","setColorScheme"],"sourceRoot":"../../../src","sources":["theme/set-color-scheme-safe.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,kBAAkBA,CAACC,IAAe,EAAE;EAClD,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;IACzB;EACF;EAEA,MAAMC,aAAa,GAAGH,IAAI,KAAK,UAAU,GAAG,QAAQ,GAAGA,IAAI;EAC3D,IAAIG,aAAa,KAAK,QAAQ,EAAE;IAC9B,MAAMC,QAAQ,GAAGC,uBAAU,CAACC,cAAc,CAAC,CAAC,IAAI,OAAO;IACvDD,uBAAU,CAACE,cAAc,CAACH,QAAQ,CAAC;EACrC,CAAC,MAAM;IACLC,uBAAU,CAACE,cAAc,CAACJ,aAAa,CAAC;EAC1C;AACF","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","setColorSchemeSafe","mode","Platform","OS","effectiveMode","Appearance","setColorScheme"],"sourceRoot":"../../../src","sources":["theme/set-color-scheme-safe.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,kBAAkBA,CAACC,IAAe,EAAE;EAClD,IAAIC,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;IACzB;EACF;EAEA,MAAMC,aAAa,GAAGH,IAAI,KAAK,UAAU,GAAG,QAAQ,GAAGA,IAAI;EAE3D,IAAIG,aAAa,KAAK,QAAQ,EAAE;IAC9B;IACA;IACA;IACA,IAAIF,qBAAQ,CAACC,EAAE,KAAK,KAAK,EAAE;MACzBE,uBAAU,CAACC,cAAc,CAAC,aAAa,CAAC;IAC1C;IACA;EACF;EAEAD,uBAAU,CAACC,cAAc,CAACF,aAAa,CAAC;AAC1C","ignoreList":[]}

package/lib/module/fonts/FontLoader.native.js

@@ -1,9 +1,52 @@
 "use strict";
 
-import React from 'react';
+import React, { useRef } from 'react';
+import { Text } from 'react-native';
 import { useFonts } from 'expo-font';
 import { FONT_ASSETS } from "./font-assets.js";
+
+/**
+ * React Native's `Text` exposes a static `defaultProps` for app-wide prop
+ * defaults. The public type definition omits it (it's an implementation
+ * detail, not part of the stable API), so we describe it locally rather
+ * than casting to `any`.
+ */
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Mutates `Text.defaultProps.style` so every native `<Text>` in the consuming
+ * app inherits Bloom's sans font (Inter). The Bloom family name is prepended
+ * to any existing default style so caller-provided `style` (which React
+ * applies AFTER `defaultProps.style`) still wins for overrides.
+ *
+ * Idempotent: re-invoking it after the first apply is a no-op because the
+ * first style entry will already be the Bloom default we added.
+ */
+function applyDefaultTextFont() {
+  const TextWithDefaults = Text;
+  const existing = TextWithDefaults.defaultProps?.style;
+  const bloomDefault = {
+    fontFamily: 'Inter'
+  };
+
+  // Detect whether we've already prepended ourselves. `existing` may be an
+  // array (multiple style fragments), a single object, a registered style
+  // number, or undefined. Only the array/object cases need inspection — if
+  // it's a number, we can't read the contents so we just prepend.
+  if (Array.isArray(existing)) {
+    const first = existing[0];
+    if (first && typeof first === 'object' && !Array.isArray(first) && first.fontFamily === bloomDefault.fontFamily) {
+      return;
+    }
+  } else if (existing && typeof existing === 'object' && existing.fontFamily === bloomDefault.fontFamily) {
+    return;
+  }
+  const nextStyle = existing == null ? bloomDefault : [bloomDefault, existing];
+  TextWithDefaults.defaultProps = {
+    ...TextWithDefaults.defaultProps,
+    style: nextStyle
+  };
+}
+
 /**
  * Native font loader. Calls `expo-font`'s `useFonts` with the Bloom font
  * asset map and gates `children` on the load result. The hook is invoked
@@ -11,6 +54,16 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
  * fonts get loaded. This keeps Hook order stable across renders and means
  * `<BloomThemeProvider fonts={false}>` still gets fonts pre-loaded if the
  * provider tree ever flips `fonts` back on.
+ *
+ * Once the bundled fonts report `loaded === true`, this component also
+ * mutates `Text.defaultProps.style` to prepend `{ fontFamily: 'Inter' }`
+ * so every native `<Text>` in the consuming app inherits Bloom's sans
+ * family without callers needing to import `<Text>` from `@oxyhq/bloom`.
+ * The mutation is gated by a `useRef` so it runs at most once per
+ * FontLoader instance, and the underlying apply is idempotent — the
+ * Bloom default is prepended to any caller `defaultProps.style`, so
+ * per-call `style` overrides (which React applies after `defaultProps`)
+ * still take precedence.
  */
 export function FontLoader({
   enabled,
@@ -18,6 +71,11 @@ export function FontLoader({
   children
 }) {
   const [loaded] = useFonts(FONT_ASSETS);
+  const defaultsApplied = useRef(false);
+  if (loaded && !defaultsApplied.current) {
+    defaultsApplied.current = true;
+    applyDefaultTextFont();
+  }
   if (!enabled) return /*#__PURE__*/_jsx(_Fragment, {
     children: children
   });

package/lib/module/fonts/FontLoader.native.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","useFonts","FONT_ASSETS","Fragment","_Fragment","jsx","_jsx","FontLoader","enabled","fallback","children","loaded"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.native.tsx"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,OAAO;AACzB,SAASC,QAAQ,QAAQ,WAAW;AACpC,SAASC,WAAW,QAAQ,kBAAe;AAAC,SAAAC,QAAA,IAAAC,SAAA,EAAAC,GAAA,IAAAC,IAAA;AAc5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAC;EAAEC,OAAO;EAAEC,QAAQ;EAAEC;AAA0B,CAAC,EAAE;EAC3E,MAAM,CAACC,MAAM,CAAC,GAAGV,QAAQ,CAACC,WAAW,CAAC;EACtC,IAAI,CAACM,OAAO,EAAE,oBAAOF,IAAA,CAAAF,SAAA;IAAAM,QAAA,EAAGA;EAAQ,CAAG,CAAC;EACpC,IAAI,CAACC,MAAM,EAAE,oBAAOL,IAAA,CAAAF,SAAA;IAAAM,QAAA,EAAGD,QAAQ,IAAI;EAAI,CAAG,CAAC;EAC3C,oBAAOH,IAAA,CAAAF,SAAA;IAAAM,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}
+{"version":3,"names":["React","useRef","Text","useFonts","FONT_ASSETS","Fragment","_Fragment","jsx","_jsx","applyDefaultTextFont","TextWithDefaults","existing","defaultProps","style","bloomDefault","fontFamily","Array","isArray","first","nextStyle","FontLoader","enabled","fallback","children","loaded","defaultsApplied","current"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.native.tsx"],"mappings":";;AAAA,OAAOA,KAAK,IAAIC,MAAM,QAAQ,OAAO;AACrC,SAASC,IAAI,QAAwD,cAAc;AACnF,SAASC,QAAQ,QAAQ,WAAW;AACpC,SAASC,WAAW,QAAQ,kBAAe;;AAc3C;AACA;AACA;AACA;AACA;AACA;AALA,SAAAC,QAAA,IAAAC,SAAA,EAAAC,GAAA,IAAAC,IAAA;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASC,oBAAoBA,CAAA,EAAS;EACpC,MAAMC,gBAAgB,GAAGR,IAAwB;EACjD,MAAMS,QAAQ,GAAGD,gBAAgB,CAACE,YAAY,EAAEC,KAAK;EACrD,MAAMC,YAAuB,GAAG;IAAEC,UAAU,EAAE;EAAQ,CAAC;;EAEvD;EACA;EACA;EACA;EACA,IAAIC,KAAK,CAACC,OAAO,CAACN,QAAQ,CAAC,EAAE;IAC3B,MAAMO,KAAK,GAAGP,QAAQ,CAAC,CAAC,CAAC;IACzB,IACEO,KAAK,IACL,OAAOA,KAAK,KAAK,QAAQ,IACzB,CAACF,KAAK,CAACC,OAAO,CAACC,KAAK,CAAC,IACpBA,KAAK,CAAeH,UAAU,KAAKD,YAAY,CAACC,UAAU,EAC3D;MACA;IACF;EACF,CAAC,MAAM,IACLJ,QAAQ,IACR,OAAOA,QAAQ,KAAK,QAAQ,IAC3BA,QAAQ,CAAeI,UAAU,KAAKD,YAAY,CAACC,UAAU,EAC9D;IACA;EACF;EAEA,MAAMI,SAA+B,GACnCR,QAAQ,IAAI,IAAI,GAAGG,YAAY,GAAG,CAACA,YAAY,EAAEH,QAAQ,CAAC;EAE5DD,gBAAgB,CAACE,YAAY,GAAG;IAC9B,GAAGF,gBAAgB,CAACE,YAAY;IAChCC,KAAK,EAAEM;EACT,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAC;EAAEC,OAAO;EAAEC,QAAQ;EAAEC;AAA0B,CAAC,EAAE;EAC3E,MAAM,CAACC,MAAM,CAAC,GAAGrB,QAAQ,CAACC,WAAW,CAAC;EACtC,MAAMqB,eAAe,GAAGxB,MAAM,CAAC,KAAK,CAAC;EAErC,IAAIuB,MAAM,IAAI,CAACC,eAAe,CAACC,OAAO,EAAE;IACtCD,eAAe,CAACC,OAAO,GAAG,IAAI;IAC9BjB,oBAAoB,CAAC,CAAC;EACxB;EAEA,IAAI,CAACY,OAAO,EAAE,oBAAOb,IAAA,CAAAF,SAAA;IAAAiB,QAAA,EAAGA;EAAQ,CAAG,CAAC;EACpC,IAAI,CAACC,MAAM,EAAE,oBAAOhB,IAAA,CAAAF,SAAA;IAAAiB,QAAA,EAAGD,QAAQ,IAAI;EAAI,CAAG,CAAC;EAC3C,oBAAOd,IAAA,CAAAF,SAAA;IAAAiB,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/module/theme/set-color-scheme-safe.js

@@ -3,15 +3,33 @@
 import { Appearance, Platform } from 'react-native';
 /**
  * Safely set the color scheme via Appearance API.
- * On Android (RN 0.83+), Appearance.setColorScheme has a Kotlin non-null
- * annotation on `style`. Passing null for 'system' crashes.
- * Workaround: resolve the system preference and pass 'light'/'dark' instead.
  *
- * On react-native-web, Appearance.setColorScheme is not implemented at all
- * (it's `undefined`), which crashes with "setColorScheme is not a function".
- * Appearance.getColorScheme() still works on web, so reading the system
- * preference is fine — it's only the setter that's missing. The browser /
- * electron controls the color scheme anyway, so we just bail out on web.
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
  */
 export function setColorSchemeSafe(mode) {
   if (Platform.OS === 'web') {
@@ -19,10 +37,14 @@ export function setColorSchemeSafe(mode) {
   }
   const effectiveMode = mode === 'adaptive' ? 'system' : mode;
   if (effectiveMode === 'system') {
-    const resolved = Appearance.getColorScheme() ?? 'light';
-    Appearance.setColorScheme(resolved);
-  } else {
-    Appearance.setColorScheme(effectiveMode);
+    // Clear any prior app-level override so useColorScheme() tracks the
+    // OS. iOS honors 'unspecified' as a sentinel to fall back to the
+    // system preference; Android does not (see note above).
+    if (Platform.OS === 'ios') {
+      Appearance.setColorScheme('unspecified');
+    }
+    return;
   }
+  Appearance.setColorScheme(effectiveMode);
 }
 //# sourceMappingURL=set-color-scheme-safe.js.map

package/lib/module/theme/set-color-scheme-safe.js.map

@@ -1 +1 @@
-{"version":3,"names":["Appearance","Platform","setColorSchemeSafe","mode","OS","effectiveMode","resolved","getColorScheme","setColorScheme"],"sourceRoot":"../../../src","sources":["theme/set-color-scheme-safe.ts"],"mappings":";;AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,cAAc;AAGnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAACC,IAAe,EAAE;EAClD,IAAIF,QAAQ,CAACG,EAAE,KAAK,KAAK,EAAE;IACzB;EACF;EAEA,MAAMC,aAAa,GAAGF,IAAI,KAAK,UAAU,GAAG,QAAQ,GAAGA,IAAI;EAC3D,IAAIE,aAAa,KAAK,QAAQ,EAAE;IAC9B,MAAMC,QAAQ,GAAGN,UAAU,CAACO,cAAc,CAAC,CAAC,IAAI,OAAO;IACvDP,UAAU,CAACQ,cAAc,CAACF,QAAQ,CAAC;EACrC,CAAC,MAAM;IACLN,UAAU,CAACQ,cAAc,CAACH,aAAa,CAAC;EAC1C;AACF","ignoreList":[]}
+{"version":3,"names":["Appearance","Platform","setColorSchemeSafe","mode","OS","effectiveMode","setColorScheme"],"sourceRoot":"../../../src","sources":["theme/set-color-scheme-safe.ts"],"mappings":";;AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,cAAc;AAGnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,kBAAkBA,CAACC,IAAe,EAAE;EAClD,IAAIF,QAAQ,CAACG,EAAE,KAAK,KAAK,EAAE;IACzB;EACF;EAEA,MAAMC,aAAa,GAAGF,IAAI,KAAK,UAAU,GAAG,QAAQ,GAAGA,IAAI;EAE3D,IAAIE,aAAa,KAAK,QAAQ,EAAE;IAC9B;IACA;IACA;IACA,IAAIJ,QAAQ,CAACG,EAAE,KAAK,KAAK,EAAE;MACzBJ,UAAU,CAACM,cAAc,CAAC,aAAa,CAAC;IAC1C;IACA;EACF;EAEAN,UAAU,CAACM,cAAc,CAACD,aAAa,CAAC;AAC1C","ignoreList":[]}

package/lib/typescript/commonjs/fonts/FontLoader.native.d.ts

@@ -17,6 +17,16 @@ export interface FontLoaderProps {
  * fonts get loaded. This keeps Hook order stable across renders and means
  * `<BloomThemeProvider fonts={false}>` still gets fonts pre-loaded if the
  * provider tree ever flips `fonts` back on.
+ *
+ * Once the bundled fonts report `loaded === true`, this component also
+ * mutates `Text.defaultProps.style` to prepend `{ fontFamily: 'Inter' }`
+ * so every native `<Text>` in the consuming app inherits Bloom's sans
+ * family without callers needing to import `<Text>` from `@oxyhq/bloom`.
+ * The mutation is gated by a `useRef` so it runs at most once per
+ * FontLoader instance, and the underlying apply is idempotent — the
+ * Bloom default is prepended to any caller `defaultProps.style`, so
+ * per-call `style` overrides (which React applies after `defaultProps`)
+ * still take precedence.
  */
 export declare function FontLoader({ enabled, fallback, children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=FontLoader.native.d.ts.map

package/lib/typescript/commonjs/fonts/FontLoader.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FontLoader.native.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAK1E"}
+{"version":3,"file":"FontLoader.native.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAKtC,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAyDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAY1E"}

package/lib/typescript/commonjs/theme/set-color-scheme-safe.d.ts

@@ -1,15 +1,33 @@
 import type { ThemeMode } from './types';
 /**
  * Safely set the color scheme via Appearance API.
- * On Android (RN 0.83+), Appearance.setColorScheme has a Kotlin non-null
- * annotation on `style`. Passing null for 'system' crashes.
- * Workaround: resolve the system preference and pass 'light'/'dark' instead.
- *
- * On react-native-web, Appearance.setColorScheme is not implemented at all
- * (it's `undefined`), which crashes with "setColorScheme is not a function".
- * Appearance.getColorScheme() still works on web, so reading the system
- * preference is fine — it's only the setter that's missing. The browser /
- * electron controls the color scheme anyway, so we just bail out on web.
+ *
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
  */
 export declare function setColorSchemeSafe(mode: ThemeMode): void;
 //# sourceMappingURL=set-color-scheme-safe.d.ts.map

package/lib/typescript/commonjs/theme/set-color-scheme-safe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-color-scheme-safe.d.ts","sourceRoot":"","sources":["../../../../src/theme/set-color-scheme-safe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,QAYjD"}
+{"version":3,"file":"set-color-scheme-safe.d.ts","sourceRoot":"","sources":["../../../../src/theme/set-color-scheme-safe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,QAkBjD"}

package/lib/typescript/module/fonts/FontLoader.native.d.ts

@@ -17,6 +17,16 @@ export interface FontLoaderProps {
  * fonts get loaded. This keeps Hook order stable across renders and means
  * `<BloomThemeProvider fonts={false}>` still gets fonts pre-loaded if the
  * provider tree ever flips `fonts` back on.
+ *
+ * Once the bundled fonts report `loaded === true`, this component also
+ * mutates `Text.defaultProps.style` to prepend `{ fontFamily: 'Inter' }`
+ * so every native `<Text>` in the consuming app inherits Bloom's sans
+ * family without callers needing to import `<Text>` from `@oxyhq/bloom`.
+ * The mutation is gated by a `useRef` so it runs at most once per
+ * FontLoader instance, and the underlying apply is idempotent — the
+ * Bloom default is prepended to any caller `defaultProps.style`, so
+ * per-call `style` overrides (which React applies after `defaultProps`)
+ * still take precedence.
  */
 export declare function FontLoader({ enabled, fallback, children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=FontLoader.native.d.ts.map

package/lib/typescript/module/fonts/FontLoader.native.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FontLoader.native.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAK1E"}
+{"version":3,"file":"FontLoader.native.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.native.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAKtC,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAyDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAY1E"}

package/lib/typescript/module/theme/set-color-scheme-safe.d.ts

@@ -1,15 +1,33 @@
 import type { ThemeMode } from './types';
 /**
  * Safely set the color scheme via Appearance API.
- * On Android (RN 0.83+), Appearance.setColorScheme has a Kotlin non-null
- * annotation on `style`. Passing null for 'system' crashes.
- * Workaround: resolve the system preference and pass 'light'/'dark' instead.
- *
- * On react-native-web, Appearance.setColorScheme is not implemented at all
- * (it's `undefined`), which crashes with "setColorScheme is not a function".
- * Appearance.getColorScheme() still works on web, so reading the system
- * preference is fine — it's only the setter that's missing. The browser /
- * electron controls the color scheme anyway, so we just bail out on web.
+ *
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
  */
 export declare function setColorSchemeSafe(mode: ThemeMode): void;
 //# sourceMappingURL=set-color-scheme-safe.d.ts.map

package/lib/typescript/module/theme/set-color-scheme-safe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-color-scheme-safe.d.ts","sourceRoot":"","sources":["../../../../src/theme/set-color-scheme-safe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,QAYjD"}
+{"version":3,"file":"set-color-scheme-safe.d.ts","sourceRoot":"","sources":["../../../../src/theme/set-color-scheme-safe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,QAkBjD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxyhq/bloom",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Bloom UI — Oxy ecosystem component library for React Native + Expo + Web",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/src/__tests__/FontLoader.native.test.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Text } from 'react-native';
+import { Text, type TextProps } from 'react-native';
 import { render } from '@testing-library/react-native';
 
 type UseFontsResult = readonly [boolean, Error | null];
@@ -16,9 +16,22 @@ function setUseFontsResult(result: UseFontsResult): void {
   mockUseFontsResult = result;
 }
 
+type TextWithDefaults = typeof Text & {
+  defaultProps?: Partial<TextProps>;
+};
+
+function resetTextDefaults(): void {
+  (Text as TextWithDefaults).defaultProps = undefined;
+}
+
 describe('FontLoader (native)', () => {
+  beforeEach(() => {
+    resetTextDefaults();
+  });
+
   afterEach(() => {
     setUseFontsResult([true, null]);
+    resetTextDefaults();
   });
 
   it('renders children when fonts are loaded and enabled', () => {
@@ -72,4 +85,62 @@ describe('FontLoader (native)', () => {
     );
     expect(getByText('content')).toBeTruthy();
   });
+
+  it('prepends Inter to Text.defaultProps.style once fonts are loaded', () => {
+    setUseFontsResult([true, null]);
+    render(
+      <FontLoader enabled>
+        <Text>content</Text>
+      </FontLoader>,
+    );
+    const defaults = (Text as TextWithDefaults).defaultProps;
+    expect(defaults?.style).toEqual({ fontFamily: 'Inter' });
+  });
+
+  it('does not touch Text.defaultProps until fonts are loaded', () => {
+    setUseFontsResult([false, null]);
+    render(
+      <FontLoader enabled>
+        <Text>content</Text>
+      </FontLoader>,
+    );
+    expect((Text as TextWithDefaults).defaultProps?.style).toBeUndefined();
+  });
+
+  it('preserves a pre-existing default style by appending it after Inter', () => {
+    const preExisting = { color: '#abcdef' } as const;
+    (Text as TextWithDefaults).defaultProps = { style: preExisting };
+    setUseFontsResult([true, null]);
+    render(
+      <FontLoader enabled>
+        <Text>content</Text>
+      </FontLoader>,
+    );
+    const style = (Text as TextWithDefaults).defaultProps?.style;
+    expect(Array.isArray(style)).toBe(true);
+    if (Array.isArray(style)) {
+      expect(style[0]).toEqual({ fontFamily: 'Inter' });
+      expect(style[1]).toBe(preExisting);
+    }
+  });
+
+  it('is idempotent across multiple FontLoader mounts', () => {
+    setUseFontsResult([true, null]);
+    const first = render(
+      <FontLoader enabled>
+        <Text>first</Text>
+      </FontLoader>,
+    );
+    first.unmount();
+    const second = render(
+      <FontLoader enabled>
+        <Text>second</Text>
+      </FontLoader>,
+    );
+    second.unmount();
+    const style = (Text as TextWithDefaults).defaultProps?.style;
+    // Should still be the single, plain Inter object — not nested arrays
+    // or duplicated entries.
+    expect(style).toEqual({ fontFamily: 'Inter' });
+  });
 });

package/src/fonts/FontLoader.native.tsx

@@ -1,4 +1,5 @@
-import React from 'react';
+import React, { useRef } from 'react';
+import { Text, type TextProps, type TextStyle, type StyleProp } from 'react-native';
 import { useFonts } from 'expo-font';
 import { FONT_ASSETS } from './font-assets';
 
@@ -14,6 +15,61 @@ export interface FontLoaderProps {
   children: React.ReactNode;
 }
 
+/**
+ * React Native's `Text` exposes a static `defaultProps` for app-wide prop
+ * defaults. The public type definition omits it (it's an implementation
+ * detail, not part of the stable API), so we describe it locally rather
+ * than casting to `any`.
+ */
+type TextWithDefaults = typeof Text & {
+  defaultProps?: Partial<TextProps>;
+};
+
+/**
+ * Mutates `Text.defaultProps.style` so every native `<Text>` in the consuming
+ * app inherits Bloom's sans font (Inter). The Bloom family name is prepended
+ * to any existing default style so caller-provided `style` (which React
+ * applies AFTER `defaultProps.style`) still wins for overrides.
+ *
+ * Idempotent: re-invoking it after the first apply is a no-op because the
+ * first style entry will already be the Bloom default we added.
+ */
+function applyDefaultTextFont(): void {
+  const TextWithDefaults = Text as TextWithDefaults;
+  const existing = TextWithDefaults.defaultProps?.style;
+  const bloomDefault: TextStyle = { fontFamily: 'Inter' };
+
+  // Detect whether we've already prepended ourselves. `existing` may be an
+  // array (multiple style fragments), a single object, a registered style
+  // number, or undefined. Only the array/object cases need inspection — if
+  // it's a number, we can't read the contents so we just prepend.
+  if (Array.isArray(existing)) {
+    const first = existing[0];
+    if (
+      first &&
+      typeof first === 'object' &&
+      !Array.isArray(first) &&
+      (first as TextStyle).fontFamily === bloomDefault.fontFamily
+    ) {
+      return;
+    }
+  } else if (
+    existing &&
+    typeof existing === 'object' &&
+    (existing as TextStyle).fontFamily === bloomDefault.fontFamily
+  ) {
+    return;
+  }
+
+  const nextStyle: StyleProp<TextStyle> =
+    existing == null ? bloomDefault : [bloomDefault, existing];
+
+  TextWithDefaults.defaultProps = {
+    ...TextWithDefaults.defaultProps,
+    style: nextStyle,
+  };
+}
+
 /**
  * Native font loader. Calls `expo-font`'s `useFonts` with the Bloom font
  * asset map and gates `children` on the load result. The hook is invoked
@@ -21,9 +77,26 @@ export interface FontLoaderProps {
  * fonts get loaded. This keeps Hook order stable across renders and means
  * `<BloomThemeProvider fonts={false}>` still gets fonts pre-loaded if the
  * provider tree ever flips `fonts` back on.
+ *
+ * Once the bundled fonts report `loaded === true`, this component also
+ * mutates `Text.defaultProps.style` to prepend `{ fontFamily: 'Inter' }`
+ * so every native `<Text>` in the consuming app inherits Bloom's sans
+ * family without callers needing to import `<Text>` from `@oxyhq/bloom`.
+ * The mutation is gated by a `useRef` so it runs at most once per
+ * FontLoader instance, and the underlying apply is idempotent — the
+ * Bloom default is prepended to any caller `defaultProps.style`, so
+ * per-call `style` overrides (which React applies after `defaultProps`)
+ * still take precedence.
  */
 export function FontLoader({ enabled, fallback, children }: FontLoaderProps) {
   const [loaded] = useFonts(FONT_ASSETS);
+  const defaultsApplied = useRef(false);
+
+  if (loaded && !defaultsApplied.current) {
+    defaultsApplied.current = true;
+    applyDefaultTextFont();
+  }
+
   if (!enabled) return <>{children}</>;
   if (!loaded) return <>{fallback ?? null}</>;
   return <>{children}</>;

package/src/theme/set-color-scheme-safe.ts

@@ -3,15 +3,33 @@ import type { ThemeMode } from './types';
 
 /**
  * Safely set the color scheme via Appearance API.
- * On Android (RN 0.83+), Appearance.setColorScheme has a Kotlin non-null
- * annotation on `style`. Passing null for 'system' crashes.
- * Workaround: resolve the system preference and pass 'light'/'dark' instead.
  *
- * On react-native-web, Appearance.setColorScheme is not implemented at all
- * (it's `undefined`), which crashes with "setColorScheme is not a function".
- * Appearance.getColorScheme() still works on web, so reading the system
- * preference is fine — it's only the setter that's missing. The browser /
- * electron controls the color scheme anyway, so we just bail out on web.
+ * Behavior by mode:
+ * - 'light' / 'dark': set the explicit override.
+ * - 'system' / 'adaptive': leave the OS in control. We must NOT call
+ *   Appearance.setColorScheme(resolved) here — doing so installs an
+ *   app-level override that masks the OS preference. Once that override
+ *   is set, useColorScheme() / Appearance.getColorScheme() return the
+ *   frozen override instead of the live OS value, and the app stops
+ *   following dark↔light OS toggles until a cold restart.
+ *
+ *   On iOS we additionally pass 'unspecified' to clear any prior
+ *   override that may have been installed by a previous explicit mode.
+ *   'unspecified' is the documented sentinel that tells the native
+ *   Appearance module to fall back to the OS preference. (RN's JS
+ *   implementation forwards this straight through to the native
+ *   bridge; on iOS this clears the override.)
+ *
+ *   On Android (RN 0.83+) the native Kotlin signature has @NonNull on
+ *   `style` and rejects null, and 'unspecified' is not honored as a
+ *   clear-override sentinel on Android either. As a result, if a user
+ *   previously selected 'light' or 'dark' and then switches back to
+ *   'system' on Android, the override remains until the next cold
+ *   restart. Users who never explicitly overrode are unaffected because
+ *   we never install an override in system mode in the first place.
+ *
+ * On react-native-web, Appearance.setColorScheme is not implemented at
+ * all; the browser controls the color scheme, so we bail out on web.
  */
 export function setColorSchemeSafe(mode: ThemeMode) {
   if (Platform.OS === 'web') {
@@ -19,10 +37,16 @@ export function setColorSchemeSafe(mode: ThemeMode) {
   }
 
   const effectiveMode = mode === 'adaptive' ? 'system' : mode;
+
   if (effectiveMode === 'system') {
-    const resolved = Appearance.getColorScheme() ?? 'light';
-    Appearance.setColorScheme(resolved);
-  } else {
-    Appearance.setColorScheme(effectiveMode);
+    // Clear any prior app-level override so useColorScheme() tracks the
+    // OS. iOS honors 'unspecified' as a sentinel to fall back to the
+    // system preference; Android does not (see note above).
+    if (Platform.OS === 'ios') {
+      Appearance.setColorScheme('unspecified');
+    }
+    return;
   }
+
+  Appearance.setColorScheme(effectiveMode);
 }