@symbiote-native/font 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# @symbiote-native/font
+
+Use a custom font without touching the native projects: give a name and a font file, wait for the
+load, then reference the name in `fontFamily`. One API for every [SymbioteNative](../../README.md)
+adapter (React, Vue, Svelte, Solid and Angular).
+
+It wraps [`expo-font`](https://github.com/expo/expo/tree/main/packages/expo-font). A font source is
+a string, URI, `require()` module id, or an [`@symbiote-native/asset`](../asset) `Asset`. The
+`renderToImageAsync` text-to-image utility (iOS + Android) comes with it. Built the same way as
+[`@symbiote-native/network`](../network), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism).
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --font
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --font
+```
+
+Either way: installs `@symbiote-native/font` and wires the native autolinking automatically - see
+[`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/font
+```
+
+`expo-font`, `expo-modules-core`, and `@symbiote-native/asset` come along as regular dependencies,
+pinned to exact versions - never install `expo-font` yourself, and never add the `expo` meta-package
+to this project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time step as every other `expo-modules-core` package this project ships - see
+[`@symbiote-native/network`'s README](../network/README.md#required-one-time-step-native-autolinking-wiring)
+and the `symbiote-expo-native-module` project skill. `native-link.json` registers two Android
+modules (`FontLoaderModule` → `ExpoFontLoader`, `FontUtilsModule` → `ExpoFontUtils`); iOS needs no
+manifest entry, both autolink via `use_expo_modules!`.
+
+No platform permission string is needed - font loading/rendering reads no protected system state
+on either platform.
+
+</details>
+
+## Shape
+
+```
+src/core/               font.ts - isLoaded/getLoadedFonts/isLoading/isFontMapLoaded/loadAsync/
+                        unloadAllAsync/unloadAsync. font-loader.ts resolves a FontSource to an
+                        @symbiote-native/asset Asset. font-utils.ts - renderToImageAsync.
+                        memory.ts - the loaded-fonts cache. native-modules.ts resolves
+                        ExpoFontLoader/ExpoFontUtils through expo-modules-core's
+                        requireNativeModule/requireOptionalNativeModule.
+src/react/hooks/        @symbiote-native/font/react   - useFonts
+src/vue/composables/    @symbiote-native/font/vue     - useFonts (same name)
+src/svelte/runes/       @symbiote-native/font/svelte  - useFonts (same name)
+src/solid/primitives/   @symbiote-native/font/solid   - createFonts (Solid reserves `use*` for
+                        consuming existing state)
+src/angular/services/   @symbiote-native/font/angular - FontsService (`.connect()` returns a
+                        Signal pair)
+```
+
+Each adapter's hook/composable/rune/primitive/service is a thin lifecycle wrapper (seed
+synchronously from `isFontMapLoaded`, call `loadAsync` once on mount, never reload on a changed
+font map) over the same `core` functions.
+
+## Use it
+
+```tsx
+// React
+import { loadAsync } from '@symbiote-native/font';
+import { useFonts } from '@symbiote-native/font/react';
+
+function App() {
+  const [loaded, error] = useFonts({
+    'Inter-Regular': require('./assets/fonts/Inter-Regular.ttf'),
+  });
+
+  if (!loaded) return null;
+  return <text style={{ fontFamily: 'Inter-Regular' }}>Hello</text>;
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { useFonts } from '@symbiote-native/font/vue';
+
+const { loaded, error } = useFonts({
+  'Inter-Regular': require('./assets/fonts/Inter-Regular.ttf'),
+});
+</script>
+<template>
+  <text v-if="loaded" style="font-family: Inter-Regular">Hello</text>
+</template>
+```
+
+```svelte
+<!-- Svelte -->
+<script lang="ts">
+  import { useFonts } from '@symbiote-native/font/svelte';
+
+  const fonts = useFonts({
+    'Inter-Regular': require('./assets/fonts/Inter-Regular.ttf'),
+  });
+</script>
+
+{#if fonts.loaded}
+  <text style="font-family: Inter-Regular">Hello</text>
+{/if}
+```
+
+```ts
+// Angular
+import { Component, inject } from '@angular/core';
+import { SYMBIOTE_ELEMENTS } from '@symbiote-native/angular';
+import { FontsService } from '@symbiote-native/font/angular';
+
+@Component({
+  standalone: true,
+  imports: [SYMBIOTE_ELEMENTS],
+  template: `@if (fonts.loaded()) {
+    <text style="font-family: Inter-Regular">Hello</text>
+  }`,
+})
+export class App {
+  readonly fonts = inject(FontsService).connect({
+    'Inter-Regular': require('./assets/fonts/Inter-Regular.ttf'),
+  });
+}
+```
+
+```tsx
+// Solid - the accessor is CALLED; a Solid component body runs once.
+import { createFonts } from '@symbiote-native/font/solid';
+
+function App() {
+  const fonts = createFonts({
+    'Inter-Regular': require('./assets/fonts/Inter-Regular.ttf'),
+  });
+
+  return fonts.loaded() ? (
+    <text style={{ 'font-family': 'Inter-Regular' }}>Hello</text>
+  ) : null;
+}
+```
+
+## API
+
+```ts
+isLoaded(fontFamily: string): boolean
+getLoadedFonts(): string[]
+isLoading(fontFamily: string): boolean
+isFontMapLoaded(map: string | Record<string, FontSource>): boolean
+loadAsync(fontFamilyOrFontMap: string | Record<string, FontSource>, source?: FontSource): Promise<void>
+unloadAllAsync(): Promise<void>                                    // always throws - see Notes
+unloadAsync(fontFamilyOrFontMap: string | Record<string, UnloadFontOptions>, options?: UnloadFontOptions): Promise<void>  // always throws - see Notes
+renderToImageAsync(glyphs: string, options?: IRenderToImageOptions): Promise<IRenderToImageResult>
+```
+
+Plus `FontDisplay` (enum, web-only effect, kept for type parity), `FontSource`, `FontResource`,
+`UnloadFontOptions`, `UseFontsResult` - hand-ported from upstream's `Font.types.ts`.
+
+## Notes
+
+- **The `fontFamily` in a style must match the map key exactly.** `'Inter-Regular'` in the map and
+  `fontFamily: 'Inter'` in the style silently falls back to the system font.
+- **`unloadAsync`/`unloadAllAsync` always throw `UnavailabilityError` on native** - ported and
+  exported for API parity, but `ExpoFontLoader` has no unload method on either iOS or Android,
+  only on web. Matches upstream exactly; not a bug in this port.
+- **The web/server branches are not ported** - `isLoaded`'s web fallback, `loadAsync`'s server
+  pre-render pass (`registerStaticFont`/`serverContext`), `FontHooks.ts`'s static-fonts SSR branch.
+  This repo has no web/SSR render target for any adapter.
+- **`expo-font`'s config plugin (`withFonts`) is not ported** - declaratively bundles static font
+  files into the native project via `app.json`. This repo runs no Expo CLI/prebuild step at all
+  (see the root `CLAUDE.md`); bundle a static font the plain React Native way
+  (`android/app/src/main/assets/fonts/`, Xcode's "Copy Bundle Resources" + `UIAppFonts` in
+  `Info.plist`) or call `loadAsync` with a local `file://` URI at startup.
+
+## Common questions
+
+- **The text uses the system font.** The `fontFamily` is not the exact key you loaded, you rendered
+  before `loaded`, or the file failed to load (check `error` and `getLoadedFonts()`).
+- **Bold or italic.** Load each weight or style as its own family and set `fontFamily` to it; do
+  not rely on `fontWeight` for a custom family.
+- **A natively bundled font works on Android, not iOS.** iOS finds a `UIAppFonts` font by its own
+  (full or PostScript) name, not the file name; a runtime-loaded font uses your map key.
+- **Unloading.** `unloadAsync` throws on iOS and Android: the native loader has no unload.
+
+Sources: [expo/expo#33673](https://github.com/expo/expo/issues/33673),
+[expo/expo#22074](https://github.com/expo/expo/issues/22074),
+[DEV: custom fonts on iOS](https://dev.to/aymericmartinache/the-mystery-of-fonts-on-ios-why-was-my-app-not-displaying-custom-fonts-3h8j).
+
+## Test it
+
+No Fabric/Descriptor angle at all - every function here is a pure async-function surface plus a
+small in-memory cache, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/{font,font-loader,font-utils,memory}.test.ts`,
+`src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`) - no `installFabric()`, no ViewConfig.
+
+The `FontScreen` in the `examples/expo-*` apps carries the on-device verification.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { FontsService } from './services/fonts.service';
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// FontsService is the Angular-only lifecycle half; the loading/caching logic all lives in
+// core, shared with React/Vue/Svelte/Solid.
+export { FontsService } from './services/fonts.service/index.js';
+export * from '../core/index.js';

package/build/angular/services/fonts.service/index.d.ts

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import { type FontSource } from '../../../core';
+export declare class FontsService {
+    connect(map: string | Record<string, FontSource>): {
+        loaded: Signal<boolean>;
+        error: Signal<Error | null>;
+    };
+}

package/build/angular/services/fonts.service/index.js

@@ -0,0 +1,64 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable, signal } from '@angular/core';
+import { isFontMapLoaded, loadAsync } from '../../../core/index.js';
+// Angular twin of React's useFonts hook and Vue's useFonts composable — connect(map) returns
+// a Signal pair, e.g. `readonly fonts = inject(FontsService).connect({ Inter: require('...') })`.
+let FontsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var FontsService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            FontsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        connect(map) {
+            const loaded = signal(isFontMapLoaded(map));
+            const error = signal(null);
+            loadAsync(map)
+                .then(() => loaded.set(true))
+                .catch((err) => error.set(err));
+            return { loaded: loaded.asReadonly(), error: error.asReadonly() };
+        }
+    };
+    return FontsService = _classThis;
+})();
+export { FontsService };

package/build/core/font-loader.d.ts

@@ -0,0 +1,4 @@
+import { Asset } from '@symbiote-native/asset';
+import type { FontResource, FontSource } from './types';
+export declare function getAssetForSource(source: FontSource): Asset | FontResource;
+export declare function loadSingleFontAsync(name: string, input: Asset | FontResource): Promise<void>;

package/build/core/font-loader.js

@@ -0,0 +1,30 @@
+// Ported from expo-font/src/FontLoader.ts (sdk-57), resolving through @symbiote-native/asset's
+// Asset class (this repo's own expo-asset port) instead of importing expo-asset directly.
+import { Asset } from '@symbiote-native/asset';
+import { CodedError } from 'expo-modules-core';
+import { expoFontLoader } from './native-modules.js';
+export function getAssetForSource(source) {
+    if (source instanceof Asset) {
+        return source;
+    }
+    if (typeof source === 'string') {
+        return Asset.fromURI(source);
+    }
+    if (typeof source === 'number') {
+        return Asset.fromModule(source);
+    }
+    if (typeof source === 'object' && typeof source.uri !== 'undefined') {
+        return getAssetForSource(source.uri);
+    }
+    return source;
+}
+export async function loadSingleFontAsync(name, input) {
+    if (!(input instanceof Asset)) {
+        throw new CodedError('ERR_FONT_SOURCE', '`loadSingleFontAsync` expected a resource of type `Asset` from @symbiote-native/asset');
+    }
+    await input.downloadAsync();
+    if (!input.downloaded || !input.localUri) {
+        throw new CodedError('ERR_DOWNLOAD', `Failed to download asset for font "${name}"`);
+    }
+    await expoFontLoader.loadAsync(name, input.localUri);
+}

package/build/core/font-utils.d.ts

@@ -0,0 +1,14 @@
+export type IRenderToImageOptions = {
+    fontFamily?: string;
+    size?: number;
+    color?: string;
+    lineHeight?: number;
+};
+export type IRenderToImageResult = {
+    uri: string;
+    width: number;
+    height: number;
+    scale: number;
+};
+/** @platform android @platform ios */
+export declare function renderToImageAsync(glyphs: string, options?: IRenderToImageOptions): Promise<IRenderToImageResult>;

package/build/core/font-utils.js

@@ -0,0 +1,16 @@
+// Ported from expo-font/src/FontUtils.ts (sdk-57).
+import { UnavailabilityError } from 'expo-modules-core';
+import { processColor } from 'react-native';
+import { expoFontUtils } from './native-modules.js';
+/** @platform android @platform ios */
+export async function renderToImageAsync(glyphs, options) {
+    if (!expoFontUtils) {
+        throw new UnavailabilityError('expo-font', 'ExpoFontUtils.renderToImageAsync');
+    }
+    return expoFontUtils.renderToImageAsync(glyphs, {
+        ...options,
+        color: options?.color
+            ? (processColor(options.color) ?? undefined)
+            : undefined,
+    });
+}

package/build/core/font.d.ts

@@ -0,0 +1,11 @@
+import type { FontSource, UnloadFontOptions } from './types';
+export declare function isLoaded(fontFamily: string): boolean;
+export declare function getLoadedFonts(): string[];
+export declare function isLoading(fontFamily: string): boolean;
+/** Shared seed check for every adapter's `useFonts`/`createFonts` lifecycle wrapper. */
+export declare function isFontMapLoaded(map: string | Record<string, FontSource>): boolean;
+export declare function loadAsync(fontFamilyOrFontMap: string | Record<string, FontSource>, source?: FontSource): Promise<void>;
+/** Always throws on native — ExpoFontLoader has no unload method there, web-only upstream. */
+export declare function unloadAllAsync(): Promise<void>;
+/** Always throws on native — ExpoFontLoader has no unload method there, web-only upstream. */
+export declare function unloadAsync(fontFamilyOrFontMap: string | Record<string, UnloadFontOptions>, options?: UnloadFontOptions): Promise<void>;

package/build/core/font.js

@@ -0,0 +1,94 @@
+// Ported from expo-font/src/Font.ts (sdk-57), native-only — drops the web/server branches
+// (isLoaded's web fallback, loadAsync's server pre-render pass, registerStaticFont).
+import { CodedError, UnavailabilityError } from 'expo-modules-core';
+import { getAssetForSource, loadSingleFontAsync } from './font-loader.js';
+import { isLoadedNative, loadPromises, markLoaded, purgeCache, purgeFontFamilyFromCache, } from './memory.js';
+import { expoFontLoader } from './native-modules.js';
+export function isLoaded(fontFamily) {
+    return isLoadedNative(fontFamily);
+}
+export function getLoadedFonts() {
+    return expoFontLoader.getLoadedFonts();
+}
+export function isLoading(fontFamily) {
+    return fontFamily in loadPromises;
+}
+/** Shared seed check for every adapter's `useFonts`/`createFonts` lifecycle wrapper. */
+export function isFontMapLoaded(map) {
+    if (typeof map === 'string') {
+        return isLoaded(map);
+    }
+    return Object.keys(map).every(fontFamily => isLoaded(fontFamily));
+}
+export function loadAsync(fontFamilyOrFontMap, source) {
+    if (typeof fontFamilyOrFontMap === 'object') {
+        if (source) {
+            return Promise.reject(new CodedError('ERR_FONT_API', `No fontFamily can be used for the provided source: ${String(source)}. The second argument of loadAsync() can only be used with a string value as the first argument.`));
+        }
+        const fontMap = fontFamilyOrFontMap;
+        const names = Object.keys(fontMap);
+        return Promise.all(names.map(name => loadFontInNamespaceAsync(name, fontMap[name]))).then(() => { });
+    }
+    return loadFontInNamespaceAsync(fontFamilyOrFontMap, source);
+}
+async function loadFontInNamespaceAsync(fontFamily, source) {
+    if (!source) {
+        throw new CodedError('ERR_FONT_SOURCE', `Cannot load null or undefined font source for fontFamily "${fontFamily}".`);
+    }
+    if (isLoaded(fontFamily)) {
+        return;
+    }
+    if (Object.hasOwn(loadPromises, fontFamily)) {
+        return loadPromises[fontFamily];
+    }
+    const asset = getAssetForSource(source);
+    loadPromises[fontFamily] = (async () => {
+        try {
+            await loadSingleFontAsync(fontFamily, asset);
+            markLoaded(fontFamily);
+        }
+        finally {
+            delete loadPromises[fontFamily];
+        }
+    })();
+    await loadPromises[fontFamily];
+}
+/** Always throws on native — ExpoFontLoader has no unload method there, web-only upstream. */
+export async function unloadAllAsync() {
+    if (!expoFontLoader.unloadAllAsync) {
+        throw new UnavailabilityError('expo-font', 'unloadAllAsync');
+    }
+    if (Object.keys(loadPromises).length) {
+        throw new CodedError('ERR_UNLOAD', `Cannot unload fonts while they're still loading: ${Object.keys(loadPromises).join(', ')}`);
+    }
+    purgeCache();
+    await expoFontLoader.unloadAllAsync();
+}
+/** Always throws on native — ExpoFontLoader has no unload method there, web-only upstream. */
+export async function unloadAsync(fontFamilyOrFontMap, options) {
+    if (!expoFontLoader.unloadAsync) {
+        throw new UnavailabilityError('expo-font', 'unloadAsync');
+    }
+    if (typeof fontFamilyOrFontMap === 'object') {
+        if (options) {
+            throw new CodedError('ERR_FONT_API', `No fontFamily can be used for the provided options: ${String(options)}. The second argument of unloadAsync() can only be used with a string value as the first argument.`);
+        }
+        const names = Object.keys(fontFamilyOrFontMap);
+        await Promise.all(names.map(name => unloadFontInNamespaceAsync(name, fontFamilyOrFontMap[name])));
+        return;
+    }
+    return unloadFontInNamespaceAsync(fontFamilyOrFontMap, options);
+}
+async function unloadFontInNamespaceAsync(fontFamily, options) {
+    if (!isLoaded(fontFamily)) {
+        return;
+    }
+    purgeFontFamilyFromCache(fontFamily);
+    if (!fontFamily) {
+        throw new CodedError('ERR_FONT_FAMILY', 'Cannot unload an empty name');
+    }
+    if (!expoFontLoader.unloadAsync) {
+        throw new UnavailabilityError('expo-font', 'unloadAsync');
+    }
+    await expoFontLoader.unloadAsync(fontFamily, options);
+}

package/build/core/index.d.ts

@@ -0,0 +1,5 @@
+export { isLoaded, getLoadedFonts, isLoading, isFontMapLoaded, loadAsync, unloadAllAsync, unloadAsync, } from './font';
+export { renderToImageAsync } from './font-utils';
+export type { IRenderToImageOptions, IRenderToImageResult } from './font-utils';
+export { FontDisplay } from './types';
+export type { FontResource, FontSource, UnloadFontOptions, UseFontsResult, } from './types';

package/build/core/index.js

@@ -0,0 +1,3 @@
+export { isLoaded, getLoadedFonts, isLoading, isFontMapLoaded, loadAsync, unloadAllAsync, unloadAsync, } from './font.js';
+export { renderToImageAsync } from './font-utils.js';
+export { FontDisplay } from './types.js';

package/build/core/memory.d.ts

@@ -0,0 +1,6 @@
+export declare const loadPromises: Record<string, Promise<void>>;
+export declare function markLoaded(fontFamily: string): void;
+export declare function isLoadedInCache(fontFamily: string): boolean;
+export declare function isLoadedNative(fontFamily: string): boolean;
+export declare function purgeFontFamilyFromCache(fontFamily: string): void;
+export declare function purgeCache(): void;

package/build/core/memory.js

@@ -0,0 +1,30 @@
+// Ported verbatim from expo-font/src/memory.ts (sdk-57) — no web/server branch to drop, this
+// module was already native-agnostic.
+import { expoFontLoader } from './native-modules.js';
+export const loadPromises = {};
+let cache = {};
+export function markLoaded(fontFamily) {
+    cache[fontFamily] = true;
+}
+export function isLoadedInCache(fontFamily) {
+    return fontFamily in cache;
+}
+export function isLoadedNative(fontFamily) {
+    if (isLoadedInCache(fontFamily)) {
+        return true;
+    }
+    const loadedNativeFonts = expoFontLoader.getLoadedFonts();
+    if (!loadedNativeFonts?.length) {
+        return false;
+    }
+    loadedNativeFonts.forEach(font => {
+        cache[font] = true;
+    });
+    return fontFamily in cache;
+}
+export function purgeFontFamilyFromCache(fontFamily) {
+    delete cache[fontFamily];
+}
+export function purgeCache() {
+    cache = {};
+}

package/build/core/native-modules.d.ts

@@ -0,0 +1,24 @@
+import type { ProcessedColorValue } from 'react-native';
+import type { UnloadFontOptions } from './types';
+export type INativeFontLoaderModule = {
+    getLoadedFonts(): string[];
+    loadAsync(fontFamilyName: string, localUri: string): Promise<void>;
+    unloadAllAsync?(): Promise<void>;
+    unloadAsync?(fontFamilyName: string, options?: UnloadFontOptions): Promise<void>;
+};
+export type INativeRenderToImageOptions = {
+    fontFamily?: string;
+    size?: number;
+    color?: ProcessedColorValue;
+    lineHeight?: number;
+};
+export type INativeFontUtilsModule = {
+    renderToImageAsync(glyphs: string, options?: INativeRenderToImageOptions): Promise<{
+        uri: string;
+        width: number;
+        height: number;
+        scale: number;
+    }>;
+};
+export declare const expoFontLoader: INativeFontLoaderModule;
+export declare const expoFontUtils: INativeFontUtilsModule | null;

package/build/core/native-modules.js

@@ -0,0 +1,7 @@
+import { requireNativeModule, requireOptionalNativeModule, } from 'expo-modules-core';
+const EXPO_FONT_LOADER_MODULE_NAME = 'ExpoFontLoader';
+const EXPO_FONT_UTILS_MODULE_NAME = 'ExpoFontUtils';
+export const expoFontLoader = requireNativeModule(EXPO_FONT_LOADER_MODULE_NAME);
+// Present on both iOS and Android upstream — still optional (matches upstream's own
+// requireOptionalNativeModule) since only web ships without it.
+export const expoFontUtils = requireOptionalNativeModule(EXPO_FONT_UTILS_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,18 @@
+import type { Asset } from '@symbiote-native/asset';
+/** @platform web — has no effect on native, kept for API-surface parity with upstream. */
+export declare enum FontDisplay {
+    AUTO = "auto",
+    SWAP = "swap",
+    BLOCK = "block",
+    FALLBACK = "fallback",
+    OPTIONAL = "optional"
+}
+export type FontResource = {
+    uri?: string | number;
+    display?: FontDisplay;
+    default?: string;
+    testString?: string;
+};
+export type FontSource = string | number | Asset | FontResource;
+export type UnloadFontOptions = Pick<FontResource, 'display'>;
+export type UseFontsResult = readonly [loaded: boolean, error: Error | null];

package/build/core/types.js

@@ -0,0 +1,9 @@
+/** @platform web — has no effect on native, kept for API-surface parity with upstream. */
+export var FontDisplay;
+(function (FontDisplay) {
+    FontDisplay["AUTO"] = "auto";
+    FontDisplay["SWAP"] = "swap";
+    FontDisplay["BLOCK"] = "block";
+    FontDisplay["FALLBACK"] = "fallback";
+    FontDisplay["OPTIONAL"] = "optional";
+})(FontDisplay || (FontDisplay = {}));

package/build/react/hooks/use-fonts/index.d.ts

@@ -0,0 +1,2 @@
+import { type FontSource, type UseFontsResult } from '../../../core';
+export declare function useFonts(map: string | Record<string, FontSource>): UseFontsResult;

package/build/react/hooks/use-fonts/index.js

@@ -0,0 +1,28 @@
+// React lifecycle wiring over the framework-agnostic core (core/font.ts). Loads once on mount
+// (upstream's own contract: a changed font map is not reloaded — see FontHooks.ts's
+// useRuntimeFonts), seeded synchronously so an already-loaded font never flashes unloaded.
+import { useEffect, useState } from 'react';
+import { isFontMapLoaded, loadAsync, } from '../../../core/index.js';
+export function useFonts(map) {
+    const [loaded, setLoaded] = useState(() => isFontMapLoaded(map));
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let isMounted = true;
+        loadAsync(map)
+            .then(() => {
+            if (isMounted)
+                setLoaded(true);
+        })
+            .catch((err) => {
+            if (isMounted)
+                setError(err);
+        });
+        return () => {
+            isMounted = false;
+        };
+        // Loads once on mount only — a later change to `map` is deliberately not reloaded,
+        // matching upstream's own useFonts contract.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return [loaded, error];
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export { useFonts } from './hooks/use-fonts';
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/font/react: the React entry over the framework-agnostic core.
+export { useFonts } from './hooks/use-fonts/index.js';
+export * from '../core/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export { createFonts } from './primitives/create-fonts';
+export * from '../core';