react-native-revnix 1.4.0

package/dist/blocks/locale.d.ts

@@ -0,0 +1,42 @@
+import type { PaywallBlockDoc } from "./types.js";
+/** BCP-47, hyphenated: "es_MX" and "es-mx" both normalize to "es-MX". Applied
+ *  to authored tags and to the device's reported locale alike, so the two can
+ *  never miss each other over punctuation or case. */
+export declare function normalizeLocale(tag: string | undefined): string | undefined;
+/** Which tables to consult, most specific first.
+ *
+ *  "es-MX" on a paywall translated into "es" reads the "es" table: a regional
+ *  variant that was never authored falls back to its language rather than to
+ *  the source, which is the difference between a Mexican user reading Spanish
+ *  and reading English. The authored tree is the last resort and is NOT in
+ *  this chain — the lookup falls through to it. */
+export declare function localeChain(available: readonly string[], locale: string | undefined, defaultLocale: string | undefined): string[];
+/** Forces the paywall language regardless of the device's, for a host whose
+ *  in-app language picker differs from the OS locale. `undefined` clears it.
+ *  Only paywalls MOUNTED AFTER this call pick it up — `detectLocale()` is
+ *  read once per doc/locale in a `useMemo`. */
+export declare function setLocale(tag?: string): void;
+/** The device's language, for hosts that do not pass one. Hermes without the
+ *  full ICU build has no `Intl`, and a React Native `navigator.language` is
+ *  the JS engine's, not the device's — so this is best effort and a host that
+ *  cares passes `locale` explicitly. */
+export declare function detectLocale(): string | undefined;
+/** Returns the document with every string swapped for `locale`'s.
+ *
+ *  Applied ONCE before rendering rather than at each text node: the renderer
+ *  then needs no localization awareness at all, and the six SDKs cannot drift
+ *  on which fields are translatable. Returns the input untouched when nothing
+ *  applies, so an untranslated paywall allocates nothing.
+ *
+ *  `{price}` and the other copy tags survive, because they are resolved AFTER
+ *  this on the localized string — "Solo {price} al mes" works. */
+export declare function localizeBlockDoc(doc: PaywallBlockDoc, locale: string | undefined): PaywallBlockDoc;
+/** The three built-in paywall footer labels (restore/terms/privacy), in the
+ *  language `locale` resolves to. Falls back to English for any language not
+ *  in the 43-entry table. Mandarin picks traditional script for Taiwan, Hong
+ *  Kong and Macau unless the tag is explicitly simplified. */
+export declare function linkLabels(locale: string | undefined): {
+    restore: string;
+    terms: string;
+    privacy: string;
+};

package/dist/blocks/locale.js

@@ -0,0 +1,263 @@
+"use strict";
+// REV-271: paywall localization, SDK half. A designed paywall carries ONE
+// tree plus a side table of translated strings — never one tree per language
+// — so styles, layout and block ids are shared and only words differ.
+//
+// Selection happens HERE, at render, rather than server-side at resolve. The
+// resolution is cached on the device (REV-157), so a locale chosen by the
+// server would pin a cached paywall to whatever language it was fetched in:
+// change the phone's language and the old copy would keep rendering until the
+// cache expired, and offline it would never change at all. Choosing on the
+// device also keeps the server's fleet-wide placement cache one entry per
+// placement instead of one per language.
+//
+// Mirrored from the dashboard's src/lib/paywall-blocks/locale.ts and into the
+// five native SDKs. The key scheme, the fallback chain and the field list
+// must stay identical on every side — a paywall translated in the dashboard
+// has to resolve the same way on all six.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLocale = normalizeLocale;
+exports.localeChain = localeChain;
+exports.setLocale = setLocale;
+exports.detectLocale = detectLocale;
+exports.localizeBlockDoc = localizeBlockDoc;
+exports.linkLabels = linkLabels;
+/** BCP-47, hyphenated: "es_MX" and "es-mx" both normalize to "es-MX". Applied
+ *  to authored tags and to the device's reported locale alike, so the two can
+ *  never miss each other over punctuation or case. */
+function normalizeLocale(tag) {
+    if (typeof tag !== "string")
+        return undefined;
+    const parts = tag.trim().replace(/_/g, "-").split("-").filter(Boolean);
+    const language = parts[0]?.toLowerCase();
+    if (language === undefined || !/^[a-z]{2,3}$/.test(language))
+        return undefined;
+    const rest = [];
+    for (const part of parts.slice(1)) {
+        // Region subtags are uppercase ("MX", "419"), scripts title case ("Hans").
+        // Anything else is a variant and stays lowercase. A subtag outside
+        // BCP-47's shapes makes the WHOLE tag junk rather than passing through —
+        // otherwise a device reporting "es-!!" would look up a language.
+        if (/^[A-Za-z]{2}$/.test(part) || /^\d{3}$/.test(part)) {
+            rest.push(part.toUpperCase());
+        }
+        else if (/^[A-Za-z]{4}$/.test(part)) {
+            rest.push(part.charAt(0).toUpperCase() + part.slice(1).toLowerCase());
+        }
+        else if (/^[A-Za-z0-9]{5,8}$/.test(part)) {
+            rest.push(part.toLowerCase());
+        }
+        else {
+            return undefined;
+        }
+    }
+    return [language, ...rest].join("-");
+}
+function baseLanguage(tag) {
+    return tag.split("-")[0] ?? tag;
+}
+/** Which tables to consult, most specific first.
+ *
+ *  "es-MX" on a paywall translated into "es" reads the "es" table: a regional
+ *  variant that was never authored falls back to its language rather than to
+ *  the source, which is the difference between a Mexican user reading Spanish
+ *  and reading English. The authored tree is the last resort and is NOT in
+ *  this chain — the lookup falls through to it. */
+function localeChain(available, locale, defaultLocale) {
+    const chain = [];
+    const push = (tag) => {
+        if (tag !== undefined && available.includes(tag) && !chain.includes(tag)) {
+            chain.push(tag);
+        }
+    };
+    const wanted = normalizeLocale(locale);
+    if (wanted !== undefined) {
+        push(wanted);
+        push(baseLanguage(wanted));
+        // "es" asked for, only "es-MX" authored: one regional table beats the
+        // source language, and the first sorted match keeps the choice
+        // deterministic across devices rather than dependent on key order.
+        if (chain.length === 0) {
+            const language = baseLanguage(wanted);
+            const regional = available
+                .filter((tag) => baseLanguage(tag) === language)
+                .sort();
+            push(regional[0]);
+        }
+    }
+    push(normalizeLocale(defaultLocale));
+    return chain;
+}
+let localeOverride;
+/** Forces the paywall language regardless of the device's, for a host whose
+ *  in-app language picker differs from the OS locale. `undefined` clears it.
+ *  Only paywalls MOUNTED AFTER this call pick it up — `detectLocale()` is
+ *  read once per doc/locale in a `useMemo`. */
+function setLocale(tag) {
+    localeOverride = tag || undefined;
+}
+/** The device's language, for hosts that do not pass one. Hermes without the
+ *  full ICU build has no `Intl`, and a React Native `navigator.language` is
+ *  the JS engine's, not the device's — so this is best effort and a host that
+ *  cares passes `locale` explicitly. */
+function detectLocale() {
+    if (localeOverride !== undefined)
+        return localeOverride;
+    try {
+        const resolved = new Intl.DateTimeFormat().resolvedOptions().locale;
+        if (typeof resolved === "string" && resolved.length > 0)
+            return resolved;
+    }
+    catch {
+        // Falls through to navigator below.
+    }
+    const nav = globalThis.navigator;
+    return typeof nav?.language === "string" && nav.language.length > 0
+        ? nav.language
+        : undefined;
+}
+function localizeBlock(block, lookup) {
+    const at = (path, authored) => lookup(`${block.id}.${path}`, authored);
+    const opt = (path, authored) => authored === undefined ? undefined : at(path, authored);
+    switch (block.type) {
+        case "text":
+            return { ...block, text: at("text", block.text) };
+        case "button":
+            return { ...block, label: at("label", block.label) };
+        case "list":
+            return {
+                ...block,
+                items: block.items.map((item, i) => ({
+                    ...item,
+                    title: at(`items.${i}.title`, item.title),
+                    description: opt(`items.${i}.description`, item.description),
+                })),
+            };
+        case "products":
+            return {
+                ...block,
+                titleTpl: opt("titleTpl", block.titleTpl),
+                priceTpl: opt("priceTpl", block.priceTpl),
+                highlightSub: opt("highlightSub", block.highlightSub),
+                badgeText: opt("badgeText", block.badgeText),
+            };
+        case "card":
+            return {
+                ...block,
+                children: block.children.map((child) => localizeBlock(child, lookup)),
+            };
+        default:
+            return block;
+    }
+}
+/** Returns the document with every string swapped for `locale`'s.
+ *
+ *  Applied ONCE before rendering rather than at each text node: the renderer
+ *  then needs no localization awareness at all, and the six SDKs cannot drift
+ *  on which fields are translatable. Returns the input untouched when nothing
+ *  applies, so an untranslated paywall allocates nothing.
+ *
+ *  `{price}` and the other copy tags survive, because they are resolved AFTER
+ *  this on the localized string — "Solo {price} al mes" works. */
+function localizeBlockDoc(doc, locale) {
+    const tables = doc.locales;
+    if (tables === undefined)
+        return doc;
+    const available = Object.keys(tables);
+    if (available.length === 0)
+        return doc;
+    const chain = localeChain(available, locale, doc.defaultLocale);
+    if (chain.length === 0)
+        return doc;
+    const lookup = (key, authored) => {
+        for (const tag of chain) {
+            const value = tables[tag]?.[key];
+            // An empty translation means "not translated", never "render nothing":
+            // a blank CTA is a dead paywall, and an export/import round-trip leaves
+            // empty cells behind for every untouched row.
+            if (typeof value === "string" && value !== "")
+                return value;
+        }
+        return authored;
+    };
+    return {
+        ...doc,
+        defaultLocale: chain[0],
+        blocks: doc.blocks.map((b) => localizeBlock(b, lookup)),
+    };
+}
+const LINK_LABEL_ALIASES = {
+    iw: "he",
+    in: "id",
+    no: "nb",
+    tl: "fil",
+};
+const LINK_LABELS = {
+    ar: ["استعادة", "الشروط", "الخصوصية"],
+    bg: ["Възстановяване", "Условия", "Поверителност"],
+    bn: ["পুনরুদ্ধার", "শর্তাবলী", "গোপনীয়তা"],
+    ca: ["Restaura", "Condicions", "Privadesa"],
+    cs: ["Obnovit", "Podmínky", "Soukromí"],
+    da: ["Gendan", "Vilkår", "Privatliv"],
+    de: ["Wiederherstellen", "AGB", "Datenschutz"],
+    el: ["Επαναφορά", "Όροι", "Απόρρητο"],
+    en: ["Restore", "Terms", "Privacy"],
+    es: ["Restaurar", "Términos", "Privacidad"],
+    et: ["Taasta", "Tingimused", "Privaatsus"],
+    fa: ["بازیابی", "شرایط", "حریم خصوصی"],
+    fi: ["Palauta", "Ehdot", "Tietosuoja"],
+    fil: ["I-restore", "Mga Tuntunin", "Privacy"],
+    fr: ["Restaurer", "Conditions", "Confidentialité"],
+    he: ["שחזור", "תנאים", "פרטיות"],
+    hi: ["पुनर्स्थापित करें", "शर्तें", "गोपनीयता"],
+    hr: ["Vrati", "Uvjeti", "Privatnost"],
+    hu: ["Visszaállítás", "Feltételek", "Adatvédelem"],
+    id: ["Pulihkan", "Ketentuan", "Privasi"],
+    it: ["Ripristina", "Termini", "Privacy"],
+    ja: ["購入を復元", "利用規約", "プライバシー"],
+    ko: ["구매 복원", "이용약관", "개인정보"],
+    lt: ["Atkurti", "Sąlygos", "Privatumas"],
+    lv: ["Atjaunot", "Noteikumi", "Privātums"],
+    ms: ["Pulihkan", "Terma", "Privasi"],
+    nb: ["Gjenopprett", "Vilkår", "Personvern"],
+    nl: ["Herstellen", "Voorwaarden", "Privacy"],
+    pl: ["Przywróć", "Regulamin", "Prywatność"],
+    pt: ["Restaurar", "Termos", "Privacidade"],
+    ro: ["Restaurează", "Termeni", "Confidențialitate"],
+    ru: ["Восстановить", "Условия", "Конфиденциальность"],
+    sk: ["Obnoviť", "Podmienky", "Súkromie"],
+    sl: ["Obnovi", "Pogoji", "Zasebnost"],
+    sr: ["Врати", "Услови", "Приватност"],
+    sv: ["Återställ", "Villkor", "Integritet"],
+    th: ["กู้คืน", "ข้อกำหนด", "ความเป็นส่วนตัว"],
+    tr: ["Geri Yükle", "Koşullar", "Gizlilik"],
+    uk: ["Відновити", "Умови", "Конфіденційність"],
+    ur: ["بحال کریں", "شرائط", "رازداری"],
+    vi: ["Khôi phục", "Điều khoản", "Quyền riêng tư"],
+    zh: ["恢复购买", "条款", "隐私"],
+    "zh-Hant": ["恢復購買", "條款", "隱私"],
+};
+/** The three built-in paywall footer labels (restore/terms/privacy), in the
+ *  language `locale` resolves to. Falls back to English for any language not
+ *  in the 43-entry table. Mandarin picks traditional script for Taiwan, Hong
+ *  Kong and Macau unless the tag is explicitly simplified. */
+function linkLabels(locale) {
+    const [restore, terms, privacy] = LINK_LABELS[resolveLinkLabelTag(locale)];
+    return { restore, terms, privacy };
+}
+function resolveLinkLabelTag(locale) {
+    const tag = normalizeLocale(locale);
+    if (tag === undefined)
+        return "en";
+    const lang = baseLanguage(tag);
+    if (lang === "zh") {
+        const parts = tag.split("-").slice(1);
+        const hasHant = parts.includes("Hant");
+        const hasHans = parts.includes("Hans");
+        const region = parts.find((part) => /^[A-Z]{2}$/.test(part));
+        const isTraditionalRegion = region !== undefined && ["TW", "HK", "MO"].includes(region);
+        return hasHant || (!hasHans && isTraditionalRegion) ? "zh-Hant" : "zh";
+    }
+    const base = LINK_LABEL_ALIASES[lang] ?? lang;
+    return base in LINK_LABELS ? base : "en";
+}

package/dist/blocks/selection.d.ts

@@ -0,0 +1,49 @@
+import type { BlockStyle, PaywallBlock, PaywallBlockDoc } from "./types.js";
+import type { RevnixPaywallPackage } from "../ui/RevnixPaywall.js";
+/** Where a block sits: inside the selected plan card, inside another plan
+ *  card, or outside any plan card (undefined). */
+export type SelectionContext = "selected" | "unselected" | undefined;
+/** The package a designed paywall is showing as chosen: the host's choice,
+ *  then the renderer's own after a tap, then the design's highlight, then the
+ *  first package — each only when the offering actually carries it. */
+export declare function selectedPackageId(packages: ReadonlyArray<{
+    packageId: string;
+}>, ...candidates: Array<string | undefined>): string | undefined;
+/** The context a package-bearing card opens for itself and its subtree. */
+export declare function packageContext(pkg: {
+    packageId: string;
+} | undefined, selectedId: string | undefined): SelectionContext;
+/** `selectedStyle` merged over `style` while selected; `style` otherwise. */
+export declare function effectiveStyle(block: PaywallBlock, context: SelectionContext): BlockStyle | undefined;
+/** Whether a block is drawn. Outside any plan card every block is drawn,
+ *  whatever `visibility` says — a root block can never disappear. */
+export declare function isVisible(block: PaywallBlock, context: SelectionContext): boolean;
+/** Canvas designs are authored at 393×852 and scaled by width, capped so a
+ *  tablet or a landscape phone shows a centred phone-sized design instead of
+ *  a blown-up one. */
+export declare const CANVAS_MAX_WIDTH = 480;
+export interface CanvasMetrics {
+    scale: number;
+    /** Horizontal offset of the scaled design inside the viewport. */
+    left: number;
+    /** Height of the laid-out design in DESIGN units. */
+    designHeight: number;
+    /** Height of the scaled design in viewport points. */
+    scaledHeight: number;
+    /** Whether the design is taller than the viewport and must scroll. */
+    overflows: boolean;
+}
+export declare function canvasMetrics(viewportWidth: number, viewportHeight: number | null): CanvasMetrics;
+export interface ResolvedBlock {
+    block: PaywallBlock;
+    context: SelectionContext;
+    visible: boolean;
+    style: BlockStyle | undefined;
+    /** Resolved copy for text and button blocks. */
+    text?: string;
+}
+/** Walk a document exactly the way the renderer does — pinned cards judge
+ *  their own context, repeat cards yield one entry per package (keyed
+ *  `id@packageId`), hidden subtrees are not entered — and report what every
+ *  block resolves to. The wire fixture test reads this. */
+export declare function resolveBlocks(doc: PaywallBlockDoc, packages: RevnixPaywallPackage[], selectedId: string | undefined): Map<string, ResolvedBlock>;

package/dist/blocks/selection.js

@@ -0,0 +1,109 @@
+"use strict";
+// REV-262: the selection half of the designed-paywall render contract v2
+// (revnix/cto-review/2026-09-03-paywall-render-contract-v2.md), kept pure so
+// the wire fixture can be walked without React Native.
+//
+// Mirrors revnix-app's src/lib/paywall-blocks/selection.ts: the dashboard
+// preview and this renderer must agree on which package is "selected", what
+// a block looks like in that state and whether it is drawn at all.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANVAS_MAX_WIDTH = void 0;
+exports.selectedPackageId = selectedPackageId;
+exports.packageContext = packageContext;
+exports.effectiveStyle = effectiveStyle;
+exports.isVisible = isVisible;
+exports.canvasMetrics = canvasMetrics;
+exports.resolveBlocks = resolveBlocks;
+const types_js_1 = require("./types.js");
+const tags_js_1 = require("./tags.js");
+/** The package a designed paywall is showing as chosen: the host's choice,
+ *  then the renderer's own after a tap, then the design's highlight, then the
+ *  first package — each only when the offering actually carries it. */
+function selectedPackageId(packages, ...candidates) {
+    for (const id of candidates) {
+        if (id !== undefined && packages.some((p) => p.packageId === id))
+            return id;
+    }
+    return packages[0]?.packageId;
+}
+/** The context a package-bearing card opens for itself and its subtree. */
+function packageContext(pkg, selectedId) {
+    if (pkg === undefined)
+        return undefined;
+    return pkg.packageId === selectedId ? "selected" : "unselected";
+}
+/** `selectedStyle` merged over `style` while selected; `style` otherwise. */
+function effectiveStyle(block, context) {
+    if (context === "selected" && block.selectedStyle) {
+        return { ...block.style, ...block.selectedStyle };
+    }
+    return block.style;
+}
+/** Whether a block is drawn. Outside any plan card every block is drawn,
+ *  whatever `visibility` says — a root block can never disappear. */
+function isVisible(block, context) {
+    if (block.visibility === undefined || context === undefined)
+        return true;
+    return (block.visibility === "selected") === (context === "selected");
+}
+/** Canvas designs are authored at 393×852 and scaled by width, capped so a
+ *  tablet or a landscape phone shows a centred phone-sized design instead of
+ *  a blown-up one. */
+exports.CANVAS_MAX_WIDTH = 480;
+function canvasMetrics(viewportWidth, viewportHeight) {
+    const scale = Math.min(viewportWidth, exports.CANVAS_MAX_WIDTH) / types_js_1.DESIGN_CANVAS.width;
+    const left = (viewportWidth - types_js_1.DESIGN_CANVAS.width * scale) / 2;
+    const designHeight = viewportHeight === null
+        ? types_js_1.DESIGN_CANVAS.height
+        : Math.max(types_js_1.DESIGN_CANVAS.height, viewportHeight / scale);
+    const scaledHeight = designHeight * scale;
+    const overflows = viewportHeight !== null && types_js_1.DESIGN_CANVAS.height * scale > viewportHeight + 1;
+    return { scale, left, designHeight, scaledHeight, overflows };
+}
+/** Walk a document exactly the way the renderer does — pinned cards judge
+ *  their own context, repeat cards yield one entry per package (keyed
+ *  `id@packageId`), hidden subtrees are not entered — and report what every
+ *  block resolves to. The wire fixture test reads this. */
+function resolveBlocks(doc, packages, selectedId) {
+    const out = new Map();
+    const root = packages.find((p) => p.packageId === selectedId) ?? packages[0];
+    const visit = (block, inherited, pkg, key) => {
+        if (block.type === "card" && block.repeat === "packages") {
+            const list = packages.length ? packages : [undefined];
+            for (const p of list) {
+                visitCard(block, packageContext(p, selectedId) ?? inherited, p ?? pkg, `${key}@${p?.packageId ?? "-"}`);
+            }
+            return;
+        }
+        if (block.type === "card" && block.packageIndex !== undefined) {
+            const own = packages[block.packageIndex];
+            if (own === undefined)
+                return; // dropped: the offering does not reach it
+            visitCard(block, packageContext(own, selectedId), own, key);
+            return;
+        }
+        const context = inherited;
+        const visible = isVisible(block, context);
+        const entry = { block, context, visible, style: effectiveStyle(block, context) };
+        if (block.type === "text")
+            entry.text = (0, tags_js_1.resolveTags)(block.text, pkg, packages);
+        if (block.type === "button")
+            entry.text = (0, tags_js_1.resolveTags)(block.label, pkg, packages);
+        out.set(key, entry);
+        if (visible && block.type === "card") {
+            for (const child of block.children)
+                visit(child, context, pkg, child.id);
+        }
+    };
+    const visitCard = (block, context, pkg, key) => {
+        const visible = isVisible(block, context);
+        out.set(key, { block, context, visible, style: effectiveStyle(block, context) });
+        if (!visible)
+            return;
+        for (const child of block.children)
+            visit(child, context, pkg, child.id);
+    };
+    for (const b of doc.blocks)
+        visit(b, undefined, root, b.id);
+    return out;
+}

package/dist/blocks/style.d.ts

@@ -0,0 +1,93 @@
+import type { TextStyle, ViewStyle } from "react-native";
+import type { BlockStyle, PaywallBlockDoc } from "./types.js";
+/**
+ * What a design font maps onto in the host app.
+ *
+ * On the web one family name covers every weight and the browser picks the
+ * face. React Native has no such indirection: each weight is a separately
+ * registered family (`PlusJakartaSans_700Bold`). So a mapping is either one
+ * family for everything, or a weight → family table, from which the nearest
+ * registered weight is chosen.
+ */
+export type FontMapping = string | Record<number, string> | undefined;
+export type FontFamilyMap = Record<string, FontMapping>;
+export interface StyleContext {
+    doc: PaywallBlockDoc;
+    /** Whether the renderer will paint gradient layers over this style's
+     *  background — true when the host passed a `gradient` component.
+     *
+     *  It decides whether a gradient `fill` degrades to its ground stop or is
+     *  left transparent for the real layers. Painting the stop UNDER a gradient
+     *  that will actually be drawn makes the box opaque, and 83 of the library's
+     *  139 gradient fills fade through a translucent stop — they sit over the
+     *  screen's photo precisely so it shows through. */
+    paintsGradients?: boolean;
+    /** Where a paint string this build cannot read is reported. Local only —
+     *  the style still resolves, to a colour from the design rather than to
+     *  black, so this is the only way a host learns it is approximating. */
+    onDiagnostic?: (message: string) => void;
+    /** Font size inherited from an ancestor, for em/multiplier conversions. */
+    fontSize: number;
+    /** Maps a design font family onto one the host app has registered. A name
+     *  that is absent, or maps to undefined, renders in the system font. */
+    fontFamilyMap?: FontFamilyMap;
+}
+/** The browser's default, which is what the dashboard preview inherits — a
+ *  block that sets no size of its own must come out the same size in both. */
+export declare const DEFAULT_FONT_SIZE = 16;
+/**
+ * Typography a container passes down to its subtree.
+ *
+ * CSS inherits `color`, `font-*`, `letter-spacing`, `line-height`,
+ * `text-align` and `text-transform` — a card that sets `textColor` restyles
+ * every descendant's text without touching them. React Native inherits none
+ * of that through Views, so the tree has to carry it explicitly or a design
+ * renders in the wrong color and size the moment a container sets the style
+ * instead of each leaf.
+ *
+ * `lineHeight` rides along as the CSS multiplier rather than points, because
+ * an unitless line-height is resolved against EACH element's own font size.
+ */
+export interface InheritedText {
+    color: string;
+    fontSize: number;
+    /** The DESIGN's family name, resolved to a registered one only once the
+     *  weight in force is known — RN selects a face by family name, so family
+     *  and weight cannot be decided independently. */
+    fontFamilyName?: string;
+    fontWeight?: TextStyle["fontWeight"];
+    fontStyle?: TextStyle["fontStyle"];
+    textAlign?: TextStyle["textAlign"];
+    textTransform?: TextStyle["textTransform"];
+    /** em, like the document; resolved per element. */
+    letterSpacing?: number;
+    /** Unitless multiplier, like the document; resolved per element. */
+    lineHeight?: number;
+}
+/** The inheritable half of a block's style, layered over what it inherited. */
+export declare function inherit(base: InheritedText, s: BlockStyle | undefined, ctx: StyleContext): InheritedText;
+/** Inherited typography as an RN style, with the em/multiplier units resolved
+ *  against the size that actually applies here, and the family resolved
+ *  against the weight in force. */
+export declare function inheritedTextStyle(t: InheritedText, ctx: StyleContext): TextStyle;
+/** The layout/paint half of a BlockStyle — everything a <View> understands. */
+export declare function toViewStyle(s: BlockStyle | undefined, ctx: StyleContext): ViewStyle;
+/** The typography half — everything a <Text> understands. */
+export declare function toTextStyle(s: BlockStyle | undefined, ctx: StyleContext): TextStyle;
+/**
+ * A design font renders only when the host app has registered it — RN cannot
+ * load a family by name at runtime. `fontFamilyMap` lets the app point a
+ * design's family at whatever it bundled (and drop the ones it did not), so an
+ * unregistered face falls back to the system font instead of, on Android,
+ * failing to render.
+ *
+ * The weight matters because RN picks a face by family NAME, not by
+ * `fontWeight`: asking for weight 800 of a family registered only at 400 gets
+ * a synthesised bold at best. Given a weight table, the nearest registered
+ * weight wins.
+ */
+export declare function resolveFontFamily(family: string | undefined, ctx: StyleContext, weight?: TextStyle["fontWeight"]): string | undefined;
+/** A `line` block is drawn from the current color at low alpha — the web
+ *  renderer uses `currentColor` with opacity, which RN has no notion of, so
+ *  the caller passes the color that is in force at that point in the tree. */
+export declare function hairlineColor(currentColor: string): string;