@symbiote-native/engine 0.1.0

package/build/process-transform-origin/index.js

@@ -0,0 +1,108 @@
+// JS-side port of RN's processTransformOrigin (Libraries/StyleSheet/processTransformOrigin.js).
+// Same root cause as boxShadow/filter: ReactNativeStyleAttributes registers `transformOrigin`
+// with `nativeCSSParsing ? true : {process: processTransformOrigin}`, and enableNativeCSSParsing()
+// DEFAULTS TO FALSE, so RN's stock path runs processTransformOrigin IN JS, turning the CSS
+// string ('top left') into the [x, y, z] array native expects. symbiote forwarded the raw
+// string: iOS native tolerated it, Android native casts it to ReadableArray and crashes with
+// `java.lang.String cannot be cast to com.facebook.react.bridge.ReadableArray`. This restores
+// the missing JS parse so native always receives the [x, y, z] array.
+//
+// RN throws via invariant() on a malformed value; we instead dlog and keep the partial array
+// (matching the boxShadow/filter idiom of never throwing into the commit path).
+import { dlog } from '../debug';
+// RN processTransformOrigin.js:14, pre-compiled pattern matching each keyword / length token.
+const TRANSFORM_ORIGIN_REGEX = /(top|bottom|left|right|center|\d+(?:%|px)|0)/gi;
+// RN processTransformOrigin.js:16-18.
+const INDEX_X = 0;
+const INDEX_Y = 1;
+const INDEX_Z = 2;
+// RN processTransformOrigin.js:21-120. Parses the CSS string into the [x, y, z] array,
+// or normalizes/passes through an array input unchanged.
+export function processTransformOrigin(transformOrigin) {
+    if (transformOrigin == null) {
+        // RN never receives undefined here (the registry only calls the processor for a
+        // present value), but the commit path may; default to center/center/0.
+        return ['50%', '50%', 0];
+    }
+    if (typeof transformOrigin !== 'string') {
+        // Array input passes through, like RN (which only re-validates in __DEV__).
+        return transformOrigin;
+    }
+    const transformOriginString = transformOrigin;
+    TRANSFORM_ORIGIN_REGEX.lastIndex = 0;
+    const transformOriginArray = ['50%', '50%', 0];
+    let index = INDEX_X;
+    let matches;
+    outer: while ((matches = TRANSFORM_ORIGIN_REGEX.exec(transformOriginString))) {
+        let nextIndex = index + 1;
+        const value = matches[0];
+        const valueLower = value.toLowerCase();
+        switch (valueLower) {
+            case 'left':
+            case 'right': {
+                // RN processTransformOrigin.js:42-46, left/right are x-only.
+                if (index !== INDEX_X) {
+                    dlog(`processTransformOrigin reject: "${value}" can only be used for x-position`);
+                    return transformOriginArray;
+                }
+                transformOriginArray[INDEX_X] = valueLower === 'left' ? 0 : '100%';
+                break;
+            }
+            case 'top':
+            case 'bottom': {
+                // RN processTransformOrigin.js:52-56, top/bottom are not valid for z.
+                if (index === INDEX_Z) {
+                    dlog(`processTransformOrigin reject: "${value}" can only be used for y-position`);
+                    return transformOriginArray;
+                }
+                transformOriginArray[INDEX_Y] = valueLower === 'top' ? 0 : '100%';
+                // RN processTransformOrigin.js:59-86, handle [[ center | left | right ] &&
+                // [ center | top | bottom ]] <length>?  When y came first, the next token is x.
+                if (index === INDEX_X) {
+                    const horizontal = TRANSFORM_ORIGIN_REGEX.exec(transformOriginString);
+                    if (horizontal == null) {
+                        break outer;
+                    }
+                    switch (horizontal[0].toLowerCase()) {
+                        case 'left':
+                            transformOriginArray[INDEX_X] = 0;
+                            break;
+                        case 'right':
+                            transformOriginArray[INDEX_X] = '100%';
+                            break;
+                        case 'center':
+                            transformOriginArray[INDEX_X] = '50%';
+                            break;
+                        default:
+                            dlog(`processTransformOrigin reject: could not parse "${transformOriginString}"`);
+                            return transformOriginArray;
+                    }
+                    nextIndex = INDEX_Z;
+                }
+                break;
+            }
+            case 'center': {
+                // RN processTransformOrigin.js:91-95, center is invalid for z.
+                if (index === INDEX_Z) {
+                    dlog(`processTransformOrigin reject: "${value}" cannot be used for z-position`);
+                    return transformOriginArray;
+                }
+                transformOriginArray[index] = '50%';
+                break;
+            }
+            default: {
+                // RN processTransformOrigin.js:99-105, a percentage stays a string, a length
+                // drops its `px` and becomes a number.
+                if (value.endsWith('%')) {
+                    transformOriginArray[index] = value;
+                }
+                else {
+                    transformOriginArray[index] = parseFloat(value);
+                }
+                break;
+            }
+        }
+        index = nextIndex;
+    }
+    return transformOriginArray;
+}

package/build/registry.d.ts

@@ -0,0 +1,31 @@
+export type IPropProcessor = (value: unknown) => unknown;
+export interface INativeEventBinding {
+    raw: string;
+    listener: string;
+    direct?: boolean;
+}
+export interface IComponentRegistration {
+    events?: readonly INativeEventBinding[];
+    processors?: Readonly<Record<string, IPropProcessor>>;
+}
+interface IPhasedRegistrationNames {
+    bubbled?: string;
+}
+interface IBubblingEventType {
+    phasedRegistrationNames?: IPhasedRegistrationNames;
+}
+interface IDirectEventType {
+    registrationName?: string;
+}
+export interface INativeViewConfig {
+    bubblingEventTypes?: Record<string, IBubblingEventType | null | undefined>;
+    directEventTypes?: Record<string, IDirectEventType | null | undefined>;
+    validAttributes?: Record<string, unknown>;
+}
+export type INativeViewConfigSource = (name: string) => INativeViewConfig | undefined;
+export declare function setNativeViewConfigSource(source: INativeViewConfigSource): void;
+export declare function registerComponent(name: string, registration?: IComponentRegistration): void;
+export declare function isRegisteredEvent(component: string, listener: string): boolean;
+export declare function registeredNativeEvent(component: string, raw: string): INativeEventBinding | undefined;
+export declare function registeredProcessor(component: string, key: string): IPropProcessor | undefined;
+export {};

package/build/registry.js

@@ -0,0 +1,145 @@
+// Runtime metadata for native Fabric views, DERIVED BY DEFAULT. Any RN library
+// already ships its own ViewConfig: codegen registers it into RN's
+// ReactNativeViewConfigRegistry the moment the library's native-component module is
+// imported. That config carries everything the shared engine can't infer: which
+// events the view emits (bubblingEventTypes / directEventTypes) and how to process
+// its props (validAttributes[*].process, e.g. processColor). So we DON'T transcribe
+// any of it, and we don't mark anything "third-party": there is no
+// per-package registration to maintain. The engine reads the config for ANY
+// component on first use. Install a community view library, render it, done.
+//
+// shared must stay react-native-free (the headless harness runs in plain Node), so
+// the ViewConfig lookup is INJECTED, exactly like the color processor: the adapter
+// wires `setNativeViewConfigSource(ReactNativeViewConfigRegistry.get)` on a real
+// host (on a real host that one source covers BOTH RN core and every library).
+//
+// The ONLY explicit list is OUR OWN built-in primitives (BUILTIN_COMPONENTS): a
+// finite set we own, which keep their hand-tuned tables (view-config events, commit
+// COLOR_PROPS) and are never read from the source, so they can't drift. Everything
+// NOT in that set derives. The list never grows with the community; it grows only
+// when we add a core primitive of our own.
+const EMPTY = { listeners: new Set(), byRaw: new Map(), processors: new Map() };
+// OUR own primitives: the finite set shared hand-tunes (view-config events,
+// commit COLOR_PROPS). The source is never consulted for these, so they can't
+// drift. Everything else derives. This list grows only when WE add a core
+// primitive, never for a community package.
+const BUILTIN_COMPONENTS = new Set([
+    'RCTView',
+    'RCTText',
+    'RCTRawText',
+    'RCTVirtualText',
+    'RCTImageView',
+    'RCTScrollView',
+    'RCTScrollContentView',
+    'RCTSinglelineTextInputView',
+    'RCTMultilineTextInputView',
+    'Switch',
+    'ActivityIndicatorView',
+    'SafeAreaView',
+    'ModalHostView',
+    'PullToRefreshView',
+    'RCTInputAccessoryView',
+]);
+// Manual overrides per component (usually none): the escape hatch.
+const overrides = new Map();
+const resolvedCache = new Map();
+let viewConfigSource;
+// Wired once by the adapter on a real host: `name => ReactNativeViewConfigRegistry.get(name)`.
+export function setNativeViewConfigSource(source) {
+    viewConfigSource = source;
+    resolvedCache.clear();
+}
+// Escape hatch: override a derived config, or supply one for a view with no codegen
+// ViewConfig. NOT needed on the common path; views derive from the source.
+export function registerComponent(name, registration = {}) {
+    const list = overrides.get(name);
+    if (list === undefined)
+        overrides.set(name, [registration]);
+    else
+        list.push(registration);
+    resolvedCache.delete(name);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+// onChange -> change (mirrors node.ts listenerName; the split of the handler prop).
+function splitListener(handlerProp) {
+    return handlerProp.charAt(2).toLowerCase() + handlerProp.slice(3);
+}
+function addEvent(into, binding) {
+    into.listeners.add(binding.listener);
+    into.byRaw.set(binding.raw, binding);
+}
+function deriveFromConfig(config, into) {
+    const { bubblingEventTypes, directEventTypes, validAttributes } = config;
+    if (bubblingEventTypes) {
+        for (const raw in bubblingEventTypes) {
+            const bubbled = bubblingEventTypes[raw]?.phasedRegistrationNames?.bubbled;
+            if (typeof bubbled === 'string')
+                addEvent(into, { raw, listener: splitListener(bubbled) });
+        }
+    }
+    if (directEventTypes) {
+        for (const raw in directEventTypes) {
+            const registrationName = directEventTypes[raw]?.registrationName;
+            if (typeof registrationName === 'string') {
+                addEvent(into, { raw, listener: splitListener(registrationName), direct: true });
+            }
+        }
+    }
+    if (validAttributes) {
+        for (const key in validAttributes) {
+            const attribute = validAttributes[key];
+            if (isRecord(attribute)) {
+                const process = attribute.process;
+                // The codegen config already carries the right processor (processColor, …);
+                // wrap it so the typed Function becomes a PropProcessor without a cast.
+                if (typeof process === 'function')
+                    into.processors.set(key, value => process(value));
+            }
+        }
+    }
+}
+function applyRegistration(registration, into) {
+    if (registration.events)
+        for (const binding of registration.events)
+            addEvent(into, binding);
+    if (registration.processors) {
+        for (const key of Object.keys(registration.processors)) {
+            into.processors.set(key, registration.processors[key]);
+        }
+    }
+}
+// Resolve a component's metadata. OUR built-ins short-circuit to EMPTY so the
+// source is never read for them (their hand-tuned tables stand). Everything else
+// derives from the injected source, then any manual override wins on top.
+function resolve(name) {
+    if (BUILTIN_COMPONENTS.has(name))
+        return EMPTY;
+    let resolved = resolvedCache.get(name);
+    if (resolved !== undefined)
+        return resolved;
+    resolved = { listeners: new Set(), byRaw: new Map(), processors: new Map() };
+    const config = viewConfigSource?.(name);
+    if (config)
+        deriveFromConfig(config, resolved);
+    const registrations = overrides.get(name);
+    if (registrations)
+        for (const registration of registrations)
+            applyRegistration(registration, resolved);
+    resolvedCache.set(name, resolved);
+    return resolved;
+}
+// True when `listener` is an event the (third-party) component emits.
+export function isRegisteredEvent(component, listener) {
+    return resolve(component).listeners.has(listener);
+}
+// The binding for a raw Fabric event on this component, for incoming dispatch.
+export function registeredNativeEvent(component, raw) {
+    return resolve(component).byRaw.get(raw);
+}
+// The processor for a prop of this component (e.g. processColor for a tint), or
+// undefined to leave the value untouched.
+export function registeredProcessor(component, key) {
+    return resolve(component).processors.get(key);
+}

package/build/settings/index.d.ts

@@ -0,0 +1,8 @@
+declare class SettingsImpl {
+    get(key: string): unknown;
+    set(settings: Record<string, unknown>): void;
+    watchKeys(keys: string | string[], callback: () => void): number;
+    clearWatch(watchId: number): void;
+}
+export declare const Settings: SettingsImpl;
+export {};

package/build/settings/index.js

@@ -0,0 +1,126 @@
+// Settings module: reads/writes the app's persisted defaults (iOS NSUserDefaults
+// via the native SettingsManager). A JS-side snapshot seeded from the native module
+// constants answers `get`; `set` writes through to native and updates the snapshot;
+// `watchKeys`/`clearWatch` are a pure-JS subscription registry that fires when a
+// watched key's value changes. Native re-broadcasts external edits through the
+// device event `settingsUpdated`, which feeds the same change->fire path. Mirrors
+// RN's Libraries/Settings/Settings.ios.js, iOS surface only.
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events';
+import { getNativeModule } from '../native-modules';
+import { dlog } from '../debug';
+// The iOS native module name RN registers this under. NOTE: this is the name the
+// iOS JS wrapper resolves via `TurboModuleRegistry.getEnforcing('SettingsManager')`.
+// The spec filename is `INativeSettingsManager`. Per the symbiote invariant, a
+// module name is only provable on a real host (a headless fake answers to any
+// name); this iOS name is device-verify-pending.
+// See .docs/native-module-platform-routing.md.
+const SETTINGS_MODULE = 'SettingsManager';
+// The device event native emits when the app's defaults change out from under JS
+// (e.g. a Settings.bundle edit). Its payload is a record of changed key->value.
+const SETTINGS_UPDATED_EVENT = 'settingsUpdated';
+// watchIds are handed out as the registry index, so the first watcher is 0. A
+// cleared slot keeps its index (the array never shrinks) so later ids stay stable.
+const FIRST_WATCH_ID = 0;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+// Lazily resolved so importing this module has no native side effect. `null` when
+// the module isn't linked (headless): the snapshot then starts empty and `set`
+// updates only JS state + fires watchers.
+let settingsModule;
+function getModule() {
+    if (settingsModule === undefined) {
+        settingsModule = getNativeModule(SETTINGS_MODULE);
+        dlog(`Settings: module ${settingsModule ? 'resolved' : 'NOT resolved (null)'}`);
+    }
+    return settingsModule;
+}
+// The JS-side mirror of native defaults: seeded once from the module constants,
+// kept in sync by `set` and by the `settingsUpdated` device event.
+let snapshot;
+function getSnapshot() {
+    if (snapshot === undefined) {
+        const module = getModule();
+        const constants = module?.getConstants().settings;
+        snapshot = isRecord(constants) ? { ...constants } : {};
+        dlog(`Settings: snapshot seeded with ${Object.keys(snapshot).length} key(s)`);
+    }
+    return snapshot;
+}
+const subscriptions = [];
+// Fire every watcher whose key set covers `key`. Called only for keys that changed.
+function fireWatchers(key) {
+    for (const sub of subscriptions) {
+        if (sub.callback !== null && sub.keys.includes(key))
+            sub.callback();
+    }
+}
+// Fold a batch of new values into the snapshot, firing watchers for each key whose
+// value actually changed. Shared by `set` (JS-originated) and the device event
+// (native-originated), matching RN's `_sendObservations`.
+function applyChanges(values) {
+    const current = getSnapshot();
+    for (const key of Object.keys(values)) {
+        const next = values[key];
+        const didChange = current[key] !== next;
+        current[key] = next;
+        if (didChange)
+            fireWatchers(key);
+    }
+}
+let emitter;
+// Subscribe to native's `settingsUpdated` so external edits flow into the snapshot.
+// WHY lazy + module-gated: importing this file must have no native side effect, and
+// with no native module there is nothing native to observe, so a headless run that
+// never installs the device hub doesn't crash. Idempotent.
+function subscribeToNative() {
+    if (emitter !== undefined)
+        return;
+    const module = getModule();
+    if (module === null)
+        return;
+    installDeviceEventHub();
+    emitter = new NativeEventEmitter(module);
+    emitter.addListener(SETTINGS_UPDATED_EVENT, payload => {
+        if (!isRecord(payload))
+            return;
+        applyChanges(payload);
+    });
+}
+class SettingsImpl {
+    // Read the current value for `key` from the JS snapshot. `undefined` if unset.
+    get(key) {
+        subscribeToNative();
+        return getSnapshot()[key];
+    }
+    // Persist `settings` to native, update the snapshot, and fire watchers for the
+    // keys that changed. Without a native module (headless) only JS state updates.
+    set(settings) {
+        subscribeToNative();
+        const module = getModule();
+        if (module === null) {
+            dlog('Settings.set -> no module (JS snapshot + watchers only)');
+        }
+        else {
+            module.setValues(settings);
+        }
+        applyChanges(settings);
+    }
+    // Register a watcher for one or more keys. Returns a numeric watchId (the registry
+    // index) to pass to `clearWatch`.
+    watchKeys(keys, callback) {
+        subscribeToNative();
+        const watched = typeof keys === 'string' ? [keys] : keys;
+        const watchId = subscriptions.length + FIRST_WATCH_ID;
+        subscriptions.push({ keys: watched, callback });
+        return watchId;
+    }
+    // Disarm the watcher with the given id. Its slot is emptied (kept, not removed) so
+    // every other watchId stays valid.
+    clearWatch(watchId) {
+        if (watchId >= FIRST_WATCH_ID && watchId < subscriptions.length) {
+            subscriptions[watchId] = { keys: [], callback: null };
+        }
+    }
+}
+export const Settings = new SettingsImpl();

package/build/share/index.android.d.ts

@@ -0,0 +1,3 @@
+import type { IShareStatic } from './shared';
+export type { IShareContent, IShareOptions, IShareAction } from './shared';
+export declare const Share: IShareStatic;

package/build/share/index.android.js

@@ -0,0 +1,56 @@
+// Share (Android build). The native module is `ShareModule`:
+// `share(content, dialogTitle?) -> Promise<{ action }>`. We validate content, build the
+// content dict (title/message), forward the dialog title, and map the resolved action
+// onto the shared IShareAction shape; Android has no dismiss path, so RN fills the
+// missing activityType with null. Metro picks this file on an Android host. See ADR 0019.
+//
+// device-verify-pending: the `ShareModule` name matches NativeShareModule's
+// TurboModuleRegistry.get('ShareModule') from RN source, but headless fakes resolve any
+// name, so it is only proven on a real Android host (a bridgeless resolution log there).
+// See .docs/native-module-platform-routing.md, ADR 0012.
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION } from './shared';
+const SHARE_MODULE = 'ShareModule';
+// ShareModule.share resolves an untyped value at the native boundary; narrow it before
+// reading `action` (no `as`).
+function isShareResult(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'action' in value &&
+        typeof value.action === 'string');
+}
+export const Share = {
+    ...shareActions,
+    // Open the Android share dialog for `content`. Resolves with the user's action
+    // (Android always resolves sharedAction); rejects on invalid content, an unexpected
+    // native result, or a missing module (explicit reject, never a hung Promise).
+    share(content, options = {}) {
+        const invalid = validateContent(content);
+        if (invalid !== null) {
+            dlog(`Share.share -> invalid content: ${invalid.message}`);
+            return Promise.reject(invalid);
+        }
+        dlog('Share.share (android)');
+        const shareModule = getNativeModule(SHARE_MODULE);
+        if (shareModule === null) {
+            dlog(`Share: "${SHARE_MODULE}" unresolved`);
+            return Promise.reject(new Error('Share: ShareModule native module unavailable'));
+        }
+        const newContent = {
+            title: content.title,
+            message: typeof content.message === 'string' ? content.message : undefined,
+        };
+        return shareModule.share(newContent, options.dialogTitle).then(result => {
+            if (!isShareResult(result)) {
+                dlog('Share.share -> android result missing action');
+                throw new Error('Share: ShareModule returned an unexpected result');
+            }
+            dlog(`Share.share -> android action=${result.action}`);
+            return {
+                action: result.action === DISMISSED_ACTION ? DISMISSED_ACTION : SHARED_ACTION,
+                activityType: null,
+            };
+        });
+    },
+};

package/build/share/index.d.ts

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

package/build/share/index.ios.d.ts

@@ -0,0 +1,3 @@
+import type { IShareStatic } from './shared';
+export type { IShareContent, IShareOptions, IShareAction } from './shared';
+export declare const Share: IShareStatic;

package/build/share/index.ios.js

@@ -0,0 +1,47 @@
+// Share, iOS build. The native module is `ActionSheetManager` (there is NO ShareModule
+// on iOS; that is the Android module); the share sheet is driven by its callback-style
+// `showShareActionSheetWithOptions(options, failure, success)`. We validate content, map
+// options onto the native share options, and resolve the IShareAction from the success
+// callback. Metro picks this file on an iOS host; the base share.ts re-exports it for
+// web/headless. See ADR 0019.
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION } from './shared';
+const ACTION_SHEET_MANAGER = 'ActionSheetManager';
+export const Share = {
+    ...shareActions,
+    // Open the iOS share sheet for `content`. Resolves with the user's action
+    // (sharedAction / dismissedAction); rejects on invalid content, a native failure,
+    // or a missing module (explicit reject rather than a Promise that never settles).
+    share(content, options = {}) {
+        const invalid = validateContent(content);
+        if (invalid !== null) {
+            dlog(`Share.share -> invalid content: ${invalid.message}`);
+            return Promise.reject(invalid);
+        }
+        dlog('Share.share (ios)');
+        const manager = getNativeModule(ACTION_SHEET_MANAGER);
+        if (manager === null) {
+            dlog(`Share: "${ACTION_SHEET_MANAGER}" unresolved`);
+            return Promise.reject(new Error('Share: ActionSheetManager native module unavailable'));
+        }
+        return new Promise((resolve, reject) => {
+            manager.showShareActionSheetWithOptions({
+                message: typeof content.message === 'string' ? content.message : undefined,
+                url: typeof content.url === 'string' ? content.url : undefined,
+                subject: options.subject,
+                tintColor: options.tintColor,
+                anchor: options.anchor,
+                excludedActivityTypes: options.excludedActivityTypes,
+            }, error => {
+                dlog('Share.share -> failure');
+                reject(new Error(error.message));
+            }, (completed, activityType) => {
+                dlog(`Share.share -> success completed=${completed}`);
+                resolve(completed
+                    ? { action: SHARED_ACTION, activityType: activityType ?? null }
+                    : { action: DISMISSED_ACTION, activityType: null });
+            });
+        });
+    },
+};

package/build/share/index.js

@@ -0,0 +1,6 @@
+// Share: base / default build (web, headless tsx, any target without a dedicated
+// platform file). Metro overrides this with share.ios.ts / share.android.ts on a real
+// iOS/Android host; off those, the iOS build is the fallback (its ActionSheetManager
+// resolves null elsewhere → graceful reject). The barrel imports './share', which
+// resolves here under tsc/tsx and to the platform file under Metro. See ADR 0019.
+export * from './index.ios';

package/build/share/shared.d.ts

@@ -0,0 +1,32 @@
+export type IShareContent = {
+    title?: string;
+    url: string;
+    message?: string;
+} | {
+    title?: string;
+    url?: string;
+    message: string;
+};
+export interface IShareOptions {
+    dialogTitle?: string;
+    subject?: string;
+    excludedActivityTypes?: string[];
+    tintColor?: unknown;
+    anchor?: number;
+}
+export declare const SHARED_ACTION = "sharedAction";
+export declare const DISMISSED_ACTION = "dismissedAction";
+export interface IShareAction {
+    action: typeof SHARED_ACTION | typeof DISMISSED_ACTION;
+    activityType?: string | null;
+}
+export interface IShareStatic {
+    share(content: IShareContent, options?: IShareOptions): Promise<IShareAction>;
+    sharedAction: typeof SHARED_ACTION;
+    dismissedAction: typeof DISMISSED_ACTION;
+}
+export declare const shareActions: {
+    sharedAction: typeof SHARED_ACTION;
+    dismissedAction: typeof DISMISSED_ACTION;
+};
+export declare function validateContent(content: IShareContent): Error | null;

package/build/share/shared.js

@@ -0,0 +1,32 @@
+// Shared core of the Share module, only what does NOT differ by platform: the public
+// types (IShareContent / IShareOptions / IShareAction), the public contract (IShareStatic),
+// and the content invariant. Share is almost entirely divergent (one method, a totally
+// different native call per platform), so there is no shared factory: each platform file
+// (share.ios.ts / share.android.ts) implements `share()` fully against its own module.
+//
+// Metro selects the platform file on a real host (share.android.ts > share.ts); the base
+// share.ts re-exports the iOS build for web/headless. There is no runtime `Platform.OS`
+// read: the filename is the selector. See ADR 0019.
+// RN's Share action constants (RN Share.js ~173/179). These back the documented
+// `result.action === Share.dismissedAction` pattern. True statically-known literals,
+// so CONSTANT_CASE; the public fields (Share.sharedAction / Share.dismissedAction) are
+// lowerCamel, assigned from these below.
+export const SHARED_ACTION = 'sharedAction';
+export const DISMISSED_ACTION = 'dismissedAction';
+// The constant fields every platform's Share exposes, spread onto the platform Share
+// object so both builds carry them identically.
+export const shareActions = {
+    sharedAction: SHARED_ACTION,
+    dismissedAction: DISMISSED_ACTION,
+};
+// RN's invariant: return an Error (caller rejects rather than throws) so a bad call
+// can't unmount the tree on device. Shared because the rule is identical per platform.
+export function validateContent(content) {
+    if (typeof content !== 'object' || content === null) {
+        return new Error('Content to share must be a valid object');
+    }
+    if (typeof content.url !== 'string' && typeof content.message !== 'string') {
+        return new Error('At least one of URL or message is required');
+    }
+    return null;
+}

package/build/status-bar/index.android.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;