@symbiote-native/engine 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,124 @@
+# @symbiote-native/engine
+
+The **retained shadow-tree engine** at the bottom of [SymbioteJS](../../README.md) — the one
+package every framework adapter (`@symbiote-native/react`, `@symbiote-native/vue`, `@symbiote-native/angular`, …)
+drives, and the only place the mutation→clone-on-write translation into React Native's Fabric
+exists. It holds a retained, mutable tree of nodes that an adapter mutates cheaply
+(`appendChild` / `setProp` / `removeChild` …), then on commit diffs that tree against Fabric's
+current one, clones only what changed, and calls `completeRoot` — the persistent, clone-on-write
+dance Fabric requires, done **once**, for every framework.
+
+> New to SymbioteJS? The [root README](../../README.md) has the architecture and the one fact it
+> rests on — React is just *one client* of `nativeFabricUIManager`. This package is what sits
+> between every adapter and that native slot.
+
+---
+
+## Who calls this, directly vs. indirectly
+
+**Most consumers never import this package by name.** An app written against
+`@symbiote-native/react`/`@symbiote-native/vue`/`@symbiote-native/angular` never calls `createElement` or
+`setProp` itself — the adapter's reconciler does that on the app's behalf. You reach for
+`@symbiote-native/engine` directly only when:
+
+- you are **writing or debugging a framework adapter** (a `react-reconciler` host config, a Vue
+  `createRenderer`, an Angular `Renderer2`) — this is its primary audience;
+- you need one of the **framework-agnostic runtime modules** it re-exports (`Platform`,
+  `StyleSheet`, `Dimensions`, `Alert`, `Animated`, …) — every adapter re-exports these verbatim, so
+  most apps still reach them through `@symbiote-native/react` etc., not this package.
+
+The mutation API below is intentionally low-level and closely mirrors Fabric's own persistent
+semantics — it is an internal seam, not an app-facing API.
+
+---
+
+## The mutation API — `core/engine/src/node.ts`
+
+The entire surface a renderer seam drives:
+
+```ts
+import {
+  createElement, createRawText, createAnchor,
+  appendChild, insertBefore, removeChild,
+  routeProp, setEventListener, setProp, setText,
+} from '@symbiote-native/engine';
+
+const node = createElement('RCTView');          // component IS the Fabric view name
+const text = createRawText('Hello');
+appendChild(node, text);
+routeProp(node, 'onPress', () => {});            // ← the flat-bag entry point (React/Vue/Solid):
+                                                  //   decides event-vs-prop via the ViewConfig,
+                                                  //   NOT by the "onX" naming convention
+```
+
+`routeProp` is the one call a flat-bag adapter should route every prop through — a **structural**
+adapter (Angular's `Renderer2.listen`, Svelte's `addEventListener`) already knows the event name
+and calls `setEventListener` directly instead.
+
+### Committing — `SymbioteSurface`
+
+```ts
+import { createSurface } from '@symbiote-native/engine';
+
+const surface = createSurface(rootTag);
+surface.appendChild(root, node);
+surface.commit();          // synchronous — for a framework that already batches (React)
+// surface.requestCommit(); // microtask-coalesced — for reactive frameworks (Vue/Svelte/Angular)
+```
+
+Every imperative call in the bridge below (`dispatchViewCommand`, `measure`, `setNativeProps`, …)
+is gated on the node having actually committed — see `whenCommitted` for wiring a native call
+before a tag is guaranteed to exist.
+
+---
+
+## What else it exports
+
+- **The imperative/native bridge** — `dispatchViewCommand`, `measure` / `measureInWindow` /
+  `measureLayout`, `getNativeTag`, `getNativeNode`, `setNativeProps`, `sendAccessibilityEvent`,
+  `whenCommitted`, `toPublicInstance` (the `ref` handle every adapter grafts onto a host node).
+- **Runtime modules**, framework-agnostic, re-exported by every adapter: `Platform`,
+  `StyleSheet` (+ `computeHairlineWidth`), `Dimensions`, `PixelRatio`, `Appearance`, `AppState`,
+  `Keyboard`, `AccessibilityInfo`, `BackHandler`, `PermissionsAndroid`, `LayoutAnimation`,
+  `InteractionManager`, `PanResponder`, and the imperative modules `Alert`, `Share`,
+  `ActionSheetIOS`, `Linking`, `Vibration`, `ToastAndroid`, `Settings`, `I18nManager`.
+- **`Animated`** — both the JS and native driver (`timing` / `spring` / `decay` / `loop` /
+  `ValueXY` / tracking / `diffClamp` / `Easing`), including the native-event attachment path
+  (`attachNativeEvent`, `AnimatedEvent`).
+- **The style pipeline** — `flattenStyle`, the CSS-style processors RN itself runs in JS
+  (`processBoxShadow`, `processFilter`, `processTransform`, `processTransformOrigin`,
+  `processAspectRatio`, `processFontVariant`, `processBackgroundImage`), and the runtime
+  **class-name registry** (`registerStyles` / `resolveClassName` / `scopeClassName`) that
+  `@symbiote-native/css-parser`'s build-time output resolves against — shared by every adapter's
+  `class` / `className` / `addClass` prop path.
+- **`AppRegistry` core** (`createAppRegistry`) — registry bookkeeping + headless-task plumbing;
+  each adapter supplies only its own `runnableFor`.
+- **`dlog` / `isDebug`** — the diagnostic-logging seam every adapter and this package route
+  through, gated by the `DEBUG` env var, never a bare `console.log`.
+
+## What it does NOT do
+
+- It does not know about React, Vue, Angular, JSX, templates, or reactivity — an adapter maps its
+  own framework idioms onto this API, never the other way around.
+- It does not touch Fabric C++, JSI, or Yoga directly — it calls `nativeFabricUIManager`
+  (`createNode` / `cloneNodeWithNewProps` / `appendChildToSet` / `completeRoot`), the same
+  framework-agnostic seam React's own renderer uses.
+- It is not a component library — visual components (Switch, Modal, the lists, …) live in
+  [`@symbiote-native/components`](../components), built on top of this package's `Descriptor`-free
+  mutation API.
+
+## Related packages
+
+- [`@symbiote-native/components`](../components) — the framework-agnostic component layer (state +
+  render), built on this engine.
+- [`@symbiote-native/react`](../../adapters/react) / [`@symbiote-native/vue`](../../adapters/vue) /
+  [`@symbiote-native/angular`](../../adapters/angular) — the framework adapters that drive this API.
+- [`@symbiote-native/css-parser`](../css-parser) — compiles CSS into the style objects this package's
+  `style-registry` resolves at runtime.
+
+## Test it
+
+```bash
+pnpm test              # vitest, from the workspace root — headless, against a fake Fabric slot
+DEBUG=1 pnpm test       # same, with diagnostic logs on
+```

package/build/accessibility-info/index.android.d.ts

@@ -0,0 +1,3 @@
+import { type IAccessibilityInfoStatic } from './shared';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from './shared';
+export declare const AccessibilityInfo: IAccessibilityInfoStatic;

package/build/accessibility-info/index.android.js

@@ -0,0 +1,166 @@
+// AccessibilityInfo on Android wraps the stock RN `AccessibilityInfo` native module
+// (NO native code added; it ships with react-native). Android's getters take a SINGLE
+// success callback (no error callback) and a different method set than iOS: screen-reader
+// is `isTouchExplorationEnabled`, plus reduce-motion / invert-colors / grayscale /
+// high-text-contrast / accessibility-service, and `getRecommendedTimeoutMillis`. The
+// device-event NAMES also differ from iOS (e.g. screen-reader is `touchExplorationDidChange`,
+// reduce-motion is `reduceMotionDidChange`). Metro picks this on an Android host. Mirrors
+// RN's AccessibilityInfo.js Android branches.
+import { getNativeModule } from '../native-modules';
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events';
+import { isSymbioteNode } from '../node';
+import { sendAccessibilityEvent as sharedSendAccessibilityEvent } from '../commit';
+import { dlog } from '../debug';
+import { isBoolean, } from './shared';
+// The Android native module name. This is the module the Android JS wrapper
+// (INativeAccessibilityInfoAndroid) resolves: the stock RN `AccessibilityInfo` Turbo/legacy
+// module. Per the symbiote invariant, a module name is only provable on a real host (a
+// headless fake answers to any name); this Android name is DEVICE-VERIFY-PENDING. See
+// .docs/native-module-platform-routing.md.
+const ACCESSIBILITY_MODULE = 'AccessibilityInfo';
+// Public event name -> the Android device event the native side emits. Android renames
+// most of them; events with no Android source (iOS-only) are absent and yield an inert
+// subscription. (RN maps both `change` and `screenReaderChanged` to touchExplorationDidChange.)
+const ANDROID_DEVICE_EVENT = {
+    screenReaderChanged: 'touchExplorationDidChange',
+    reduceMotionChanged: 'reduceMotionDidChange',
+    highTextContrastChanged: 'highTextContrastDidChange',
+    accessibilityServiceChanged: 'accessibilityServiceDidChange',
+    invertColorsChanged: 'invertColorDidChange',
+    grayscaleChanged: 'grayscaleModeDidChange',
+};
+// Lazily resolved so importing this module has no native side effect. `null` when unlinked.
+let accessibilityModule;
+let emitter;
+function getModule() {
+    if (accessibilityModule === undefined) {
+        accessibilityModule = getNativeModule(ACCESSIBILITY_MODULE);
+        dlog(`AccessibilityInfo(android): module ${accessibilityModule ? 'resolved' : 'NOT resolved (null)'}`);
+    }
+    return accessibilityModule;
+}
+function getEmitter() {
+    if (emitter === undefined) {
+        installDeviceEventHub();
+        emitter = new NativeEventEmitter(getModule() ?? undefined);
+    }
+    return emitter;
+}
+// Run a single-callback Android getter as a Promise. Resolves false when the module is
+// unlinked OR the optional method is absent on this host; mirrors RN's "missing query ->
+// false" contract for the cross-platform getters. The dlog records the miss.
+function queryState(pick, label) {
+    const module = getModule();
+    if (module === null) {
+        dlog(`AccessibilityInfo(android).${label} -> no module (false)`);
+        return Promise.resolve(false);
+    }
+    const getter = pick(module);
+    if (getter === undefined) {
+        dlog(`AccessibilityInfo(android).${label} -> method absent (false)`);
+        return Promise.resolve(false);
+    }
+    return new Promise(resolve => {
+        getter.call(module, enabled => resolve(enabled));
+    });
+}
+class AccessibilityInfoAndroid {
+    // Screen reader on Android == touch exploration (TalkBack).
+    isScreenReaderEnabled() {
+        return queryState(m => m.isTouchExplorationEnabled, 'isScreenReaderEnabled');
+    }
+    isReduceMotionEnabled() {
+        return queryState(m => m.isReduceMotionEnabled, 'isReduceMotionEnabled');
+    }
+    // iOS-only query; Android has no bold-text setting, so resolve false (RN parity).
+    isBoldTextEnabled() {
+        return Promise.resolve(false);
+    }
+    isGrayscaleEnabled() {
+        return queryState(m => m.isGrayscaleEnabled, 'isGrayscaleEnabled');
+    }
+    isInvertColorsEnabled() {
+        return queryState(m => m.isInvertColorsEnabled, 'isInvertColorsEnabled');
+    }
+    // iOS-only query; resolve false (RN parity).
+    isReduceTransparencyEnabled() {
+        return Promise.resolve(false);
+    }
+    isHighTextContrastEnabled() {
+        return queryState(m => m.isHighTextContrastEnabled, 'isHighTextContrastEnabled');
+    }
+    // iOS-only "Increase Contrast"; Android has no equivalent, so resolve false (RN parity).
+    isDarkerSystemColorsEnabled() {
+        return Promise.resolve(false);
+    }
+    // iOS-only reduce-motion sub-setting; resolve false on Android (RN parity).
+    prefersCrossFadeTransitions() {
+        return Promise.resolve(false);
+    }
+    isAccessibilityServiceEnabled() {
+        return queryState(m => m.isAccessibilityServiceEnabled, 'isAccessibilityServiceEnabled');
+    }
+    // Post a string to be announced by the screen reader. No-op without a module.
+    announceForAccessibility(announcement) {
+        const module = getModule();
+        if (module === null) {
+            dlog('AccessibilityInfo(android).announceForAccessibility -> no module (no-op)');
+            return;
+        }
+        module.announceForAccessibility(announcement);
+    }
+    // Android ignores queue/priority options (iOS-only) and posts the announcement plainly
+    // (RN parity).
+    announceForAccessibilityWithOptions(announcement, _options) {
+        this.announceForAccessibility(announcement);
+    }
+    // Deprecated focus-by-tag entry. The Fabric slot keys on a node's committed handle, and a
+    // bare reactTag can't be resolved back to its SymbioteNode (the mirror is node-keyed), so
+    // this best-effort path is a logged no-op. Callers should use sendAccessibilityEvent(node,
+    // 'focus') with a host ref, which routes a real node through the slot.
+    setAccessibilityFocus(reactTag) {
+        dlog(`AccessibilityInfo(android).setAccessibilityFocus(${reactTag}) -> tag-only, no node to route (no-op)`);
+    }
+    // Recommended UI-change timeout for this user. Resolves the original when the module or
+    // the query is absent (RN parity).
+    getRecommendedTimeoutMillis(originalTimeout) {
+        const module = getModule();
+        if (module === null || module.getRecommendedTimeoutMillis === undefined) {
+            return Promise.resolve(originalTimeout);
+        }
+        const query = module.getRecommendedTimeoutMillis;
+        return new Promise(resolve => {
+            query.call(module, originalTimeout, timeout => resolve(timeout));
+        });
+    }
+    // Emit a named accessibility event at a view through the Fabric slot. RN's Fabric path
+    // hands the public-instance handle to nativeFabricUIManager.sendAccessibilityEvent with the
+    // STRING eventType; the C++ side maps it to the platform's AccessibilityEvent kind. The
+    // handle here IS the SymbioteNode (symbiote augments the node in place as its public
+    // instance), so resolve it with the runtime guard and route through shared.
+    sendAccessibilityEvent(handle, eventType) {
+        if (!isSymbioteNode(handle)) {
+            dlog(`AccessibilityInfo(android).sendAccessibilityEvent("${eventType}") -> handle is not a node (no-op)`);
+            return;
+        }
+        dlog(`AccessibilityInfo(android).sendAccessibilityEvent("${eventType}") -> slot`);
+        sharedSendAccessibilityEvent(handle, eventType);
+    }
+    // Subscribe to an accessibility-state change. Android events all carry a bare boolean.
+    // Never throws: a public event with no Android device mapping yields an inert
+    // subscription; a missing module yields a live-but-silent one.
+    addEventListener(eventName, handler) {
+        const deviceEvent = ANDROID_DEVICE_EVENT[eventName];
+        dlog(`AccessibilityInfo(android).addEventListener -> ${eventName} (device: ${deviceEvent ?? 'none'})`);
+        if (deviceEvent === undefined) {
+            return { remove() { } };
+        }
+        const eventEmitter = getEmitter();
+        return eventEmitter.addListener(deviceEvent, payload => {
+            if (!isBoolean(payload))
+                return;
+            handler(payload);
+        });
+    }
+}
+export const AccessibilityInfo = new AccessibilityInfoAndroid();

package/build/accessibility-info/index.d.ts

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

package/build/accessibility-info/index.ios.d.ts

@@ -0,0 +1,3 @@
+import { type IAccessibilityInfoStatic } from './shared';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from './shared';
+export declare const AccessibilityInfo: IAccessibilityInfoStatic;

package/build/accessibility-info/index.ios.js

@@ -0,0 +1,219 @@
+// AccessibilityInfo on iOS wraps the `AccessibilityManager` native module: callback-
+// based state getters (VoiceOver / reduce-motion / bold-text / grayscale / invert-colors /
+// reduce-transparency / darker-system-colors), announce + focus side effects, and the
+// observe-counters for the device-event subscription. Subscribes to iOS device events
+// (`screenReaderChanged` / `reduceMotionChanged` / `boldTextChanged` / …) via a
+// NativeEventEmitter and re-broadcasts to JS listeners. Metro picks this on an iOS host;
+// the bare accessibility-info.ts re-exports it as the default for tsc / tsx / headless.
+// Mirrors RN's AccessibilityInfo.js iOS branches.
+import { getNativeModule } from '../native-modules';
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events';
+import { isSymbioteNode } from '../node';
+import { sendAccessibilityEvent as sharedSendAccessibilityEvent } from '../commit';
+import { dlog } from '../debug';
+import { isBoolean, } from './shared';
+// The iOS native module name RN registers this under. NOTE: this is the name the iOS JS
+// wrapper (INativeAccessibilityManagerIOS) resolves via
+// `TurboModuleRegistry.get('AccessibilityManager')`, NOT the spec filename
+// `NativeAccessibilityManager`. 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-verified
+// (the pre-split file shipped it). See .docs/native-module-platform-routing.md.
+const ACCESSIBILITY_MODULE = 'AccessibilityManager';
+// Public event name -> the iOS device event the native side emits. iOS keeps the names
+// 1:1; the indirection exists only so the mapping stays explicit (Android renames them).
+const IOS_DEVICE_EVENT = {
+    screenReaderChanged: 'screenReaderChanged',
+    reduceMotionChanged: 'reduceMotionChanged',
+    boldTextChanged: 'boldTextChanged',
+    grayscaleChanged: 'grayscaleChanged',
+    invertColorsChanged: 'invertColorsChanged',
+    reduceTransparencyChanged: 'reduceTransparencyChanged',
+    darkerSystemColorsChanged: 'darkerSystemColorsChanged',
+    announcementFinished: 'announcementFinished',
+};
+// Lazily resolved so importing this module has no native side effect: a headless run
+// without a fake __turboModuleProxy still loads it; resolution happens on first use.
+// `null` when the module isn't linked.
+let accessibilityModule;
+let emitter;
+function getModule() {
+    if (accessibilityModule === undefined) {
+        accessibilityModule = getNativeModule(ACCESSIBILITY_MODULE);
+        dlog(`AccessibilityInfo(ios): module ${accessibilityModule ? 'resolved' : 'NOT resolved (null)'}`);
+    }
+    return accessibilityModule;
+}
+function getEmitter() {
+    if (emitter === undefined) {
+        // WHY lazy: install on first subscribe so the hub exists before native emits,
+        // without a hard bootstrap-order dependency. Idempotent.
+        installDeviceEventHub();
+        emitter = new NativeEventEmitter(getModule() ?? undefined);
+    }
+    return emitter;
+}
+// Run a callback-based native getter as a Promise; resolves false when the module is
+// unlinked, mirroring RN's "unavailable query -> false" contract for the cross-platform
+// getters. (RN rejects on iOS, but a false fallback keeps the unified surface uniform with
+// Android's missing-method getters; the dlog records the miss.)
+function queryState(pick, label) {
+    const module = getModule();
+    if (module === null) {
+        dlog(`AccessibilityInfo(ios).${label} -> no module (false)`);
+        return Promise.resolve(false);
+    }
+    const getter = pick(module);
+    return new Promise((resolve, reject) => {
+        getter.call(module, enabled => resolve(enabled), error => reject(error));
+    });
+}
+// Like queryState, but for an OPTIONAL native getter (newer iOS surfaces): resolves false
+// when the module is unlinked OR the method is absent on this host, instead of throwing.
+function queryOptionalState(pick, label) {
+    const module = getModule();
+    if (module === null) {
+        dlog(`AccessibilityInfo(ios).${label} -> no module (false)`);
+        return Promise.resolve(false);
+    }
+    const getter = pick(module);
+    if (getter === undefined) {
+        dlog(`AccessibilityInfo(ios).${label} -> method absent (false)`);
+        return Promise.resolve(false);
+    }
+    return new Promise((resolve, reject) => {
+        getter.call(module, enabled => resolve(enabled), error => reject(error));
+    });
+}
+class AccessibilityInfoIOS {
+    isScreenReaderEnabled() {
+        return queryState(m => m.getCurrentVoiceOverState, 'isScreenReaderEnabled');
+    }
+    isReduceMotionEnabled() {
+        return queryState(m => m.getCurrentReduceMotionState, 'isReduceMotionEnabled');
+    }
+    isBoldTextEnabled() {
+        return queryState(m => m.getCurrentBoldTextState, 'isBoldTextEnabled');
+    }
+    isGrayscaleEnabled() {
+        return queryState(m => m.getCurrentGrayscaleState, 'isGrayscaleEnabled');
+    }
+    isInvertColorsEnabled() {
+        return queryState(m => m.getCurrentInvertColorsState, 'isInvertColorsEnabled');
+    }
+    isReduceTransparencyEnabled() {
+        return queryState(m => m.getCurrentReduceTransparencyState, 'isReduceTransparencyEnabled');
+    }
+    // iOS "Increase Contrast": Settings > Accessibility > Display & Text Size. The native
+    // getter is optional (older hosts lack it); resolve false when absent rather than reject,
+    // keeping the unified surface non-throwing (RN rejects, we mirror the false fallback).
+    isDarkerSystemColorsEnabled() {
+        return queryOptionalState(m => m.getCurrentDarkerSystemColorsState, 'isDarkerSystemColorsEnabled');
+    }
+    // iOS reduce-motion sub-setting (prefer cross-fade over slide). Optional native getter;
+    // resolve false when absent (RN parity for the unavailable case).
+    prefersCrossFadeTransitions() {
+        return queryOptionalState(m => m.getCurrentPrefersCrossFadeTransitionsState, 'prefersCrossFadeTransitions');
+    }
+    // Android-only query; iOS has no high-text-contrast concept, so resolve false (RN parity).
+    isHighTextContrastEnabled() {
+        return Promise.resolve(false);
+    }
+    // Android-only query; on iOS RN rejects. We resolve false to keep the unified surface
+    // non-throwing; the dlog records that it's a no-op on this platform.
+    isAccessibilityServiceEnabled() {
+        dlog('AccessibilityInfo(ios).isAccessibilityServiceEnabled -> Android-only (false)');
+        return Promise.resolve(false);
+    }
+    // Post a string to be announced by the screen reader. No-op without a module.
+    announceForAccessibility(announcement) {
+        const module = getModule();
+        if (module === null) {
+            dlog('AccessibilityInfo(ios).announceForAccessibility -> no module (no-op)');
+            return;
+        }
+        module.announceForAccessibility(announcement);
+    }
+    // Announce with queue/priority options. Falls back to the plain announce when the host
+    // lacks the options-aware method (older iOS), mirroring RN.
+    announceForAccessibilityWithOptions(announcement, options) {
+        const module = getModule();
+        if (module === null) {
+            dlog('AccessibilityInfo(ios).announceForAccessibilityWithOptions -> no module (no-op)');
+            return;
+        }
+        if (module.announceForAccessibilityWithOptions) {
+            module.announceForAccessibilityWithOptions(announcement, options);
+        }
+        else {
+            module.announceForAccessibility(announcement);
+        }
+    }
+    // Move accessibility focus to the view with the given react tag. No-op without a module.
+    // RN deprecates this in favor of sendAccessibilityEvent; kept for parity.
+    setAccessibilityFocus(reactTag) {
+        const module = getModule();
+        if (module === null) {
+            dlog('AccessibilityInfo(ios).setAccessibilityFocus -> no module (no-op)');
+            return;
+        }
+        dlog(`AccessibilityInfo(ios).setAccessibilityFocus -> ${reactTag}`);
+        module.setAccessibilityFocus(reactTag);
+    }
+    // iOS has no recommended-timeout query; resolve the original (RN parity).
+    getRecommendedTimeoutMillis(originalTimeout) {
+        return Promise.resolve(originalTimeout);
+    }
+    // Emit an accessibility event at a view through the Fabric slot. RN's Fabric
+    // sendAccessibilityEvent hands the public-instance handle straight to
+    // nativeFabricUIManager.sendAccessibilityEvent with the STRING eventType, and the C++
+    // side maps it. The handle here IS the SymbioteNode (symbiote augments the node in place
+    // as its public instance), so resolve it with the runtime guard and route through shared.
+    // RN early-returns 'click' on iOS only (AccessibilityInfo.js) because VoiceOver has no click
+    // producer, so preserve that one no-op; every other event reaches the slot.
+    sendAccessibilityEvent(handle, eventType) {
+        if (eventType === 'click') {
+            dlog('AccessibilityInfo(ios).sendAccessibilityEvent("click") -> iOS no-op (RN parity)');
+            return;
+        }
+        if (!isSymbioteNode(handle)) {
+            dlog(`AccessibilityInfo(ios).sendAccessibilityEvent("${eventType}") -> handle is not a node (no-op)`);
+            return;
+        }
+        dlog(`AccessibilityInfo(ios).sendAccessibilityEvent("${eventType}") -> slot`);
+        sharedSendAccessibilityEvent(handle, eventType);
+    }
+    // Subscribe to an accessibility-state change. A handler for a boolean event receives a
+    // boolean; the iOS-only `announcementFinished` carries the announcement payload. Never
+    // throws: a public event with no iOS device mapping yields an inert subscription, and a
+    // missing module yields a live-but-silent one (the counters are no-ops without a module).
+    addEventListener(eventName, handler) {
+        const deviceEvent = IOS_DEVICE_EVENT[eventName];
+        dlog(`AccessibilityInfo(ios).addEventListener -> ${eventName} (device: ${deviceEvent ?? 'none'})`);
+        if (deviceEvent === undefined) {
+            return { remove() { } };
+        }
+        const eventEmitter = getEmitter();
+        return eventEmitter.addListener(deviceEvent, payload => {
+            // Most events carry a bare boolean; announcementFinished carries an object. Forward
+            // each in its own shape, dropping payloads that match neither so we never forward
+            // garbage to the handler.
+            if (eventName === 'announcementFinished') {
+                if (isAnnouncementFinished(payload))
+                    handler(payload);
+                return;
+            }
+            if (!isBoolean(payload))
+                return;
+            handler(payload);
+        });
+    }
+}
+function isAnnouncementFinished(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        'announcement' in payload &&
+        typeof payload.announcement === 'string' &&
+        'success' in payload &&
+        typeof payload.success === 'boolean');
+}
+export const AccessibilityInfo = new AccessibilityInfoIOS();

package/build/accessibility-info/index.js

@@ -0,0 +1,5 @@
+// Base / default AccessibilityInfo: re-exports the iOS build. Metro overrides this with
+// accessibility-info.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
+// accessibility-info-shared.ts.
+export * from './index.ios';

package/build/accessibility-info/shared.d.ts

@@ -0,0 +1,34 @@
+import type { ISymbioteNode } from '../node';
+import type { IEventSubscription } from '../native-events';
+export type IAccessibilityChangeEventName = 'screenReaderChanged' | 'reduceMotionChanged' | 'boldTextChanged' | 'grayscaleChanged' | 'invertColorsChanged' | 'reduceTransparencyChanged' | 'darkerSystemColorsChanged' | 'announcementFinished' | 'accessibilityServiceChanged' | 'highTextContrastChanged';
+export type IAccessibilityChangeEvent = IAccessibilityChangeEventName;
+export type IAccessibilityHandle = ISymbioteNode | number | null | undefined;
+export interface IAccessibilityAnnouncementFinishedEvent {
+    announcement: string;
+    success: boolean;
+}
+export type IAccessibilityChangeEventHandler = (state: boolean | IAccessibilityAnnouncementFinishedEvent) => void;
+export interface IAnnounceForAccessibilityOptions {
+    queue?: boolean;
+    priority?: 'low' | 'default' | 'high';
+}
+export interface IAccessibilityInfoStatic {
+    isScreenReaderEnabled(): Promise<boolean>;
+    isReduceMotionEnabled(): Promise<boolean>;
+    isBoldTextEnabled(): Promise<boolean>;
+    isGrayscaleEnabled(): Promise<boolean>;
+    isInvertColorsEnabled(): Promise<boolean>;
+    isReduceTransparencyEnabled(): Promise<boolean>;
+    isHighTextContrastEnabled(): Promise<boolean>;
+    isAccessibilityServiceEnabled(): Promise<boolean>;
+    isDarkerSystemColorsEnabled(): Promise<boolean>;
+    prefersCrossFadeTransitions(): Promise<boolean>;
+    announceForAccessibility(announcement: string): void;
+    announceForAccessibilityWithOptions(announcement: string, options: IAnnounceForAccessibilityOptions): void;
+    setAccessibilityFocus(reactTag: number): void;
+    getRecommendedTimeoutMillis(originalTimeout: number): Promise<number>;
+    sendAccessibilityEvent(handle: IAccessibilityHandle, eventType: IAccessibilityEventType): void;
+    addEventListener(eventName: IAccessibilityChangeEventName, handler: IAccessibilityChangeEventHandler): IEventSubscription;
+}
+export type IAccessibilityEventType = 'click' | 'focus' | 'viewHoverEnter' | 'windowStateChange';
+export declare function isBoolean(value: unknown): value is boolean;

package/build/accessibility-info/shared.js

@@ -0,0 +1,13 @@
+// AccessibilityInfo, shared contract. The component renders NO Fabric view; it
+// imperatively queries an accessibility native module and subscribes to its device
+// events. What DIVERGES by platform is the native module (iOS `AccessibilityManager`
+// with callback getters; Android stock `AccessibilityInfo` with single-callback
+// getters), which getters exist, and the DEVICE-EVENT NAME a public
+// event maps to (iOS `screenReaderChanged` vs Android `touchExplorationDidChange`).
+// So the .ios/.android files own the native calls and per-platform event-name map;
+// the public types + the shared method surface live here. Filename selects, no
+// Platform.OS read (see ADR 0012 + native_module_name_is_platform_specific). Mirrors
+// RN's Libraries/Components/AccessibilityInfo/AccessibilityInfo.js.
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}

package/build/action-sheet-ios/index.d.ts

@@ -0,0 +1,36 @@
+export interface IActionSheetIOSOptions {
+    title?: string;
+    message?: string;
+    options: string[];
+    destructiveButtonIndex?: number | number[];
+    destructiveButtonIndices?: number[];
+    cancelButtonIndex?: number;
+    anchor?: number;
+    tintColor?: unknown;
+    cancelButtonTintColor?: unknown;
+    disabledButtonTintColor?: unknown;
+    userInterfaceStyle?: string;
+    disabledButtonIndices?: number[];
+}
+export interface IShareActionSheetIOSOptions {
+    message?: string;
+    url?: string;
+    subject?: string;
+    anchor?: number;
+    tintColor?: unknown;
+    cancelButtonTintColor?: unknown;
+    disabledButtonTintColor?: unknown;
+    excludedActivityTypes?: string[];
+    userInterfaceStyle?: string;
+}
+export interface IShareActionSheetError {
+    domain: string;
+    code: string;
+    userInfo?: Record<string, unknown>;
+    message: string;
+}
+export declare const ActionSheetIOS: {
+    showActionSheetWithOptions(options: IActionSheetIOSOptions, callback: (buttonIndex: number) => void): void;
+    showShareActionSheetWithOptions(options: IShareActionSheetIOSOptions, failureCallback: (error: IShareActionSheetError) => void, successCallback: (completed: boolean, activityType?: string) => void): void;
+    dismissActionSheet(): void;
+};