@symbiote-native/engine 0.1.0

package/build/interaction-manager/index.js

@@ -0,0 +1,222 @@
+// InteractionManager: schedule long-running work to run only after any active
+// interactions/animations have completed, so JS animations stay smooth. A faithful
+// port of React Native's Libraries/Interaction/InteractionManager (the queue-backed
+// implementation, not the deprecated no-op stub).
+//
+// It is pure JS (timers + a tiny event emitter, no React and no native bridge), so
+// per symbiote's layering invariant it lives in @symbiote-native/engine, where every adapter
+// re-exports it.
+//
+// Mechanics: each `runAfterInteractions` task is pushed onto a queue and the queue is
+// flushed on the next tick. `createInteractionHandle` increments an outstanding-handle
+// count that blocks the flush; `clearInteractionHandle` decrements it and, when the
+// last handle clears, schedules a flush on the next tick. `interactionStart` /
+// `interactionComplete` fire as the count crosses 0.
+import { dlog } from '../debug';
+// A positive deadline (ms) makes the flush yield via setTimeout once that much event-
+// loop time has elapsed within one batch, letting touches interrupt; 0 (default) runs
+// the whole batch in one setImmediate.
+const DEFAULT_DEADLINE = 0;
+// setTimeout delay used both to yield to the event loop and to resume after the last
+// handle clears: a 0ms macrotask, never a real wait.
+const NEXT_TICK_MS = 0;
+export const Events = {
+    interactionStart: 'interactionStart',
+    interactionComplete: 'interactionComplete',
+};
+function isSimpleTask(task) {
+    return typeof Reflect.get(task, 'run') === 'function';
+}
+function isPromiseTask(task) {
+    return typeof Reflect.get(task, 'gen') === 'function';
+}
+// Minimal string→listener-set emitter; we don't pull in events.ts to keep this module
+// self-contained, and the surface here is just on/off/emit over two event names.
+class Emitter {
+    listeners = new Map();
+    on(eventType, listener) {
+        let set = this.listeners.get(eventType);
+        if (set === undefined) {
+            set = new Set();
+            this.listeners.set(eventType, set);
+        }
+        set.add(listener);
+        return () => {
+            set?.delete(listener);
+        };
+    }
+    emit(eventType, ...args) {
+        const set = this.listeners.get(eventType);
+        if (set === undefined)
+            return;
+        for (const listener of [...set])
+            listener(...args);
+    }
+}
+// Lazily resolve Node's setImmediate, falling back to a 0ms setTimeout where it is
+// absent (browsers, some RN hosts). A runtime guard keeps us off `as`.
+function scheduleImmediate(callback) {
+    const candidate = Reflect.get(globalThis, 'setImmediate');
+    if (typeof candidate === 'function') {
+        candidate(callback);
+        return;
+    }
+    scheduleTimeout(callback, NEXT_TICK_MS);
+}
+// The host timer, read lazily off globalThis (shared's tsconfig does not type timers
+// on globalThis, the same reason raf.ts reaches them through Reflect.get).
+function scheduleTimeout(callback, ms) {
+    const candidate = Reflect.get(globalThis, 'setTimeout');
+    if (typeof candidate === 'function')
+        candidate(callback, ms);
+}
+class InteractionManagerImpl {
+    Events = Events;
+    emitter = new Emitter();
+    taskQueue = [];
+    interactionHandleCount = 0;
+    nextHandle = 1;
+    deadline = DEFAULT_DEADLINE;
+    flushScheduled = false;
+    addListener(eventType, listener) {
+        const off = this.emitter.on(eventType, listener);
+        return { remove: off };
+    }
+    // Schedule a task to run once all interaction handles have cleared and the queue
+    // drains. Returns a cancellable promise-like.
+    runAfterInteractions(task) {
+        let resolveTask;
+        let rejectTask;
+        const promise = new Promise((resolve, reject) => {
+            resolveTask = resolve;
+            rejectTask = reject;
+        });
+        const queued = () => {
+            this.runTask(task, resolveTask, rejectTask);
+        };
+        let cancelled = false;
+        const guarded = () => {
+            if (cancelled)
+                return;
+            queued();
+        };
+        this.taskQueue.push(guarded);
+        this.scheduleFlush();
+        return {
+            then: promise.then.bind(promise),
+            done: (onDone) => {
+                // RN's `done` is `then` run for effect: fire and forget.
+                void promise.then(onDone);
+            },
+            cancel: () => {
+                cancelled = true;
+            },
+        };
+    }
+    // Notify the manager an interaction has started; defers queued tasks. Returns a
+    // handle to clear when the interaction ends.
+    createInteractionHandle() {
+        dlog('InteractionManager.createInteractionHandle');
+        const wasIdle = this.interactionHandleCount === 0;
+        this.interactionHandleCount += 1;
+        if (wasIdle)
+            this.emitter.emit(Events.interactionStart);
+        const handle = this.nextHandle;
+        this.nextHandle += 1;
+        return handle;
+    }
+    // Notify the manager an interaction has completed; the last clear resumes the queue.
+    clearInteractionHandle(handle) {
+        if (!handle)
+            throw new Error('InteractionManager: Must provide a handle to clear.');
+        dlog(`InteractionManager.clearInteractionHandle(${handle})`);
+        this.interactionHandleCount -= 1;
+        if (this.interactionHandleCount === 0) {
+            this.emitter.emit(Events.interactionComplete);
+            // Resume on the next tick so synchronous clear→schedule pairs still yield once.
+            scheduleTimeout(() => {
+                this.scheduleFlush();
+            }, NEXT_TICK_MS);
+        }
+    }
+    setDeadline(deadline) {
+        this.deadline = deadline;
+    }
+    runTask(task, resolveTask, rejectTask) {
+        const resolve = resolveTask ?? (() => { });
+        const reject = rejectTask ?? (() => { });
+        if (task === undefined || task === null) {
+            resolve();
+            return;
+        }
+        if (typeof task === 'function') {
+            try {
+                task();
+                resolve();
+            }
+            catch (error) {
+                reject(toError(error));
+            }
+            return;
+        }
+        if (isPromiseTask(task)) {
+            task.gen().then(() => resolve(), reject);
+            return;
+        }
+        if (isSimpleTask(task)) {
+            try {
+                task.run();
+                resolve();
+            }
+            catch (error) {
+                reject(toError(error));
+            }
+            return;
+        }
+        reject(new TypeError('InteractionManager task object must have a gen or run method.'));
+    }
+    // Schedule a single flush of the queue on the next tick, coalescing multiple
+    // schedule calls within the same tick into one.
+    scheduleFlush() {
+        if (this.flushScheduled)
+            return;
+        if (this.taskQueue.length === 0)
+            return;
+        this.flushScheduled = true;
+        scheduleImmediate(() => {
+            this.flushScheduled = false;
+            this.flushQueue();
+        });
+    }
+    // Drain the queue while no handles are outstanding, honouring the deadline by
+    // yielding via setTimeout when one batch overruns it.
+    flushQueue() {
+        if (this.interactionHandleCount > 0)
+            return;
+        const startTime = Date.now();
+        while (this.taskQueue.length > 0) {
+            if (this.interactionHandleCount > 0)
+                return;
+            const next = this.taskQueue.shift();
+            if (next === undefined)
+                break;
+            if (typeof next === 'function')
+                next();
+            if (this.deadline > DEFAULT_DEADLINE && Date.now() - startTime >= this.deadline) {
+                if (this.taskQueue.length > 0) {
+                    scheduleTimeout(() => {
+                        this.flushQueue();
+                    }, NEXT_TICK_MS);
+                }
+                return;
+            }
+        }
+    }
+}
+// Coerce a thrown unknown into an Error without `as`, mirroring RN's toError.
+function toError(value) {
+    if (value instanceof Error)
+        return value;
+    return new Error(typeof value === 'string' ? value : 'Unknown InteractionManager task error');
+}
+export const InteractionManager = new InteractionManagerImpl();

package/build/keyboard/index.d.ts

@@ -0,0 +1,31 @@
+import { type IEventSubscription, type INativeEventListener } from '../native-events';
+export declare const KEYBOARD_EVENT: {
+    readonly willShow: "keyboardWillShow";
+    readonly didShow: "keyboardDidShow";
+    readonly willHide: "keyboardWillHide";
+    readonly didHide: "keyboardDidHide";
+    readonly willChangeFrame: "keyboardWillChangeFrame";
+    readonly didChangeFrame: "keyboardDidChangeFrame";
+};
+export type IKeyboardEventName = (typeof KEYBOARD_EVENT)[keyof typeof KEYBOARD_EVENT];
+export interface IKeyboardMetrics {
+    screenX: number;
+    screenY: number;
+    width: number;
+    height: number;
+}
+export interface IKeyboardEvent {
+    duration: number;
+    easing: string;
+    endCoordinates: IKeyboardMetrics;
+    startCoordinates?: IKeyboardMetrics;
+    isEventFromThisApp?: boolean;
+}
+export declare const Keyboard: {
+    addListener(eventType: IKeyboardEventName, listener: INativeEventListener): IEventSubscription;
+    removeAllListeners(eventType: IKeyboardEventName): void;
+    isVisible(): boolean;
+    metrics(): IKeyboardMetrics | undefined;
+    scheduleLayoutAnimation(event: IKeyboardEvent): void;
+    dismiss(): void;
+};

package/build/keyboard/index.js

@@ -0,0 +1,142 @@
+// Keyboard module: the first consumer of the native->JS event bridge. Native
+// emits keyboard notifications (show/hide/changeFrame) into the device hub; this
+// subscribes through a NativeEventEmitter bound to the KeyboardObserver native
+// module, which RN keys its keyboard events off of. Mirrors RN's
+// Libraries/Components/Keyboard/Keyboard.js, slimmed to the parts we need.
+import { getNativeModule } from '../native-modules';
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events';
+import { dlog } from '../debug';
+import { blurTextInput, currentlyFocusedInput } from '../text-input-state';
+import { LayoutAnimation } from '../layout-animation';
+// RN's scheduleLayoutAnimation falls back to the 'keyboard' animation type when the
+// event's easing string isn't a known LayoutAnimation type (Keyboard.js:200).
+const KEYBOARD_ANIMATION_TYPE = 'keyboard';
+// Map a raw easing string onto a ILayoutAnimationType without a cast: RN does
+// `LayoutAnimation.Types[easing] || 'keyboard'`, which only yields a real type when
+// the string is a key of the Types table. We mirror that by checking membership in
+// the frozen table before trusting the value.
+function easingToAnimationType(easing) {
+    const types = LayoutAnimation.Types;
+    return types[easing] ?? KEYBOARD_ANIMATION_TYPE;
+}
+// The native module name RN registers the keyboard observer under, confirmed
+// from its spec (specs_DEPRECATED/modules/INativeKeyboardObserver.js:20,
+// `TurboModuleRegistry.get('KeyboardObserver')`).
+const KEYBOARD_OBSERVER_MODULE = 'KeyboardObserver';
+// The keyboard notification names native emits. RN's KeyboardEventDefinitions.
+export const KEYBOARD_EVENT = {
+    willShow: 'keyboardWillShow',
+    didShow: 'keyboardDidShow',
+    willHide: 'keyboardWillHide',
+    didHide: 'keyboardDidHide',
+    willChangeFrame: 'keyboardWillChangeFrame',
+    didChangeFrame: 'keyboardDidChangeFrame',
+};
+function isKeyboardEvent(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        'endCoordinates' in payload &&
+        typeof payload.endCoordinates === 'object' &&
+        payload.endCoordinates !== null);
+}
+// Lazily resolved so importing this module has no native side effect: a headless
+// run without a fake __turboModuleProxy still loads it; resolution happens on the
+// first addListener. Null when the module isn't linked.
+let observer;
+let emitter;
+// The latest keyboardDidShow event, or null when the keyboard is hidden. RN's
+// `_currentlyShowing`. Kept fresh by an internal self-subscription (see getEmitter):
+// Keyboard listens to its OWN show/hide events and caches the event so the synchronous
+// isVisible() / metrics() reads need no native round-trip.
+let currentlyShowing = null;
+// Every live subscription this module handed out, grouped by event type, so
+// removeAllListeners(eventType) can tear them all down. The shared NativeEventEmitter
+// exposes only per-listener remove(), so Keyboard tracks the set itself (mirrors RN's
+// _emitter.removeAllListeners, which we cannot reach through the shared emitter).
+const subscriptions = new Map();
+function trackSubscription(eventType, subscription) {
+    let set = subscriptions.get(eventType);
+    if (set === undefined) {
+        set = new Set();
+        subscriptions.set(eventType, set);
+    }
+    set.add(subscription);
+    return {
+        remove() {
+            subscription.remove();
+            set.delete(subscription);
+        },
+    };
+}
+function getEmitter() {
+    if (emitter === undefined) {
+        if (observer === undefined) {
+            observer = getNativeModule(KEYBOARD_OBSERVER_MODULE);
+            dlog(`Keyboard: KeyboardObserver module ${observer ? 'resolved' : 'NOT resolved (null)'}`);
+        }
+        // WHY lazy: install on the first subscribe rather than at module load, so the
+        // hub exists before native emits without a hard bootstrap-order dependency for
+        // this first cut. Idempotent, so repeated subscribes cost one boolean check.
+        installDeviceEventHub();
+        emitter = new NativeEventEmitter(observer ?? undefined);
+        // Self-subscription: cache the latest show event, clear on hide (RN's constructor).
+        // Bypasses trackSubscription so removeAllListeners never tears down the cache feed.
+        emitter.addListener(KEYBOARD_EVENT.didShow, payload => {
+            if (isKeyboardEvent(payload))
+                currentlyShowing = payload;
+        });
+        emitter.addListener(KEYBOARD_EVENT.didHide, () => {
+            currentlyShowing = null;
+        });
+    }
+    return emitter;
+}
+export const Keyboard = {
+    addListener(eventType, listener) {
+        dlog(`Keyboard.addListener -> ${eventType}`);
+        return trackSubscription(eventType, getEmitter().addListener(eventType, listener));
+    },
+    // Tear down every listener this module added for one event type. The self-subscription
+    // that feeds the cache is untracked, so it survives (RN parity: removeAllListeners only
+    // clears caller subscriptions). No-op when nobody's listening for that event.
+    removeAllListeners(eventType) {
+        dlog(`Keyboard.removeAllListeners -> ${eventType}`);
+        const set = subscriptions.get(eventType);
+        if (set === undefined)
+            return;
+        for (const subscription of set)
+            subscription.remove();
+        set.clear();
+    },
+    // Whether the keyboard is last known to be visible. Reads the cached show event.
+    isVisible() {
+        return currentlyShowing !== null;
+    },
+    // The soft-keyboard frame if visible (the cached event's endCoordinates), else
+    // undefined. RN's metrics().
+    metrics() {
+        return currentlyShowing?.endCoordinates;
+    },
+    // Syncs an accessory view's layout with the keyboard transition: configure the next
+    // commit to animate over the keyboard's own duration/easing. RN's
+    // scheduleLayoutAnimation (Keyboard.js:193). Skipped when duration is absent or 0,
+    // since a zero-length animation is a no-op.
+    scheduleLayoutAnimation(event) {
+        const { duration, easing } = event;
+        if (duration === 0)
+            return;
+        dlog(`Keyboard.scheduleLayoutAnimation -> duration ${duration}, easing ${easing}`);
+        LayoutAnimation.configureNext({
+            duration,
+            update: { duration, type: easingToAnimationType(easing) },
+        });
+    },
+    // RN's dismissKeyboard blurs the currently-focused input (TextInputState); blurring
+    // an input is what actually retracts the keyboard, so we do the same. A no-op when
+    // nothing holds focus, like RN.
+    dismiss() {
+        const focused = currentlyFocusedInput();
+        dlog(`Keyboard.dismiss -> ${focused ? 'blur focused input' : 'no focused input (no-op)'}`);
+        blurTextInput(focused);
+    },
+};

package/build/layout-animation/index.d.ts

@@ -0,0 +1,66 @@
+declare const ANIMATION_TYPE: {
+    readonly spring: "spring";
+    readonly linear: "linear";
+    readonly easeInEaseOut: "easeInEaseOut";
+    readonly easeIn: "easeIn";
+    readonly easeOut: "easeOut";
+    readonly keyboard: "keyboard";
+};
+declare const ANIMATION_PROPERTY: {
+    readonly opacity: "opacity";
+    readonly scaleX: "scaleX";
+    readonly scaleY: "scaleY";
+    readonly scaleXY: "scaleXY";
+};
+export type ILayoutAnimationType = (typeof ANIMATION_TYPE)[keyof typeof ANIMATION_TYPE];
+export type ILayoutAnimationProperty = (typeof ANIMATION_PROPERTY)[keyof typeof ANIMATION_PROPERTY];
+export type ILayoutAnimationTypes = Readonly<Record<ILayoutAnimationType, ILayoutAnimationType>>;
+export type ILayoutAnimationProperties = Readonly<Record<ILayoutAnimationProperty, ILayoutAnimationProperty>>;
+export interface ILayoutAnimationAnim {
+    duration?: number;
+    delay?: number;
+    springDamping?: number;
+    initialVelocity?: number;
+    type?: ILayoutAnimationType;
+    property?: ILayoutAnimationProperty;
+}
+export interface ILayoutAnimationConfig {
+    duration: number;
+    create?: ILayoutAnimationAnim;
+    update?: ILayoutAnimationAnim;
+    delete?: ILayoutAnimationAnim;
+}
+type IOnAnimationDidEndCallback = () => void;
+type IOnAnimationDidFailCallback = () => void;
+declare class LayoutAnimationImpl {
+    readonly Types: ILayoutAnimationTypes;
+    readonly Properties: ILayoutAnimationProperties;
+    readonly Presets: {
+        readonly easeInEaseOut: ILayoutAnimationConfig;
+        readonly linear: ILayoutAnimationConfig;
+        readonly spring: {
+            readonly duration: 700;
+            readonly create: {
+                readonly type: "linear";
+                readonly property: "opacity";
+            };
+            readonly update: {
+                readonly type: "spring";
+                readonly springDamping: 0.4;
+            };
+            readonly delete: {
+                readonly type: "linear";
+                readonly property: "opacity";
+            };
+        };
+    };
+    configureNext(config: ILayoutAnimationConfig, onAnimationDidEnd?: IOnAnimationDidEndCallback, onAnimationDidFail?: IOnAnimationDidFailCallback): void;
+    create(duration: number, type?: ILayoutAnimationType, property?: ILayoutAnimationProperty): ILayoutAnimationConfig;
+    easeInEaseOut(onAnimationDidEnd?: IOnAnimationDidEndCallback): void;
+    linear(onAnimationDidEnd?: IOnAnimationDidEndCallback): void;
+    spring(onAnimationDidEnd?: IOnAnimationDidEndCallback): void;
+    setLayoutAnimationEnabled(enabled: boolean): void;
+    checkConfig(..._args: unknown[]): void;
+}
+export declare const LayoutAnimation: LayoutAnimationImpl;
+export {};

package/build/layout-animation/index.js

@@ -0,0 +1,183 @@
+// LayoutAnimation: configures the NEXT commit to animate layout changes. The
+// animation itself is performed natively; this module only ships a config to the
+// native UIManager via `configureNextLayoutAnimation(config, onSuccess, onError)`
+// before the commit. Ports RN's Libraries/LayoutAnimation/LayoutAnimation.js
+// (the JS surface + the native configure call), built on symbiote's single
+// native trust boundary, `getNativeModule`.
+//
+// It is a native-bridge consumer (RN's `Platform`/`StyleSheet` purity split puts
+// these in the adapter, not in shared, like Keyboard / StatusBar).
+import { getNativeModule } from '../native-modules';
+import { dlog } from '../debug';
+// ---- native module routing ----------------------------------------------
+// DEVICE-VERIFY-PENDING: on bridgeless Fabric the layout-animation configure call
+// is exposed by RN through the UIManager surface (RN's non-Fabric path calls
+// `UIManager.configureNextLayoutAnimation`; the Fabric path routes the same args
+// onto `global.nativeFabricUIManager.configureNextLayoutAnimation`). Per
+// .docs/decisions/0012 and .docs/native-module-platform-routing.md the native
+// MODULE NAME is platform-specific and a headless fake answers to ANY name, so
+// the name below is the most plausible bridgeless candidate, NOT proven. Only the
+// simulator/device resolution log can confirm it; the fallback list is tried in
+// order so a wrong primary still resolves on a real host. Verify on-device before
+// trusting either name. See the `dlog` at the resolution seam below.
+const NATIVE_UI_MANAGER_NAME = {
+    primary: 'UIManager',
+    fallback: 'FabricUIManager',
+};
+// ---- public type surface (ported from RN's ReactNativeTypes) -------------
+const ANIMATION_TYPE = {
+    spring: 'spring',
+    linear: 'linear',
+    easeInEaseOut: 'easeInEaseOut',
+    easeIn: 'easeIn',
+    easeOut: 'easeOut',
+    keyboard: 'keyboard',
+};
+const ANIMATION_PROPERTY = {
+    opacity: 'opacity',
+    scaleX: 'scaleX',
+    scaleY: 'scaleY',
+    scaleXY: 'scaleXY',
+};
+// Resolved FRESH on every configureNext, deliberately NOT memoized. The native module can
+// be absent at one moment and linked later, and a cached answer would pin the first result;
+// getNativeModule is a cheap proxy lookup, so per-call resolution costs nothing and stays
+// correct. (Memoizing here also broke the headless smoke, which flips a fake module on/off
+// in one process: a cached module survived the flip-off, so configureNext kept calling native
+// when the module was meant to be absent.)
+function resolveUIManager() {
+    // Try the most plausible bridgeless name first, then fall back. A wrong primary
+    // resolves null on a real host (the bridgeless proxy returns null for an
+    // unlinked name), so the fallback covers a misnamed primary.
+    const candidates = [NATIVE_UI_MANAGER_NAME.primary, NATIVE_UI_MANAGER_NAME.fallback];
+    for (const name of candidates) {
+        const module = getNativeModule(name);
+        if (module !== null) {
+            // DEVICE-VERIFY-PENDING seam: this line on the simulator/device is the only
+            // proof the chosen name is the real one. Keep it permanently (P0 logging gate).
+            dlog(`LayoutAnimation: resolved native UIManager via "${name}"`);
+            return module;
+        }
+    }
+    dlog(`LayoutAnimation: no native UIManager resolved (tried ${candidates.join(', ')}); ` +
+        `configureNext is a no-op (headless or module not linked)`);
+    return null;
+}
+// ---- config builder ------------------------------------------------------
+// Builds a well-formed config for `configureNext`. Mirrors RN's `create`:
+// `create`/`delete` carry both type and property; `update` carries only type.
+function createLayoutAnimation(duration, type, property) {
+    return {
+        duration,
+        create: { type, property },
+        update: { type },
+        delete: { type, property },
+    };
+}
+// ---- presets -------------------------------------------------------------
+const PRESET_DURATION = {
+    easeInEaseOut: 300,
+    linear: 500,
+    spring: 700,
+};
+const SPRING_DAMPING = 0.4;
+const Presets = {
+    easeInEaseOut: createLayoutAnimation(PRESET_DURATION.easeInEaseOut, ANIMATION_TYPE.easeInEaseOut, ANIMATION_PROPERTY.opacity),
+    linear: createLayoutAnimation(PRESET_DURATION.linear, ANIMATION_TYPE.linear, ANIMATION_PROPERTY.opacity),
+    spring: {
+        duration: PRESET_DURATION.spring,
+        create: { type: ANIMATION_TYPE.linear, property: ANIMATION_PROPERTY.opacity },
+        update: { type: ANIMATION_TYPE.spring, springDamping: SPRING_DAMPING },
+        delete: { type: ANIMATION_TYPE.linear, property: ANIMATION_PROPERTY.opacity },
+    },
+};
+// ---- enabled gate --------------------------------------------------------
+// Whether `configureNext` actually arms the next commit. RN seeds this from a
+// feature flag (LayoutAnimation.js:45) and exposes `setEnabled` to toggle it;
+// here it defaults on (our Fabric path always supports it) and `configureNext`
+// short-circuits when it is off, mirroring RN's `if (!isLayoutAnimationEnabled)
+// return` (LayoutAnimation.js:69).
+let isLayoutAnimationEnabled = true;
+// Gates whether the next commit animates. RN's own `setLayoutAnimationEnabled`
+// (LayoutAnimation.js:48) is a no-op due to a self-assignment bug; we implement
+// the intended behaviour: a disabled state makes `configureNext` a no-op.
+function setLayoutAnimationEnabled(value) {
+    isLayoutAnimationEnabled = value;
+}
+// ---- configureNext -------------------------------------------------------
+// Configures the next commit to be animated. NATIVE drives completion:
+// `onAnimationDidEnd` is passed straight through as the native success callback,
+// so it fires exactly when the native animation actually finishes, including
+// when native extends it past `duration` (spring overshoot, OS slowdown,
+// reduce-motion). `onAnimationDidFail` fires only if native config parsing fails.
+// When no native module is linked (headless), this is a logged no-op; an app
+// without it must still run, so we never throw.
+//
+// We deliberately do NOT arm a JS `setTimeout(duration + slack)` to force
+// completion. RN keeps such a timer as a fallback for platform/renderer combos
+// where native never calls back (non-Fabric Android, iOS Fabric pre-ship); but a
+// fixed `duration + 17ms` timer races and usually beats the real native callback,
+// firing `onAnimationDidEnd` before the animation visually completes. On our
+// Fabric-only path native completion is reliably wired, so we rely on it solely.
+function configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
+    // RN bails before touching native when animations are disabled
+    // (LayoutAnimation.js:69).
+    if (!isLayoutAnimationEnabled) {
+        dlog('LayoutAnimation.configureNext: disabled; no-op');
+        return;
+    }
+    const manager = resolveUIManager();
+    if (manager === null || manager.configureNextLayoutAnimation === undefined) {
+        dlog('LayoutAnimation.configureNext: no native UIManager; no-op');
+        return;
+    }
+    // Idempotent guard so native can't drive both success and error into a
+    // double-fire (RN's `animationCompletionHasRun`), without a JS timer racing it.
+    let completionHasRun = false;
+    const onComplete = () => {
+        if (completionHasRun)
+            return;
+        completionHasRun = true;
+        onAnimationDidEnd?.();
+    };
+    dlog(`LayoutAnimation.configureNext: dispatching config (duration=${config.duration})`);
+    // onError only fires if native config parsing fails; default to a no-op.
+    manager.configureNextLayoutAnimation(config, onComplete, onAnimationDidFail ?? (() => { }));
+}
+// ---- the LayoutAnimation facade ------------------------------------------
+class LayoutAnimationImpl {
+    // Frozen so callers can't mutate the shared type/property tables.
+    Types = Object.freeze({ ...ANIMATION_TYPE });
+    Properties = Object.freeze({ ...ANIMATION_PROPERTY });
+    Presets = Presets;
+    // Methods (not class fields) so they stay overridable under
+    // useDefineForClassFields.
+    configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
+        configureNext(config, onAnimationDidEnd, onAnimationDidFail);
+    }
+    create(duration, type, property) {
+        return createLayoutAnimation(duration, type, property);
+    }
+    easeInEaseOut(onAnimationDidEnd) {
+        configureNext(Presets.easeInEaseOut, onAnimationDidEnd);
+    }
+    linear(onAnimationDidEnd) {
+        configureNext(Presets.linear, onAnimationDidEnd);
+    }
+    spring(onAnimationDidEnd) {
+        configureNext(Presets.spring, onAnimationDidEnd);
+    }
+    // RN exposes this as both `setLayoutAnimationEnabled` and the `setEnabled`
+    // alias (LayoutAnimation.js:48,222); we surface the primary name. A disabled
+    // state makes `configureNext` a no-op.
+    setLayoutAnimationEnabled(enabled) {
+        setLayoutAnimationEnabled(enabled);
+    }
+    // RN's dev-time config validator. It has been retired upstream
+    // (LayoutAnimation.js:204); the live impl only logs that it is disabled, so
+    // we mirror that and keep the call a no-op rather than re-add dead validation.
+    checkConfig(..._args) {
+        dlog('LayoutAnimation.checkConfig(...) has been disabled.');
+    }
+}
+export const LayoutAnimation = new LayoutAnimationImpl();

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

@@ -0,0 +1,2 @@
+export type { IUrlEvent, IIntentExtra } from './shared';
+export declare const Linking: import("./shared").ILinkingStatic;

package/build/linking/index.android.js

@@ -0,0 +1,18 @@
+// Linking: Android build. The native module is `IntentAndroid`
+// (RN's TurboModuleRegistry.get('IntentAndroid'), spec NativeIntentAndroid): the same
+// four URL methods as iOS plus `sendIntent(action, extras?)`. Everything else is the
+// shared core. Metro picks this file on an Android host.
+//
+// device-verify-pending: the `IntentAndroid` name and routing are confirmed from RN
+// source but not yet exercised on a real Android host; only a bridgeless resolution
+// log there can prove the name. See .docs/native-module-platform-routing.md.
+import { createLinking } from './shared';
+export const Linking = createLinking({
+    moduleName: 'IntentAndroid',
+    sendIntent: (module, action, extras) => {
+        if (module === null || module.sendIntent === undefined) {
+            return Promise.reject(new Error('Linking: IntentAndroid native module unavailable'));
+        }
+        return module.sendIntent(action, extras);
+    },
+});

package/build/linking/index.d.ts

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

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

@@ -0,0 +1,2 @@
+export type { IUrlEvent, IIntentExtra } from './shared';
+export declare const Linking: import("./shared").ILinkingStatic;