@oxyhq/bloom 0.71.0 → 0.72.1

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FontLoader = FontLoader;
+var _react = _interopRequireDefault(require("react"));
+var _jsxRuntime = require("react/jsx-runtime");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+function FontLoader({
+  children
+}) {
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_jsxRuntime.Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=FontLoader.node.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_react","_interopRequireDefault","require","_jsxRuntime","e","__esModule","default","FontLoader","children","jsx","Fragment"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.node.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA0B,IAAAC,WAAA,GAAAD,OAAA;AAAA,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAU1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,UAAUA,CAAC;EAAEC;AAA0B,CAAC,EAAE;EACxD,oBAAO,IAAAL,WAAA,CAAAM,GAAA,EAAAN,WAAA,CAAAO,QAAA;IAAAF,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/commonjs/fonts/apply-font-faces.js

@@ -8,10 +8,11 @@ exports.applyFontFaces = applyFontFaces;
 // is selected by bundlers via the package.json conditions. RN consumers
 // never need font-face injection — useFonts handles loading on native.
 //
-// The web variant does NOT pull in any `.woff2` files via asset imports —
-// it imports base64 data URLs from `font-data.web.ts`. This stub stays
-// here so the file split (`*.ts` vs `*.web.ts`) makes the platform
-// intent explicit and so the runtime API surface matches across platforms.
+// The split is load-bearing, not decorative: the web variant reaches
+// `font-urls.web.ts`, whose module-level `.woff2` imports would otherwise
+// drag a second, unusable copy of every font into the native bundle
+// (Metro resolves an asset import on native to a registry id, not a URL).
+// Keeping this stub empty is what guarantees native pays nothing for them.
 function applyFontFaces() {
   // intentionally empty
 }

package/lib/commonjs/fonts/apply-font-faces.js.map

@@ -1 +1 @@
-{"version":3,"names":["applyFontFaces"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,cAAcA,CAAA,EAAS;EACrC;AAAA","ignoreList":[]}
+{"version":3,"names":["applyFontFaces"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,cAAcA,CAAA,EAAS;EACrC;AAAA","ignoreList":[]}

package/lib/commonjs/fonts/apply-font-faces.web.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.applyFontFaces = applyFontFaces;
-var _fontDataWeb = require("./font-data.web.js");
+var _fontUrlsWeb = require("./font-urls.web.js");
 var _tokens = require("./tokens.js");
 const STYLE_ID = 'bloom-fonts';
 
@@ -12,18 +12,16 @@ const STYLE_ID = 'bloom-fonts';
  * Inject @font-face rules and font CSS variables onto :root.
  *
  * Web-only. The native counterpart in `apply-font-faces.ts` is a no-op
- * stub — Metro cannot parse `.woff2` imports, so the file split keeps
- * the font payload out of the native bundle entirely. Idempotent: safe to
- * call multiple times; subsequent calls early-return after the
- * `<style id="bloom-fonts">` tag has been mounted. SSR-safe via the
- * `typeof document === 'undefined'` guard.
+ * stub — native loads its fonts through `useFonts(FONT_ASSETS)`, so the file
+ * split keeps the web font payload out of the native bundle entirely.
+ * Idempotent: safe to call multiple times; subsequent calls early-return
+ * after the `<style id="bloom-fonts">` tag has been mounted. SSR-safe via
+ * the `typeof document === 'undefined'` guard.
  *
- * The font URLs come from `./font-data.web`, a generated module that
- * embeds the woff2 bytes as base64 data URLs. Inlining (rather than
- * relying on bundler asset loaders for `.woff2`) means consumers do not
- * have to extend Metro's `assetExts` or add a webpack/Vite asset rule —
- * the published JS is self-contained. See `scripts/generate-font-data.mjs`
- * for the rationale and trade-offs.
+ * The URLs come from `./font-urls.web`, which imports the `.woff2` files so
+ * the consuming bundler emits them as separate, cacheable assets. See that
+ * module for the per-bundler details and for the one thing a consumer has to
+ * provide (Metro needs `woff2` in `assetExts`).
  */
 function applyFontFaces() {
   if (typeof document === 'undefined') return;
@@ -31,10 +29,10 @@ function applyFontFaces() {
   const style = document.createElement('style');
   style.id = STYLE_ID;
   style.textContent = `
-    @font-face { font-family: 'BlomusModernus'; src: url(${_fontDataWeb.blomusModernusRegular}) format('woff2'); font-weight: 400; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'BlomusModernus'; src: url(${_fontDataWeb.blomusModernusBold}) format('woff2'); font-weight: 700; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'Inter'; src: url(${_fontDataWeb.interVariable}) format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'Geist Mono'; src: url(${_fontDataWeb.geistMonoVariable}) format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'BlomusModernus'; src: url("${_fontUrlsWeb.blomusModernusRegular}") format('woff2'); font-weight: 400; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'BlomusModernus'; src: url("${_fontUrlsWeb.blomusModernusBold}") format('woff2'); font-weight: 700; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'Inter'; src: url("${_fontUrlsWeb.interVariable}") format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'Geist Mono'; src: url("${_fontUrlsWeb.geistMonoVariable}") format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
     :root {
       --bloom-font-display: ${_tokens.fontFamilies.display};
       --bloom-font-sans: ${_tokens.fontFamilies.sans};

package/lib/commonjs/fonts/apply-font-faces.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["_fontDataWeb","require","_tokens","STYLE_ID","applyFontFaces","document","getElementById","style","createElement","id","textContent","blomusModernusRegular","blomusModernusBold","interVariable","geistMonoVariable","fontFamilies","display","sans","mono","head","appendChild"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.web.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMA,IAAAC,OAAA,GAAAD,OAAA;AAEA,MAAME,QAAQ,GAAG,aAAa;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAAA,EAAS;EACrC,IAAI,OAAOC,QAAQ,KAAK,WAAW,EAAE;EACrC,IAAIA,QAAQ,CAACC,cAAc,CAACH,QAAQ,CAAC,EAAE;EAEvC,MAAMI,KAAK,GAAGF,QAAQ,CAACG,aAAa,CAAC,OAAO,CAAC;EAC7CD,KAAK,CAACE,EAAE,GAAGN,QAAQ;EACnBI,KAAK,CAACG,WAAW,GAAG;AACtB,2DAA2DC,kCAAqB;AAChF,2DAA2DC,+BAAkB;AAC7E,kDAAkDC,0BAAa;AAC/D,uDAAuDC,8BAAiB;AACxE;AACA,8BAA8BC,oBAAY,CAACC,OAAO;AAClD,2BAA2BD,oBAAY,CAACE,IAAI;AAC5C,2BAA2BF,oBAAY,CAACG,IAAI;AAC5C;AACA,GAAG;EACDb,QAAQ,CAACc,IAAI,CAACC,WAAW,CAACb,KAAK,CAAC;AAClC","ignoreList":[]}
+{"version":3,"names":["_fontUrlsWeb","require","_tokens","STYLE_ID","applyFontFaces","document","getElementById","style","createElement","id","textContent","blomusModernusRegular","blomusModernusBold","interVariable","geistMonoVariable","fontFamilies","display","sans","mono","head","appendChild"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.web.ts"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMA,IAAAC,OAAA,GAAAD,OAAA;AAEA,MAAME,QAAQ,GAAG,aAAa;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,cAAcA,CAAA,EAAS;EACrC,IAAI,OAAOC,QAAQ,KAAK,WAAW,EAAE;EACrC,IAAIA,QAAQ,CAACC,cAAc,CAACH,QAAQ,CAAC,EAAE;EAEvC,MAAMI,KAAK,GAAGF,QAAQ,CAACG,aAAa,CAAC,OAAO,CAAC;EAC7CD,KAAK,CAACE,EAAE,GAAGN,QAAQ;EACnBI,KAAK,CAACG,WAAW,GAAG;AACtB,4DAA4DC,kCAAqB;AACjF,4DAA4DC,+BAAkB;AAC9E,mDAAmDC,0BAAa;AAChE,wDAAwDC,8BAAiB;AACzE;AACA,8BAA8BC,oBAAY,CAACC,OAAO;AAClD,2BAA2BD,oBAAY,CAACE,IAAI;AAC5C,2BAA2BF,oBAAY,CAACG,IAAI;AAC5C;AACA,GAAG;EACDb,QAAQ,CAACc,IAAI,CAACC,WAAW,CAACb,KAAK,CAAC;AAClC","ignoreList":[]}

package/lib/commonjs/fonts/font-assets.web.js

@@ -8,8 +8,9 @@ exports.FONT_ASSETS = void 0;
 //
 // `useFonts()` is native-only — the web `FontLoader` (`FontLoader.tsx`) calls
 // `applyFontFaces()` instead, which injects the same four families as
-// `@font-face` rules from base64 data URLs (`apply-font-faces.web.ts` /
-// `font-data.web.ts`). So the map is empty by design, not by omission.
+// `@font-face` rules pointing at bundler-emitted `.woff2` URLs
+// (`apply-font-faces.web.ts` / `font-urls.web.ts`). So the map is empty by
+// design, not by omission.
 //
 // This file exists so `index.web.ts` can name its font-asset source
 // explicitly, exactly as it already does for `./apply-font-faces.web`. The

package/lib/commonjs/fonts/font-assets.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["FONT_ASSETS","exports"],"sourceRoot":"../../../src","sources":["fonts/font-assets.web.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGO,MAAMA,WAAyB,GAAAC,OAAA,CAAAD,WAAA,GAAG,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["FONT_ASSETS","exports"],"sourceRoot":"../../../src","sources":["fonts/font-assets.web.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGO,MAAMA,WAAyB,GAAAC,OAAA,CAAAD,WAAA,GAAG,CAAC,CAAC","ignoreList":[]}

package/lib/commonjs/fonts/font-urls.web.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "blomusModernusBold", {
+  enumerable: true,
+  get: function () {
+    return _BlomusModernusBold.default;
+  }
+});
+Object.defineProperty(exports, "blomusModernusRegular", {
+  enumerable: true,
+  get: function () {
+    return _BlomusModernusRegular.default;
+  }
+});
+Object.defineProperty(exports, "geistMonoVariable", {
+  enumerable: true,
+  get: function () {
+    return _GeistMonoVariable.default;
+  }
+});
+Object.defineProperty(exports, "interVariable", {
+  enumerable: true,
+  get: function () {
+    return _InterVariable.default;
+  }
+});
+var _BlomusModernusBold = _interopRequireDefault(require("./assets/BlomusModernus-Bold.woff2"));
+var _BlomusModernusRegular = _interopRequireDefault(require("./assets/BlomusModernus-Regular.woff2"));
+var _GeistMonoVariable = _interopRequireDefault(require("./assets/GeistMono-Variable.woff2"));
+var _InterVariable = _interopRequireDefault(require("./assets/InterVariable.woff2"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+//# sourceMappingURL=font-urls.web.js.map

package/lib/commonjs/fonts/font-urls.web.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_BlomusModernusBold","_interopRequireDefault","require","_BlomusModernusRegular","_GeistMonoVariable","_InterVariable","e","__esModule","default"],"sourceRoot":"../../../src","sources":["fonts/font-urls.web.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAAA,mBAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,sBAAA,GAAAF,sBAAA,CAAAC,OAAA;AACA,IAAAE,kBAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,cAAA,GAAAJ,sBAAA,CAAAC,OAAA;AAAyD,SAAAD,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA","ignoreList":[]}

package/lib/commonjs/fonts/index.node.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FONT_ASSETS", {
+  enumerable: true,
+  get: function () {
+    return _fontAssets.FONT_ASSETS;
+  }
+});
+Object.defineProperty(exports, "FontLoader", {
+  enumerable: true,
+  get: function () {
+    return _FontLoaderNode.FontLoader;
+  }
+});
+Object.defineProperty(exports, "applyFontFaces", {
+  enumerable: true,
+  get: function () {
+    return _applyFontFaces.applyFontFaces;
+  }
+});
+Object.defineProperty(exports, "fontCssVars", {
+  enumerable: true,
+  get: function () {
+    return _tokens.fontCssVars;
+  }
+});
+Object.defineProperty(exports, "fontFamilies", {
+  enumerable: true,
+  get: function () {
+    return _tokens.fontFamilies;
+  }
+});
+var _tokens = require("./tokens.js");
+var _applyFontFaces = require("./apply-font-faces");
+var _fontAssets = require("./font-assets");
+var _FontLoaderNode = require("./FontLoader.node.js");
+//# sourceMappingURL=index.node.js.map

package/lib/commonjs/fonts/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_tokens","require","_applyFontFaces","_fontAssets","_FontLoaderNode"],"sourceRoot":"../../../src","sources":["fonts/index.node.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA,IAAAA,OAAA,GAAAC,OAAA;AAEA,IAAAC,eAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAF,OAAA;AACA,IAAAG,eAAA,GAAAH,OAAA","ignoreList":[]}

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

@@ -0,0 +1,29 @@
+"use strict";
+
+import React from 'react';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export function FontLoader({
+  children
+}) {
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+}
+//# sourceMappingURL=FontLoader.node.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["React","Fragment","_Fragment","jsx","_jsx","FontLoader","children"],"sourceRoot":"../../../src","sources":["fonts/FontLoader.node.tsx"],"mappings":";;AAAA,OAAOA,KAAK,MAAM,OAAO;AAAC,SAAAC,QAAA,IAAAC,SAAA,EAAAC,GAAA,IAAAC,IAAA;AAU1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAC;EAAEC;AAA0B,CAAC,EAAE;EACxD,oBAAOF,IAAA,CAAAF,SAAA;IAAAI,QAAA,EAAGA;EAAQ,CAAG,CAAC;AACxB","ignoreList":[]}

package/lib/module/fonts/apply-font-faces.js

@@ -4,10 +4,11 @@
 // is selected by bundlers via the package.json conditions. RN consumers
 // never need font-face injection — useFonts handles loading on native.
 //
-// The web variant does NOT pull in any `.woff2` files via asset imports —
-// it imports base64 data URLs from `font-data.web.ts`. This stub stays
-// here so the file split (`*.ts` vs `*.web.ts`) makes the platform
-// intent explicit and so the runtime API surface matches across platforms.
+// The split is load-bearing, not decorative: the web variant reaches
+// `font-urls.web.ts`, whose module-level `.woff2` imports would otherwise
+// drag a second, unusable copy of every font into the native bundle
+// (Metro resolves an asset import on native to a registry id, not a URL).
+// Keeping this stub empty is what guarantees native pays nothing for them.
 export function applyFontFaces() {
   // intentionally empty
 }

package/lib/module/fonts/apply-font-faces.js.map

@@ -1 +1 @@
-{"version":3,"names":["applyFontFaces"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,cAAcA,CAAA,EAAS;EACrC;AAAA","ignoreList":[]}
+{"version":3,"names":["applyFontFaces"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,cAAcA,CAAA,EAAS;EACrC;AAAA","ignoreList":[]}

package/lib/module/fonts/apply-font-faces.web.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { blomusModernusRegular, blomusModernusBold, interVariable, geistMonoVariable } from "./font-data.web.js";
+import { blomusModernusRegular, blomusModernusBold, interVariable, geistMonoVariable } from "./font-urls.web.js";
 import { fontFamilies } from "./tokens.js";
 const STYLE_ID = 'bloom-fonts';
 
@@ -8,18 +8,16 @@ const STYLE_ID = 'bloom-fonts';
  * Inject @font-face rules and font CSS variables onto :root.
  *
  * Web-only. The native counterpart in `apply-font-faces.ts` is a no-op
- * stub — Metro cannot parse `.woff2` imports, so the file split keeps
- * the font payload out of the native bundle entirely. Idempotent: safe to
- * call multiple times; subsequent calls early-return after the
- * `<style id="bloom-fonts">` tag has been mounted. SSR-safe via the
- * `typeof document === 'undefined'` guard.
+ * stub — native loads its fonts through `useFonts(FONT_ASSETS)`, so the file
+ * split keeps the web font payload out of the native bundle entirely.
+ * Idempotent: safe to call multiple times; subsequent calls early-return
+ * after the `<style id="bloom-fonts">` tag has been mounted. SSR-safe via
+ * the `typeof document === 'undefined'` guard.
  *
- * The font URLs come from `./font-data.web`, a generated module that
- * embeds the woff2 bytes as base64 data URLs. Inlining (rather than
- * relying on bundler asset loaders for `.woff2`) means consumers do not
- * have to extend Metro's `assetExts` or add a webpack/Vite asset rule —
- * the published JS is self-contained. See `scripts/generate-font-data.mjs`
- * for the rationale and trade-offs.
+ * The URLs come from `./font-urls.web`, which imports the `.woff2` files so
+ * the consuming bundler emits them as separate, cacheable assets. See that
+ * module for the per-bundler details and for the one thing a consumer has to
+ * provide (Metro needs `woff2` in `assetExts`).
  */
 export function applyFontFaces() {
   if (typeof document === 'undefined') return;
@@ -27,10 +25,10 @@ export function applyFontFaces() {
   const style = document.createElement('style');
   style.id = STYLE_ID;
   style.textContent = `
-    @font-face { font-family: 'BlomusModernus'; src: url(${blomusModernusRegular}) format('woff2'); font-weight: 400; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'BlomusModernus'; src: url(${blomusModernusBold}) format('woff2'); font-weight: 700; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'Inter'; src: url(${interVariable}) format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
-    @font-face { font-family: 'Geist Mono'; src: url(${geistMonoVariable}) format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'BlomusModernus'; src: url("${blomusModernusRegular}") format('woff2'); font-weight: 400; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'BlomusModernus'; src: url("${blomusModernusBold}") format('woff2'); font-weight: 700; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'Inter'; src: url("${interVariable}") format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
+    @font-face { font-family: 'Geist Mono'; src: url("${geistMonoVariable}") format('woff2-variations'); font-weight: 100 900; font-style: normal; font-display: swap; }
     :root {
       --bloom-font-display: ${fontFamilies.display};
       --bloom-font-sans: ${fontFamilies.sans};

package/lib/module/fonts/apply-font-faces.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["blomusModernusRegular","blomusModernusBold","interVariable","geistMonoVariable","fontFamilies","STYLE_ID","applyFontFaces","document","getElementById","style","createElement","id","textContent","display","sans","mono","head","appendChild"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.web.ts"],"mappings":";;AAAA,SACEA,qBAAqB,EACrBC,kBAAkB,EAClBC,aAAa,EACbC,iBAAiB,QACZ,oBAAiB;AACxB,SAASC,YAAY,QAAQ,aAAU;AAEvC,MAAMC,QAAQ,GAAG,aAAa;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAS;EACrC,IAAI,OAAOC,QAAQ,KAAK,WAAW,EAAE;EACrC,IAAIA,QAAQ,CAACC,cAAc,CAACH,QAAQ,CAAC,EAAE;EAEvC,MAAMI,KAAK,GAAGF,QAAQ,CAACG,aAAa,CAAC,OAAO,CAAC;EAC7CD,KAAK,CAACE,EAAE,GAAGN,QAAQ;EACnBI,KAAK,CAACG,WAAW,GAAG;AACtB,2DAA2DZ,qBAAqB;AAChF,2DAA2DC,kBAAkB;AAC7E,kDAAkDC,aAAa;AAC/D,uDAAuDC,iBAAiB;AACxE;AACA,8BAA8BC,YAAY,CAACS,OAAO;AAClD,2BAA2BT,YAAY,CAACU,IAAI;AAC5C,2BAA2BV,YAAY,CAACW,IAAI;AAC5C;AACA,GAAG;EACDR,QAAQ,CAACS,IAAI,CAACC,WAAW,CAACR,KAAK,CAAC;AAClC","ignoreList":[]}
+{"version":3,"names":["blomusModernusRegular","blomusModernusBold","interVariable","geistMonoVariable","fontFamilies","STYLE_ID","applyFontFaces","document","getElementById","style","createElement","id","textContent","display","sans","mono","head","appendChild"],"sourceRoot":"../../../src","sources":["fonts/apply-font-faces.web.ts"],"mappings":";;AAAA,SACEA,qBAAqB,EACrBC,kBAAkB,EAClBC,aAAa,EACbC,iBAAiB,QACZ,oBAAiB;AACxB,SAASC,YAAY,QAAQ,aAAU;AAEvC,MAAMC,QAAQ,GAAG,aAAa;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAAA,EAAS;EACrC,IAAI,OAAOC,QAAQ,KAAK,WAAW,EAAE;EACrC,IAAIA,QAAQ,CAACC,cAAc,CAACH,QAAQ,CAAC,EAAE;EAEvC,MAAMI,KAAK,GAAGF,QAAQ,CAACG,aAAa,CAAC,OAAO,CAAC;EAC7CD,KAAK,CAACE,EAAE,GAAGN,QAAQ;EACnBI,KAAK,CAACG,WAAW,GAAG;AACtB,4DAA4DZ,qBAAqB;AACjF,4DAA4DC,kBAAkB;AAC9E,mDAAmDC,aAAa;AAChE,wDAAwDC,iBAAiB;AACzE;AACA,8BAA8BC,YAAY,CAACS,OAAO;AAClD,2BAA2BT,YAAY,CAACU,IAAI;AAC5C,2BAA2BV,YAAY,CAACW,IAAI;AAC5C;AACA,GAAG;EACDR,QAAQ,CAACS,IAAI,CAACC,WAAW,CAACR,KAAK,CAAC;AAClC","ignoreList":[]}

package/lib/module/fonts/font-assets.web.js

@@ -4,8 +4,9 @@
 //
 // `useFonts()` is native-only — the web `FontLoader` (`FontLoader.tsx`) calls
 // `applyFontFaces()` instead, which injects the same four families as
-// `@font-face` rules from base64 data URLs (`apply-font-faces.web.ts` /
-// `font-data.web.ts`). So the map is empty by design, not by omission.
+// `@font-face` rules pointing at bundler-emitted `.woff2` URLs
+// (`apply-font-faces.web.ts` / `font-urls.web.ts`). So the map is empty by
+// design, not by omission.
 //
 // This file exists so `index.web.ts` can name its font-asset source
 // explicitly, exactly as it already does for `./apply-font-faces.web`. The

package/lib/module/fonts/font-assets.web.js.map

@@ -1 +1 @@
-{"version":3,"names":["FONT_ASSETS"],"sourceRoot":"../../../src","sources":["fonts/font-assets.web.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,OAAO,MAAMA,WAAyB,GAAG,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["FONT_ASSETS"],"sourceRoot":"../../../src","sources":["fonts/font-assets.web.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,OAAO,MAAMA,WAAyB,GAAG,CAAC,CAAC","ignoreList":[]}

package/lib/module/fonts/font-urls.web.js

@@ -0,0 +1,32 @@
+"use strict";
+
+// Web font URLs, resolved by whatever bundler is building the consuming app.
+//
+// WEB-ONLY. Each import below hands the `.woff2` to the app's asset pipeline,
+// which emits it as a standalone file and gives us back its URL:
+//
+//   - Metro (Expo web) rewrites the import to the exported asset path — its
+//     asset transformer emits a bare string module whenever the platform is
+//     `web`, so the imported value is the URL itself, not an asset id.
+//   - Vite, Rollup and webpack 5 resolve it through their own asset handling
+//     and return a content-hashed URL.
+//
+// Either way the browser fetches the four families alongside the JS and caches
+// them under their own URLs, instead of re-parsing ~310 KB of base64 out of the
+// entry bundle on every cold load. No consumer ever writes an asset filename
+// down, so a font swap here cannot leave a downstream app pointing at a file
+// that no longer exists.
+//
+// Metro does not carry `woff2` in its default `assetExts`, so a consumer
+// bundling for web with Metro has to register it; `@oxyhq/app-preset`'s Metro
+// base already does that for every Oxy app.
+//
+// Native never reaches this module. The default `apply-font-faces.ts` is a
+// no-op stub and `FontLoader.native.tsx` loads the `.ttf` variants through
+// `useFonts` instead, so no web font bytes enter a native bundle.
+import blomusModernusBold from './assets/BlomusModernus-Bold.woff2';
+import blomusModernusRegular from './assets/BlomusModernus-Regular.woff2';
+import geistMonoVariable from './assets/GeistMono-Variable.woff2';
+import interVariable from './assets/InterVariable.woff2';
+export { blomusModernusRegular, blomusModernusBold, interVariable, geistMonoVariable };
+//# sourceMappingURL=font-urls.web.js.map

package/lib/module/fonts/font-urls.web.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["blomusModernusBold","blomusModernusRegular","geistMonoVariable","interVariable"],"sourceRoot":"../../../src","sources":["fonts/font-urls.web.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAOA,kBAAkB,MAAM,oCAAoC;AACnE,OAAOC,qBAAqB,MAAM,uCAAuC;AACzE,OAAOC,iBAAiB,MAAM,mCAAmC;AACjE,OAAOC,aAAa,MAAM,8BAA8B;AAExD,SAASF,qBAAqB,EAAED,kBAAkB,EAAEG,aAAa,EAAED,iBAAiB","ignoreList":[]}

package/lib/module/fonts/index.node.js

@@ -0,0 +1,22 @@
+"use strict";
+
+// Node variant of the `./fonts` barrel, selected by the `node` export
+// condition. Same surface as `./index.ts`, with every member resolved to the
+// inert implementation:
+//
+// - `./apply-font-faces` is the no-op stub. The web one is unreachable here on
+//   purpose: it imports `font-urls.web`, whose `.woff2` imports Node feeds to
+//   the JS parser, so loading it throws `SyntaxError` before any runtime guard
+//   can help.
+// - `./font-assets` is the empty map — there is no native font registry.
+// - `./FontLoader.node` renders children and nothing else.
+//
+// Both platform-forked members are named OUTRIGHT rather than left
+// extensionless, for the same reason `index.web.ts` does it: Node performs no
+// platform-extension resolution, so a bare specifier would fall through to
+// whichever file happens to sit at that path.
+export { fontFamilies, fontCssVars } from "./tokens.js";
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from "./FontLoader.node.js";
+//# sourceMappingURL=index.node.js.map

package/lib/module/fonts/index.node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["fontFamilies","fontCssVars","applyFontFaces","FONT_ASSETS","FontLoader"],"sourceRoot":"../../../src","sources":["fonts/index.node.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASA,YAAY,EAAEC,WAAW,QAAQ,aAAU;AAEpD,SAASC,cAAc,QAAQ,oBAAoB;AACnD,SAASC,WAAW,QAAQ,eAAe;AAC3C,SAASC,UAAU,QAAQ,sBAAmB","ignoreList":[]}

package/lib/module/fonts/index.web.js

@@ -8,9 +8,9 @@
 // of the box), so an extensionless specifier here would quietly fall through
 // to the default file.
 //
-// - `./apply-font-faces.web` performs the real `@font-face` injection using
-//   inlined base64 data URLs (see `font-data.web.ts`); the default
-//   `./apply-font-faces` is a no-op stub for native.
+// - `./apply-font-faces.web` performs the real `@font-face` injection against
+//   the `.woff2` URLs the consuming bundler emits (see `font-urls.web.ts`);
+//   the default `./apply-font-faces` is a no-op stub for native.
 // - `./font-assets.web` is an empty map. The native map is built from Metro
 //   asset `require()` calls, and importing it from an ES module throws
 //   `ReferenceError: require is not defined` during module evaluation — which

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

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface FontLoaderProps {
+    /** Ignored — there is nothing to load. Kept so the API matches every platform. */
+    enabled: boolean;
+    /** Ignored — nothing is ever pending, so children render immediately. */
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export declare function FontLoader({ children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FontLoader.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontLoader.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.node.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAEvD"}

package/lib/typescript/commonjs/fonts/apply-font-faces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-font-faces.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,IAAI,IAAI,CAErC"}
+{"version":3,"file":"apply-font-faces.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.ts"],"names":[],"mappings":"AASA,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/lib/typescript/commonjs/fonts/apply-font-faces.web.d.ts

@@ -2,18 +2,16 @@
  * Inject @font-face rules and font CSS variables onto :root.
  *
  * Web-only. The native counterpart in `apply-font-faces.ts` is a no-op
- * stub — Metro cannot parse `.woff2` imports, so the file split keeps
- * the font payload out of the native bundle entirely. Idempotent: safe to
- * call multiple times; subsequent calls early-return after the
- * `<style id="bloom-fonts">` tag has been mounted. SSR-safe via the
- * `typeof document === 'undefined'` guard.
+ * stub — native loads its fonts through `useFonts(FONT_ASSETS)`, so the file
+ * split keeps the web font payload out of the native bundle entirely.
+ * Idempotent: safe to call multiple times; subsequent calls early-return
+ * after the `<style id="bloom-fonts">` tag has been mounted. SSR-safe via
+ * the `typeof document === 'undefined'` guard.
  *
- * The font URLs come from `./font-data.web`, a generated module that
- * embeds the woff2 bytes as base64 data URLs. Inlining (rather than
- * relying on bundler asset loaders for `.woff2`) means consumers do not
- * have to extend Metro's `assetExts` or add a webpack/Vite asset rule —
- * the published JS is self-contained. See `scripts/generate-font-data.mjs`
- * for the rationale and trade-offs.
+ * The URLs come from `./font-urls.web`, which imports the `.woff2` files so
+ * the consuming bundler emits them as separate, cacheable assets. See that
+ * module for the per-bundler details and for the one thing a consumer has to
+ * provide (Metro needs `woff2` in `assetExts`).
  */
 export declare function applyFontFaces(): void;
 //# sourceMappingURL=apply-font-faces.web.d.ts.map

package/lib/typescript/commonjs/fonts/apply-font-faces.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-font-faces.web.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.web.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAkBrC"}
+{"version":3,"file":"apply-font-faces.web.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.web.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAkBrC"}

package/lib/typescript/commonjs/fonts/font-assets.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"font-assets.web.d.ts","sourceRoot":"","sources":["../../../../src/fonts/font-assets.web.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,WAAW,EAAE,YAAiB,CAAC"}
+{"version":3,"file":"font-assets.web.d.ts","sourceRoot":"","sources":["../../../../src/fonts/font-assets.web.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,eAAO,MAAM,WAAW,EAAE,YAAiB,CAAC"}

package/lib/typescript/commonjs/fonts/font-urls.web.d.ts

@@ -0,0 +1,6 @@
+import blomusModernusBold from './assets/BlomusModernus-Bold.woff2';
+import blomusModernusRegular from './assets/BlomusModernus-Regular.woff2';
+import geistMonoVariable from './assets/GeistMono-Variable.woff2';
+import interVariable from './assets/InterVariable.woff2';
+export { blomusModernusRegular, blomusModernusBold, interVariable, geistMonoVariable };
+//# sourceMappingURL=font-urls.web.d.ts.map

package/lib/typescript/commonjs/fonts/font-urls.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"font-urls.web.d.ts","sourceRoot":"","sources":["../../../../src/fonts/font-urls.web.ts"],"names":[],"mappings":"AAwBA,OAAO,kBAAkB,MAAM,oCAAoC,CAAC;AACpE,OAAO,qBAAqB,MAAM,uCAAuC,CAAC;AAC1E,OAAO,iBAAiB,MAAM,mCAAmC,CAAC;AAClE,OAAO,aAAa,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAC"}

package/lib/typescript/commonjs/fonts/index.node.d.ts

@@ -0,0 +1,7 @@
+export { fontFamilies, fontCssVars } from './tokens';
+export type { FontFamilyName } from './tokens';
+export { applyFontFaces } from './apply-font-faces';
+export { FONT_ASSETS } from './font-assets';
+export { FontLoader } from './FontLoader.node';
+export type { FontLoaderProps } from './FontLoader.node';
+//# sourceMappingURL=index.node.d.ts.map

package/lib/typescript/commonjs/fonts/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/index.node.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACrD,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

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

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface FontLoaderProps {
+    /** Ignored — there is nothing to load. Kept so the API matches every platform. */
+    enabled: boolean;
+    /** Ignored — nothing is ever pending, so children render immediately. */
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+/**
+ * Node font loader: a pass-through.
+ *
+ * There is no font registry to load into and no document to inject
+ * `@font-face` rules on, so the correct behaviour is to render children and
+ * stay out of the way — the same thing `FontLoader.tsx` ends up doing under
+ * Node once `applyFontFaces()` hits its `typeof document === 'undefined'`
+ * guard.
+ *
+ * It exists as a separate file rather than reusing that one because
+ * `FontLoader.tsx` imports `./apply-font-faces.web` outright, which reaches
+ * `font-urls.web`'s `.woff2` imports. Node hands a `.woff2` to the JS parser,
+ * so merely LOADING that module is fatal — the guard inside the function never
+ * gets a chance to run. Reached only through the `node` export condition on
+ * `./fonts`; see `scripts/generate-platform-exports.mjs` for why conditions
+ * are the only lever available here.
+ */
+export declare function FontLoader({ children }: FontLoaderProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FontLoader.node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FontLoader.node.d.ts","sourceRoot":"","sources":["../../../../src/fonts/FontLoader.node.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,OAAO,EAAE,OAAO,CAAC;IACjB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,2CAEvD"}

package/lib/typescript/module/fonts/apply-font-faces.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-font-faces.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,IAAI,IAAI,CAErC"}
+{"version":3,"file":"apply-font-faces.d.ts","sourceRoot":"","sources":["../../../../src/fonts/apply-font-faces.ts"],"names":[],"mappings":"AASA,wBAAgB,cAAc,IAAI,IAAI,CAErC"}