@symbiote-native/engine 0.1.0

package/build/status-bar/index.android.js

@@ -0,0 +1,83 @@
+// StatusBar on Android: drives the Android StatusBarManager from props (via
+// applyStatusBarProps) and from the static methods (statusBarImperative). Android's native
+// module is a DIFFERENT shape from iOS: single-arg setHidden(hidden) / setStyle(style) plus
+// setColor/setTranslucent, same module name ('StatusBarManager'). Metro picks this on an
+// Android host; iOS keeps its own shape. Each adapter wraps these with its declarative component.
+//
+// History: this used to be a no-op. Driving the window flags from our bridgeless surface
+// blanked the app: a status-bar relayout triggered stopSurface, which threw "Global was
+// not installed" because RN installs global.RN$stopSurface from its own renderer, which we
+// replace. Now that render.ts installs RN$stopSurface and tears surfaces down cleanly, the
+// relayout survives and the bar updates without blanking (verified on device: show/hide +
+// light/dark text). See render.ts installStopSurfaceGlobal + native-module-platform-routing.
+import { getNativeModule } from '../native-modules';
+import { processColor } from '../commit';
+import { dlog } from '../debug';
+import { STATUS_BAR_MANAGER } from './shared';
+// processColor returns `unknown` (its result is platform-dependent); narrow to the
+// number Fabric/native expects, like RN's invariant before setColor. A non-number
+// (null for an unparseable color, headless identity passthrough of a string) is dropped.
+function applyBackgroundColor(manager, color, animated) {
+    const processed = processColor(color);
+    if (typeof processed !== 'number') {
+        dlog(`StatusBar android: backgroundColor ${String(color)} did not process to an int — skipping`);
+        return;
+    }
+    // RISK: driving the window background flag once blanked the bridgeless surface
+    // (see header). Routed cleanly here but DEVICE-VERIFY-PENDING.
+    dlog(`StatusBar android setColor -> ${processed} animated=${animated}`);
+    manager.setColor(processed, animated);
+}
+// Apply a StatusBar component's props to the native module, same contract as iOS, with the
+// single-arg Android setters. The adapter calls this from its declarative component's effect,
+// on mount and on every prop change.
+export function applyStatusBarProps(props) {
+    const { barStyle, hidden, animated = false, backgroundColor, translucent } = props;
+    const manager = getNativeModule(STATUS_BAR_MANAGER);
+    if (manager === null) {
+        dlog('StatusBar android: StatusBarManager not resolvable — skipping');
+        return;
+    }
+    dlog(`StatusBar android -> barStyle=${barStyle} hidden=${hidden} translucent=${translucent} bg=${String(backgroundColor)}`);
+    if (barStyle !== undefined)
+        manager.setStyle(barStyle);
+    if (hidden !== undefined)
+        manager.setHidden(hidden);
+    if (translucent !== undefined)
+        manager.setTranslucent(translucent);
+    if (backgroundColor !== undefined)
+        applyBackgroundColor(manager, backgroundColor, animated);
+}
+export const statusBarImperative = {
+    setBarStyle(style) {
+        dlog(`StatusBar.setBarStyle android ${style}`);
+        getNativeModule(STATUS_BAR_MANAGER)?.setStyle(style);
+    },
+    setHidden(hidden) {
+        dlog(`StatusBar.setHidden android ${hidden}`);
+        getNativeModule(STATUS_BAR_MANAGER)?.setHidden(hidden);
+    },
+    setNetworkActivityIndicatorVisible() {
+        // No Android equivalent: an iOS-only concept.
+        dlog('StatusBar.setNetworkActivityIndicatorVisible (android no-op)');
+    },
+    setBackgroundColor(color, animated = false) {
+        dlog(`StatusBar.setBackgroundColor android ${String(color)}`);
+        const manager = getNativeModule(STATUS_BAR_MANAGER);
+        if (manager === null)
+            return;
+        applyBackgroundColor(manager, color, animated);
+    },
+    setTranslucent(translucent) {
+        // RISK: window translucent flag is device-verify-pending (may blank the surface).
+        dlog(`StatusBar.setTranslucent android ${translucent}`);
+        getNativeModule(STATUS_BAR_MANAGER)?.setTranslucent(translucent);
+    },
+};
+// Android exposes the bar height as a native constant; undefined if the module or the
+// constant is absent (older RN, or a fake that doesn't define getConstants). Read lazily
+// so nothing touches native at import time.
+export function statusBarCurrentHeight() {
+    return getNativeModule(STATUS_BAR_MANAGER)?.getConstants?.()
+        .HEIGHT;
+}

package/build/status-bar/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/status-bar/index.ios.d.ts

@@ -0,0 +1,5 @@
+import { type IStatusBarImperative, type IStatusBarProps } from './shared';
+export type { IStatusBarProps, IStatusBarStyle } from './shared';
+export declare function applyStatusBarProps(props: IStatusBarProps): void;
+export declare const statusBarImperative: IStatusBarImperative;
+export declare function statusBarCurrentHeight(): number | undefined;

package/build/status-bar/index.ios.js

@@ -0,0 +1,66 @@
+// StatusBar on iOS drives the iOS `StatusBarManager` TurboModule from props (via
+// applyStatusBarProps) and from the static methods (statusBarImperative). The native
+// contract is RN's spec at
+// .vendors/react-native/.../src/private/specs_DEPRECATED/modules/NativeStatusBarManagerIOS.js:
+//   setStyle(statusBarStyle?: string, animated: boolean)
+//   setHidden(hidden: boolean, withAnimation: 'none' | 'fade' | 'slide')
+//   setNetworkActivityIndicatorVisible(visible: boolean)
+// We mirror only those three setters as our hand-written interface: the typed trust
+// boundary getNativeModule<T> resolves against. Metro picks this on an iOS host; the base
+// status-bar.ts re-exports it for tsc / tsx / headless. Each adapter wraps these with its own
+// declarative component.
+import { getNativeModule } from '../native-modules';
+import { dlog } from '../debug';
+import { STATUS_BAR_MANAGER, STATIC_HIDE_TRANSITION, hideTransition, } from './shared';
+// Apply a StatusBar component's props to the native module. The adapter calls this from its
+// declarative component's effect, on mount and on every prop change. Resolves lazily inside
+// the call, not at import; keeps this module importable headless before a fake
+// __turboModuleProxy is installed. Non-enforcing: a declarative StatusBar must NOT crash the
+// whole render if the module can't resolve.
+//
+// Simplification vs RN: RN maintains a prop-merge stack so nested StatusBars compose
+// (deepest/last wins); we direct-apply a single component's props, which is correct for one
+// StatusBar and a fine first cut.
+export function applyStatusBarProps(props) {
+    const { barStyle, hidden, animated = false, networkActivityIndicatorVisible } = props;
+    const manager = getNativeModule(STATUS_BAR_MANAGER);
+    if (manager === null) {
+        dlog('StatusBar: StatusBarManager not resolvable via __turboModuleProxy — skipping');
+        return;
+    }
+    dlog('StatusBar -> applying props to StatusBarManager');
+    if (barStyle !== undefined)
+        manager.setStyle(barStyle, animated);
+    if (hidden !== undefined)
+        manager.setHidden(hidden, hideTransition(animated));
+    if (networkActivityIndicatorVisible !== undefined) {
+        manager.setNetworkActivityIndicatorVisible(networkActivityIndicatorVisible);
+    }
+}
+// The static API mirrors the declarative component: non-throwing, a missing optional
+// native module is a no-op, never a crash. Android-only setters are inert on iOS (the iOS
+// status bar has no background color and is never translucent in RN's sense).
+export const statusBarImperative = {
+    setBarStyle(style, animated = false) {
+        dlog('StatusBar.setBarStyle');
+        getNativeModule(STATUS_BAR_MANAGER)?.setStyle(style, animated);
+    },
+    setHidden(hidden, animation = STATIC_HIDE_TRANSITION) {
+        dlog('StatusBar.setHidden');
+        getNativeModule(STATUS_BAR_MANAGER)?.setHidden(hidden, animation);
+    },
+    setNetworkActivityIndicatorVisible(visible) {
+        dlog('StatusBar.setNetworkActivityIndicatorVisible');
+        getNativeModule(STATUS_BAR_MANAGER)?.setNetworkActivityIndicatorVisible(visible);
+    },
+    setBackgroundColor() {
+        dlog('StatusBar.setBackgroundColor (ios no-op)');
+    },
+    setTranslucent() {
+        dlog('StatusBar.setTranslucent (ios no-op)');
+    },
+};
+// currentHeight is Android-only; absent on iOS (RN sets it to null on iOS).
+export function statusBarCurrentHeight() {
+    return undefined;
+}

package/build/status-bar/index.js

@@ -0,0 +1,4 @@
+// Base / default StatusBar engine surface; re-exports the iOS build. Metro overrides this
+// with status-bar.ios.ts / .android.ts on a real host; under tsx / tsc / web the host config
+// resolves here. Filename is the selector, no Platform.OS read. See status-bar-shared.ts.
+export * from './index.ios';

package/build/status-bar/shared.d.ts

@@ -0,0 +1,22 @@
+import type { IColorValue } from '../platform-color';
+export type IStatusBarStyle = 'default' | 'light-content' | 'dark-content';
+export type IStatusBarAnimation = 'none' | 'fade' | 'slide';
+export declare const STATUS_BAR_MANAGER = "StatusBarManager";
+export declare const ANIMATED_HIDE_TRANSITION: IStatusBarAnimation;
+export declare const STATIC_HIDE_TRANSITION: IStatusBarAnimation;
+export declare function hideTransition(animated: boolean): IStatusBarAnimation;
+export interface IStatusBarProps {
+    barStyle?: IStatusBarStyle;
+    hidden?: boolean;
+    animated?: boolean;
+    networkActivityIndicatorVisible?: boolean;
+    backgroundColor?: IColorValue;
+    translucent?: boolean;
+}
+export interface IStatusBarImperative {
+    setBarStyle(style: IStatusBarStyle, animated?: boolean): void;
+    setHidden(hidden: boolean, animation?: IStatusBarAnimation): void;
+    setNetworkActivityIndicatorVisible(visible: boolean): void;
+    setBackgroundColor(color: IColorValue, animated?: boolean): void;
+    setTranslucent(translucent: boolean): void;
+}

package/build/status-bar/shared.js

@@ -0,0 +1,22 @@
+// StatusBar: shared contract. The component renders NO Fabric view; it imperatively
+// drives a status-bar native module. What DIVERGES by platform is the native module's
+// method shape: iOS's StatusBarManager takes `setStyle(style, animated)` /
+// `setHidden(hidden, withAnimation)`, while Android's takes single-arg `setStyle(style)` /
+// `setHidden(hidden)` plus `setColor` / `setTranslucent`, and driving those Android window
+// flags from our bridgeless surface blanks it (a window-insets relayout detaches the Fabric
+// surface). So the .ios/.android files own the native calls (applyStatusBarProps +
+// statusBarImperative); the types + the framework-agnostic imperative surface live here.
+// Filename selects, no Platform.OS read (see ADR 0012 + native_module_name_is_platform_specific).
+//
+// This is the engine half: pure types + the imperative API. Each adapter wraps it with a
+// per-framework declarative component (React FC + useEffect, Vue defineComponent + watchEffect)
+// that renders null and applies the props through applyStatusBarProps. The imperative API is
+// shared verbatim: a single StatusBarManager driver behind both adapters.
+export const STATUS_BAR_MANAGER = 'StatusBarManager';
+// RN's default hide/show transition when `animated` is true (showHideTransition
+// defaults to 'fade'); 'none' otherwise.
+export const ANIMATED_HIDE_TRANSITION = 'fade';
+export const STATIC_HIDE_TRANSITION = 'none';
+export function hideTransition(animated) {
+    return animated ? ANIMATED_HIDE_TRANSITION : STATIC_HIDE_TRANSITION;
+}

package/build/style/index.d.ts

@@ -0,0 +1 @@
+export declare function flattenStyle(style: unknown): Record<string, unknown>;

package/build/style/index.js

@@ -0,0 +1,30 @@
+// StyleSheet.flatten, ported. RN's idiom is `style={[base, override, cond && extra]}`,
+// an array of objects (and nested arrays) where later keys win. But Fabric's C++
+// reads a single flat props payload, so before we diff and commit we must collapse
+// that array into one plain object. This is the only place that collapse happens.
+//
+// Mirrors react-native/Libraries/StyleSheet/flattenStyle.js: recurse on the style
+// POSITION only, never on a property VALUE. `transform: [{translateX: 5}]` is an
+// array-valued prop and `shadowOffset: {width, height}` an object-valued prop; both
+// are copied through untouched. Only the top-level style slot is flattened.
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function flattenStyle(style) {
+    if (Array.isArray(style)) {
+        const result = {};
+        for (const entry of style) {
+            // Falsy entries (null/undefined/false/''/0) flatten to {} and contribute nothing.
+            const flat = flattenStyle(entry);
+            for (const key in flat) {
+                result[key] = flat[key];
+            }
+        }
+        return result;
+    }
+    if (isPlainObject(style)) {
+        // Shallow copy of own enumerable keys: values (arrays, nested objects) pass through.
+        return { ...style };
+    }
+    return {};
+}

package/build/style-registry/index.d.ts

@@ -0,0 +1,11 @@
+import type { IViewStyle, ITextStyle } from '../styles';
+type IResolvedStyle = Partial<IViewStyle & ITextStyle>;
+export type IClassNameValue = string | IResolvedStyle | Array<string | IResolvedStyle> | undefined | null;
+export declare function registerStyles(styles: Record<string, IResolvedStyle>): void;
+export declare function clearGlobalStyles(): void;
+export declare function isClassNameValue(value: unknown): value is IClassNameValue;
+export declare function resolveClassName(className: IClassNameValue): IResolvedStyle;
+export type IClassToggleMap = Record<string, boolean | undefined>;
+export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
+export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;
+export {};

package/build/style-registry/index.js

@@ -0,0 +1,165 @@
+// Runtime style registry, ported from wolf-tui's internal/shared/src/styles/registry.ts.
+// Side-effect CSS imports (compiled by the sibling CSS-to-style build package, not
+// this module) call registerStyles() with camelCase keys; components look them up
+// by resolveClassName(). No CSS parsing happens here — this is a Map<string, ...>
+// lookup, nothing more.
+//
+// Dropped vs the wolf-tui original: all Tailwind-utility detection (registerTailwind-
+// Metadata / isTailwindUtility / custom prefix-static sets) — this repo's style
+// surface has no Tailwind layer, so compound lookup below always runs for 2-4-part
+// class strings instead of being gated behind "no part looks like a utility class".
+//
+// kebab-case authoring: a CSS selector `.section-label` always registers under the
+// camelCase key `sectionLabel` (@symbiote-native/css-parser's extractClassName), so a template
+// can write EITHER `class="sectionLabel"` OR `class="section-label"` — resolveOne below
+// falls back to the kebab->camel form on a miss. Reinstated (wolf-tui had this, an
+// earlier port here dropped it on the assumption authors would always match the
+// camelCase key exactly) once that assumption proved wrong in practice.
+// Compound lookup tries every ordering of 2-4 space-separated class parts joined by
+// '.' (e.g. "btn primary" -> "btn.primary" / "primary.btn") before falling back to a
+// per-class merge, mirroring CSS compound-selector registration (`.btn.primary { }`).
+const COMPOUND_MIN_PARTS = 2;
+const COMPOUND_MAX_PARTS = 4;
+const globalStyles = new Map();
+// Called by generated code from side-effect style imports. Last import wins on a
+// name collision, matching CSS cascade behavior.
+export function registerStyles(styles) {
+    for (const [name, style] of Object.entries(styles)) {
+        globalStyles.set(name, style);
+    }
+}
+// Clears every registration; used between tests for isolation.
+export function clearGlobalStyles() {
+    globalStyles.clear();
+}
+// A `class`/`className` prop arrives as `unknown` at the routeProp boundary (any adapter can
+// hand over anything); this narrows before resolveClassName without an `as` cast. Shared with
+// adapters/vue/src/components/scroll-view/shared.ts's identical need, rather than each keeping
+// its own copy — that file imports this one instead of redeclaring it.
+export function isClassNameValue(value) {
+    return typeof value === 'string' || (typeof value === 'object' && value !== null);
+}
+export function resolveClassName(className) {
+    if (!className)
+        return {};
+    if (typeof className === 'object' && !Array.isArray(className)) {
+        return className;
+    }
+    if (Array.isArray(className)) {
+        return className.reduce((acc, item) => {
+            return { ...acc, ...resolveClassName(item) };
+        }, {});
+    }
+    const trimmed = className.trim();
+    if (!trimmed)
+        return {};
+    const exactMatch = globalStyles.get(trimmed) ?? globalStyles.get(kebabToCamel(trimmed));
+    if (exactMatch)
+        return exactMatch;
+    const parts = trimmed.split(/\s+/).filter(Boolean);
+    if (parts.length >= COMPOUND_MIN_PARTS && parts.length <= COMPOUND_MAX_PARTS) {
+        const compound = tryCompoundLookup(parts);
+        if (compound)
+            return compound;
+    }
+    return parts.reduce((acc, cls) => {
+        return { ...acc, ...resolveOne(cls) };
+    }, {});
+}
+function generateCompoundPermutations(parts) {
+    if (parts.length < COMPOUND_MIN_PARTS)
+        return [];
+    const compounds = [];
+    for (let size = COMPOUND_MIN_PARTS; size <= parts.length; size++) {
+        compounds.push(...generateKPermutations(parts, size));
+    }
+    return compounds;
+}
+function generateKPermutations(parts, size) {
+    if (size === 0)
+        return [''];
+    if (parts.length === 0)
+        return [];
+    const result = [];
+    function helper(current, remaining, depth) {
+        if (depth === size) {
+            result.push(toCompoundKey(current));
+            return;
+        }
+        for (let i = 0; i < remaining.length; i++) {
+            helper([...current, remaining[i]], remaining.slice(0, i).concat(remaining.slice(i + 1)), depth + 1);
+        }
+    }
+    helper([], parts, 0);
+    return result;
+}
+// wolf-tui joins a compound permutation with '.' ("btn.primary") because its CSS
+// pipeline registers dot-joined selector strings. This repo's CSS-to-style compiler
+// emits plain camelCase keys for every class, single or compound, so "btn primary"
+// must resolve against a registered "btnPrimary" instead.
+function toCompoundKey(parts) {
+    return parts.reduce((key, part, index) => (index === 0 ? part : key + capitalize(part)), '');
+}
+function capitalize(value) {
+    return value.length === 0 ? value : value[0].toUpperCase() + value.slice(1);
+}
+// Duplicated from @symbiote-native/css-parser's identical helper rather than imported: css-parser
+// pulls in postcss and is build-time only (never shipped in the app bundle), and this registry
+// is the opposite — pure runtime, in every app bundle — so importing it here would leak a
+// build-time dependency into the shipped app. The conversion itself is two lines; keeping both
+// copies in sync is a smaller cost than the alternative.
+function kebabToCamel(value) {
+    return value.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function tryCompoundLookup(parts) {
+    if (parts.length < COMPOUND_MIN_PARTS)
+        return null;
+    for (const compound of generateCompoundPermutations(parts)) {
+        const style = globalStyles.get(compound);
+        if (style)
+            return style;
+    }
+    return null;
+}
+function resolveOne(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        return {};
+    return globalStyles.get(trimmed) ?? globalStyles.get(kebabToCamel(trimmed)) ?? {};
+}
+// Pure NAME rewriter for Vue `<style scoped>`: suffixes every class token that this
+// file's scoped block locally defines with `__${scopeId}`, leaving unrecognized tokens
+// (globals, external classes) untouched. Runs at the compiled call site BEFORE Vue's own
+// normalizeClass() collapses string/object/array `class` values to a final string, so it
+// must pre-process all three shapes normalizeClass understands. No registry lookup here —
+// resolveClassName still does the actual style lookup, unchanged, against the rewritten name.
+export function scopeClassName(value, localNames, scopeId) {
+    if (value === undefined || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(item => scopeClassEntry(item, localNames, scopeId));
+    }
+    return scopeClassEntry(value, localNames, scopeId);
+}
+// A token arrives as either the camelCase registry key (`sectionLabel`) or its kebab-case
+// authoring form (`section-label`) — normalize to camelCase FIRST, then decide scoping, so
+// `localNames` (always camelCase, built from the css-parser's registered keys) recognizes a
+// kebab-written token. The emitted (possibly suffixed) name is always the camelCase form.
+function scopeToken(token, localNames, scopeId) {
+    const camelToken = kebabToCamel(token);
+    return localNames.has(camelToken) ? `${camelToken}__${scopeId}` : camelToken;
+}
+function scopeClassEntry(value, localNames, scopeId) {
+    if (typeof value === 'object') {
+        const scoped = {};
+        for (const [name, enabled] of Object.entries(value)) {
+            scoped[scopeToken(name, localNames, scopeId)] = enabled;
+        }
+        return scoped;
+    }
+    return value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(token => scopeToken(token, localNames, scopeId))
+        .join(' ');
+}

package/build/style-sheet/index.d.ts

@@ -0,0 +1,20 @@
+import type { INamedStyles, IViewStyle, ITextStyle } from '../styles';
+type IStyleRecord = Record<string, IViewStyle | ITextStyle>;
+type IStyleObject = Record<string, unknown>;
+export declare function computeHairlineWidth(scale: number): number;
+declare function compose<A, B>(style1: A, style2: B): A | B | [A, B];
+type IStylePreprocessor = (value: unknown) => unknown;
+declare function setStyleAttributePreprocessor(property: string, process: IStylePreprocessor): void;
+declare function flattenWithPreprocessors(style: unknown): Record<string, unknown>;
+declare function roundToNearestPixel(value: number): number;
+export declare const StyleSheet: {
+    create<T extends INamedStyles<T> | IStyleRecord>(styles: T & IStyleRecord): T;
+    flatten: typeof flattenWithPreprocessors;
+    compose: typeof compose;
+    setStyleAttributePreprocessor: typeof setStyleAttributePreprocessor;
+    roundToNearestPixel: typeof roundToNearestPixel;
+    absoluteFill: Readonly<IStyleObject>;
+    absoluteFillObject: Readonly<IStyleObject>;
+    readonly hairlineWidth: number;
+};
+export {};

package/build/style-sheet/index.js

@@ -0,0 +1,121 @@
+// StyleSheet, ported from react-native/Libraries/StyleSheet/StyleSheetExports.js.
+// RN's StyleSheet is mostly identity + small helpers: `create` returns the object
+// untouched (no deep-freeze by default in modern RN), `flatten` collapses a style
+// array, `compose` picks/pairs two styles, plus the `hairlineWidth` / `absoluteFill`
+// constants. The typed ViewStyle/TextStyle live next door in styles.ts, so `create`
+// is typed against them like RN's, not left generic over a plain Record.
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+import { flattenStyle } from '../style';
+// RN's hairline factor: a "1 physical pixel" line is ~0.4 logical px, rounded to the
+// nearest device pixel. Named so the 0.4 isn't a bare magic number (RN source uses
+// the same literal in PixelRatio.roundToNearestPixel(0.4)).
+const HAIRLINE_LOGICAL_FACTOR = 0.4;
+// Fallback when DeviceInfo isn't resolvable (headless, or before native bring-up).
+// RN can't run without it; we degrade to a sane 1px line rather than crash.
+const HAIRLINE_FALLBACK = 1;
+// Resolve the screen pixel scale lazily from native, or null when unavailable.
+// Lazy (not at import) so this module is importable headless before a fake
+// __turboModuleProxy exists, same precedent as StatusBar's in-effect resolve.
+function resolveScreenScale() {
+    const deviceInfo = getNativeModule('DeviceInfo');
+    if (deviceInfo === null) {
+        dlog('StyleSheet: DeviceInfo not resolvable — hairlineWidth falls back');
+        return null;
+    }
+    const dimensions = deviceInfo.getConstants().Dimensions;
+    const scale = dimensions.window?.scale ?? dimensions.windowPhysicalPixels?.scale;
+    // A non-positive scale would make the round/divide nonsensical; treat as missing.
+    if (typeof scale !== 'number' || scale <= 0) {
+        dlog(`StyleSheet: DeviceInfo scale invalid (${String(scale)}) — hairlineWidth falls back`);
+        return null;
+    }
+    return scale;
+}
+// Compute the hairline width for a given scale, mirroring RN exactly: round the
+// logical factor to the nearest device pixel, and if that rounds to 0 (scale < ~1.25)
+// fall back to the thinnest representable line, one physical pixel = 1 / scale.
+// Exported as a pure helper so the smoke can check the formula without faking native.
+export function computeHairlineWidth(scale) {
+    const rounded = Math.round(HAIRLINE_LOGICAL_FACTOR * scale) / scale;
+    return rounded === 0 ? 1 / scale : rounded;
+}
+// RN freezes absoluteFill in __DEV__; we always freeze so `absoluteFill` and
+// `absoluteFillObject` can safely be the same shared object.
+const absoluteFill = Object.freeze({
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+});
+// RN's composeStyles: falsy left → right, falsy right → left, else the pair [a, b]
+// (which flatten later collapses, later keys winning).
+function compose(style1, style2) {
+    if (style1 === null || style1 === undefined)
+        return style2;
+    if (style2 === null || style2 === undefined)
+        return style1;
+    return [style1, style2];
+}
+const stylePreprocessors = new Map();
+// Register a value-rewriter for one style property (RN's setStyleAttributePreprocessor,
+// StyleSheetExports.js:151). EXPERIMENTAL in RN; used internally for color/transform.
+// Overwriting an existing preprocessor warns, matching RN's __DEV__ guard.
+function setStyleAttributePreprocessor(property, process) {
+    if (stylePreprocessors.has(property)) {
+        dlog(`StyleSheet.setStyleAttributePreprocessor: overwriting "${property}" preprocessor`);
+    }
+    stylePreprocessors.set(property, process);
+}
+// Flatten, then run any registered preprocessor over the matching keys. Kept as a
+// wrapper over the single flattenStyle collapse so the preprocessor map is applied
+// exactly once, at the same seam RN applies it (the style->payload boundary), without
+// reaching into the commit path.
+function flattenWithPreprocessors(style) {
+    const flat = flattenStyle(style);
+    if (stylePreprocessors.size === 0)
+        return flat;
+    for (const [property, process] of stylePreprocessors) {
+        if (Object.hasOwn(flat, property)) {
+            flat[property] = process(flat[property]);
+        }
+    }
+    return flat;
+}
+// Snap a dp size to the nearest value that maps to a whole number of device pixels.
+// RN's StyleSheet.roundToNearestPixel delegates to PixelRatio.roundToNearestPixel
+// (Math.round(size * scale) / scale). PixelRatio lives in the react adapter, which
+// shared cannot import, so the same math runs here over the scale shared already
+// resolves; an unresolvable scale (headless) leaves the value unrounded.
+function roundToNearestPixel(value) {
+    const scale = resolveScreenScale();
+    if (scale === null)
+        return value;
+    return Math.round(value * scale) / scale;
+}
+export const StyleSheet = {
+    // Identity at runtime, like RN, but the NamedStyles constraint preserves each
+    // string-literal style value (flexDirection: 'row' stays 'row', not string) and
+    // validates entries, so `styles.box` is assignable to a ViewStyle prop.
+    create(styles) {
+        return styles;
+    },
+    // Reuse the single flatten implementation; do not reimplement the clone-on-write
+    // collapse here. The wrapper additionally applies any registered per-attribute
+    // preprocessor as the style collapses to its flat payload.
+    flatten: flattenWithPreprocessors,
+    compose,
+    setStyleAttributePreprocessor,
+    roundToNearestPixel,
+    absoluteFill,
+    absoluteFillObject: absoluteFill,
+    // Lazy compute, recomputed each read (cheap, and avoids caching a fallback taken
+    // before native was ready). RN memoizes; we keep it simple until that's a cost.
+    get hairlineWidth() {
+        const scale = resolveScreenScale();
+        if (scale === null)
+            return HAIRLINE_FALLBACK;
+        return computeHairlineWidth(scale);
+    },
+};