@symbiote-native/engine 0.1.0

package/build/linking/index.ios.js

@@ -0,0 +1,9 @@
+// Linking: iOS build. The native module is `LinkingManager`
+// (RN's TurboModuleRegistry.get('LinkingManager')); iOS has no `sendIntent`, so per
+// RN's Linking.js it rejects 'Unsupported'. Everything else is the shared core. Metro
+// picks this file on an iOS host; the base linking.ts re-exports it for web/headless.
+import { createLinking } from './shared';
+export const Linking = createLinking({
+    moduleName: 'LinkingManager',
+    sendIntent: () => Promise.reject(new Error('Unsupported')),
+});

package/build/linking/index.js

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

package/build/linking/shared.d.ts

@@ -0,0 +1,32 @@
+import { type IEventEmitterModule, type IEventSubscription } from '../native-events';
+declare const URL_EVENT = "url";
+export interface IUrlEvent {
+    url: string;
+}
+export interface IIntentExtra {
+    key: string;
+    value: string | number | boolean;
+}
+export interface INativeLinkingModule extends IEventEmitterModule {
+    getInitialURL(): Promise<string | null>;
+    canOpenURL(url: string): Promise<boolean>;
+    openURL(url: string): Promise<void>;
+    openSettings(): Promise<void>;
+    sendIntent?(action: string, extras?: IIntentExtra[]): Promise<void>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+export interface ILinkingStatic {
+    addEventListener(eventType: typeof URL_EVENT, listener: (event: IUrlEvent) => void): IEventSubscription;
+    openURL(url: string): Promise<void>;
+    canOpenURL(url: string): Promise<boolean>;
+    getInitialURL(): Promise<string | null>;
+    openSettings(): Promise<void>;
+    sendIntent(action: string, extras?: IIntentExtra[]): Promise<void>;
+}
+export interface ILinkingPlatform {
+    moduleName: string;
+    sendIntent(module: INativeLinkingModule | null, action: string, extras?: IIntentExtra[]): Promise<void>;
+}
+export declare function createLinking(platform: ILinkingPlatform): ILinkingStatic;
+export {};

package/build/linking/shared.js

@@ -0,0 +1,98 @@
+// Shared core of the Linking module: everything that does NOT differ by platform:
+// the public contract, the lazy native-module resolver, the `url` device-event
+// subscription, URL validation, and payload narrowing. The per-platform files
+// (linking.ios.ts / linking.android.ts) supply ONLY what genuinely diverges (the
+// native module NAME and the `sendIntent` strategy) and hand them to `createLinking`.
+//
+// Metro selects the platform file on a real host (linking.android.ts > linking.ts);
+// the base linking.ts re-exports the iOS build for web/headless. There is no runtime
+// `Platform.OS` read; the filename is the selector. See ADR 0019.
+import { installDeviceEventHub, NativeEventEmitter, } from '../native-events';
+import { getNativeModule } from '../native-modules';
+import { dlog } from '../debug';
+// The one event symbiote observes: an incoming deep link. RN's LinkingEventDefinitions.
+const URL_EVENT = 'url';
+// RN's _validateURL: a typo / empty URL must fail loudly at the call, not reach native.
+function validateUrl(url) {
+    if (typeof url !== 'string' || url.length === 0) {
+        throw new Error(`Invalid URL: ${url}`);
+    }
+}
+// Narrow the native event payload to IUrlEvent at the trust boundary, no `as`.
+function toUrlEvent(payload) {
+    if (typeof payload === 'object' && payload !== null && 'url' in payload) {
+        const { url } = payload;
+        if (typeof url === 'string')
+            return { url };
+    }
+    dlog('Linking: url event payload missing string url');
+    return { url: '' };
+}
+// Build a platform's Linking from its module name + sendIntent strategy. Each call owns
+// its own lazy module/emitter cache, so importing both platform builds in a smoke keeps
+// them independent. On a real host only one platform file is ever bundled.
+export function createLinking(platform) {
+    let linkingModule;
+    let emitter;
+    function getModule() {
+        if (linkingModule === undefined) {
+            linkingModule = getNativeModule(platform.moduleName);
+            dlog(`Linking: ${platform.moduleName} module ${linkingModule ? 'resolved' : 'NOT resolved (null)'}`);
+        }
+        return linkingModule;
+    }
+    function getEmitter() {
+        if (emitter === undefined) {
+            // Lazy install on first subscribe: the hub exists before native emits without a
+            // hard bootstrap-order dependency. Idempotent.
+            installDeviceEventHub();
+            emitter = new NativeEventEmitter(getModule() ?? undefined);
+        }
+        return emitter;
+    }
+    function moduleUnavailable() {
+        return new Error(`Linking: ${platform.moduleName} native module unavailable`);
+    }
+    return {
+        addEventListener(eventType, listener) {
+            dlog(`Linking.addEventListener -> ${eventType}`);
+            return getEmitter().addListener(eventType, payload => {
+                listener(toUrlEvent(payload));
+            });
+        },
+        openURL(url) {
+            validateUrl(url);
+            dlog(`Linking.openURL -> ${url}`);
+            const module = getModule();
+            if (module === null)
+                return Promise.reject(moduleUnavailable());
+            return module.openURL(url);
+        },
+        canOpenURL(url) {
+            validateUrl(url);
+            dlog(`Linking.canOpenURL -> ${url}`);
+            const module = getModule();
+            if (module === null)
+                return Promise.reject(moduleUnavailable());
+            return module.canOpenURL(url);
+        },
+        getInitialURL() {
+            dlog('Linking.getInitialURL');
+            const module = getModule();
+            if (module === null)
+                return Promise.resolve(null);
+            return module.getInitialURL();
+        },
+        openSettings() {
+            dlog('Linking.openSettings');
+            const module = getModule();
+            if (module === null)
+                return Promise.reject(moduleUnavailable());
+            return module.openSettings();
+        },
+        sendIntent(action, extras) {
+            dlog(`Linking.sendIntent -> ${action}`);
+            return platform.sendIntent(getModule(), action, extras);
+        },
+    };
+}

package/build/native-events.d.ts

@@ -0,0 +1,24 @@
+declare global {
+    var RN$registerCallableModule: ((name: string, factory: () => {
+        emit: (eventType: string, ...args: unknown[]) => void;
+    }) => void) | undefined;
+    var RN$Bridgeless: boolean | undefined;
+}
+export interface IEventSubscription {
+    remove(): void;
+}
+export declare function installDeviceEventHub(): void;
+export interface IDeviceEventSource {
+    addListener(eventType: string, listener: (payload: unknown) => void): IEventSubscription;
+}
+export declare function setDeviceEventSource(source: IDeviceEventSource): void;
+export interface IEventEmitterModule {
+    addListener(eventType: string): void;
+    removeListeners(count: number): void;
+}
+export type INativeEventListener = (payload: unknown) => void;
+export declare class NativeEventEmitter {
+    private readonly module?;
+    constructor(module?: IEventEmitterModule);
+    addListener(eventType: string, listener: INativeEventListener): IEventSubscription;
+}

package/build/native-events.js

@@ -0,0 +1,129 @@
+// native -> JS: receiving native module events. The native side emits ALL device
+// events by invoking ONE callable JS module under the fixed name
+// `RCTDeviceEventEmitter`. On a real RN host that name is already owned by RN's own
+// RCTDeviceEventEmitter, and `RN$registerCallableModule` cannot steal it: native's
+// `callableModules_.emplace` ignores a duplicate key (ReactInstance.cpp), so a
+// second registration is a silent no-op. So we do NOT register our own hub on a
+// real host: the app injects RN's DeviceEventEmitter (the bus native actually
+// calls) via `setDeviceEventSource`, exactly like setColorProcessor. The built-in
+// hub below stays as the fallback bus for headless/non-RN runs. See .docs/decisions/0012.
+import { dlog } from './debug';
+import { runWrapped } from './dispatch';
+// The single device-event bus. Native pushes into `emit`; subscribers (wrapped by
+// NativeEventEmitter) live in `listeners`, keyed by event name.
+const listeners = new Map();
+function emit(eventType, ...args) {
+    const set = listeners.get(eventType);
+    // Diagnostic: proves native is calling OUR hub (vs RN's own RCTDeviceEventEmitter).
+    dlog(`device hub emit "${eventType}" -> ${set?.size ?? 0} listener(s)`);
+    if (set === undefined)
+        return;
+    // A device event arrives outside the framework's update loop; route the fan-out
+    // through the shared dispatch wrapper so a listener's setState lands on the sync
+    // lane and flushes, the same seam Fabric touch events use. Snapshot before
+    // iterating: a listener may remove itself mid-dispatch.
+    const snapshot = [...set];
+    runWrapped(() => {
+        for (const listener of snapshot)
+            listener(...args);
+    });
+}
+function addRawListener(eventType, listener) {
+    let set = listeners.get(eventType);
+    if (set === undefined) {
+        set = new Set();
+        listeners.set(eventType, set);
+    }
+    set.add(listener);
+}
+function removeRawListener(eventType, listener) {
+    listeners.get(eventType)?.delete(listener);
+}
+let installed = false;
+// Register the hub so native can deliver events. Call once at bootstrap, after the
+// host is up (alongside binding the Fabric slot). Idempotent.
+export function installDeviceEventHub() {
+    // A host bus was injected: it owns delivery; the fallback hub is unused. (On a
+    // real host our registration would be a no-op anyway: native's emplace ignores
+    // the already-registered RCTDeviceEventEmitter key.)
+    if (installed || injectedSource !== undefined)
+        return;
+    const register = globalThis.RN$registerCallableModule;
+    if (register === undefined) {
+        throw new Error('RN$registerCallableModule is not installed on the global. ' +
+            'Native events need a bridgeless (New Architecture) host.');
+    }
+    register('RCTDeviceEventEmitter', () => ({ emit }));
+    installed = true;
+    dlog('device event hub installed (RCTDeviceEventEmitter)');
+}
+let injectedSource;
+// Inject the host's device-event bus (e.g. RN's DeviceEventEmitter). Once set,
+// NativeEventEmitter subscribes through it instead of the built-in fallback hub.
+// Called by the app at bootstrap, where importing the host bus is allowed.
+export function setDeviceEventSource(source) {
+    injectedSource = source;
+}
+// True only when the module actually carries both observe-counter methods. A
+// resolved TurboModule whose spec omits addListener/removeListeners (or a host where
+// the module isn't a real event emitter) leaves them undefined, so calling through
+// would throw "undefined is not a function" — the `?.` guards the module, not a
+// missing method. Mirrors RN's NativeEventEmitter constructor probe.
+function hasObserveCounters(module) {
+    return typeof module.addListener === 'function' && typeof module.removeListeners === 'function';
+}
+// Subscribe to events for one native module. Mirrors RN's NativeEventEmitter: each
+// `addListener` also pings the module's `addListener` counter, and removal pings
+// `removeListeners`, so native observes only while someone is listening.
+export class NativeEventEmitter {
+    module;
+    constructor(module) {
+        // Keep the module ONLY if it has both counter methods, exactly like RN: a
+        // module missing them stays unset, so the `this.module?.` calls below no-op
+        // instead of crashing on `undefined(...)`.
+        if (module !== undefined && hasObserveCounters(module)) {
+            this.module = module;
+        }
+        else if (module !== undefined) {
+            dlog('NativeEventEmitter: module lacks addListener/removeListeners; dropping it (counter pings become no-ops)');
+        }
+    }
+    addListener(eventType, listener) {
+        // The module counter tells native to START observing; without it (module
+        // unresolved) native may never emit. Logged to pinpoint a silent native side.
+        const via = injectedSource !== undefined ? 'host-bus' : 'fallback-hub';
+        dlog(`NativeEventEmitter.addListener "${eventType}" ` +
+            `module-counter=${this.module ? 'pinged' : 'none'} via=${via}`);
+        this.module?.addListener(eventType);
+        if (injectedSource !== undefined) {
+            // The host bus delivers raw (no framework flush); wrap so a listener's
+            // setState lands on the sync lane and paints, like Fabric touch events.
+            const subscription = injectedSource.addListener(eventType, payload => {
+                runWrapped(() => listener(payload));
+            });
+            let removed = false;
+            return {
+                remove: () => {
+                    if (removed)
+                        return;
+                    removed = true;
+                    subscription.remove();
+                    this.module?.removeListeners(1);
+                },
+            };
+        }
+        // Fallback bus (headless / non-RN host): the internal hub. Its `emit` wraps.
+        const raw = (...args) => listener(args[0]);
+        addRawListener(eventType, raw);
+        let removed = false;
+        return {
+            remove: () => {
+                if (removed)
+                    return;
+                removed = true;
+                removeRawListener(eventType, raw);
+                this.module?.removeListeners(1);
+            },
+        };
+    }
+}

package/build/native-modules.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    var __turboModuleProxy: (<T>(name: string) => T | null) | undefined;
+    var nativeModuleProxy: Record<string, unknown> | undefined;
+}
+export declare function getNativeModule<T>(name: string): T | null;
+export declare function getEnforcingNativeModule<T>(name: string): T;

package/build/native-modules.js

@@ -0,0 +1,57 @@
+// JS -> native: reaching a native (Turbo)Module. The New Architecture installs
+// `global.__turboModuleProxy(name)`: a JSI function that returns the native
+// module registered under `name` (a HostObject whose methods call into native),
+// or null. React Native's own `TurboModuleRegistry.get` is just this call; we are
+// one more client of the same global, exactly as `getSlot` is for the view tree.
+//
+// This is first-party access, for symbiote's own modules (StatusBarManager,
+// KeyboardObserver, …). Third-party RN packages import `TurboModuleRegistry` from
+// `'react-native'` and read the same global themselves; they do not go through
+// here. See .docs/decisions/0012.
+import { dlog } from './debug';
+// The native module value crosses from an untyped HostObject into our types here;
+// the caller vouches for its shape via T (the single trust-boundary narrowing, no
+// per-call `as`). Native modules are always non-null objects.
+function isNativeModule(value) {
+    return value !== null && value !== undefined;
+}
+// The native module `name`, typed as the caller's interface `T`, or null when no
+// module by that name is registered in the binary (or the proxy is absent, e.g.
+// running headless without a fake installed).
+export function getNativeModule(name) {
+    // Non-bridgeless: the function proxy. Call it by name.
+    const turboProxy = globalThis.__turboModuleProxy;
+    if (typeof turboProxy === 'function') {
+        const module = turboProxy(name);
+        if (module !== null && module !== undefined)
+            return module;
+    }
+    // Bridgeless: the HostObject proxy, indexed by name. Guard the access: a
+    // HostObject may throw for an unlinked name, and a throw here would propagate
+    // into a render effect and blank the tree.
+    const bridgelessProxy = globalThis.nativeModuleProxy;
+    if (bridgelessProxy !== undefined) {
+        try {
+            const module = bridgelessProxy[name];
+            if (isNativeModule(module))
+                return module;
+        }
+        catch (error) {
+            dlog(`nativeModuleProxy["${name}"] threw: ${String(error)}`);
+        }
+    }
+    dlog(`native module "${name}" not found ` +
+        `(turbo=${typeof turboProxy}, bridgeless=${typeof globalThis.nativeModuleProxy})`);
+    return null;
+}
+// Same, but throws when the module is missing, for modules a feature hard-depends
+// on (StatusBar without StatusBarManager cannot function, so failing loud beats a
+// silent no-op).
+export function getEnforcingNativeModule(name) {
+    const module = getNativeModule(name);
+    if (module === null) {
+        throw new Error(`Native module "${name}" is not registered in the binary. ` +
+            'Verify it is linked (New Architecture / bridgeless host with __turboModuleProxy installed).');
+    }
+    return module;
+}

package/build/node.d.ts

@@ -0,0 +1,36 @@
+declare const BRAND: unique symbol;
+export declare const RAW_TEXT_COMPONENT = "RCTRawText";
+export declare const TEXT_COMPONENT = "RCTText";
+export declare const VIRTUAL_TEXT_COMPONENT = "RCTVirtualText";
+export interface ISymbioteEvent {
+    type: string;
+    target: ISymbioteNode;
+    currentTarget: ISymbioteNode;
+    nativeEvent: Record<string, unknown>;
+    stopPropagation: () => void;
+}
+export type IListener = (event: ISymbioteEvent) => unknown;
+export interface ISymbioteNode {
+    readonly [BRAND]: true;
+    readonly component: string;
+    readonly isText: boolean;
+    props: Record<string, unknown>;
+    listeners: Map<string, IListener> | undefined;
+    children: ISymbioteNode[];
+    parent: ISymbioteNode | undefined;
+}
+export declare function createElement(component: string, isText?: boolean): ISymbioteNode;
+export declare function createRawText(text: string): ISymbioteNode;
+export declare function isSymbioteNode(value: unknown): value is ISymbioteNode;
+export declare const ANCHOR_COMPONENT = "#anchor";
+export declare function createAnchor(): ISymbioteNode;
+export declare function isAnchor(node: ISymbioteNode): boolean;
+export declare function setProp(node: ISymbioteNode, key: string, value: unknown): void;
+export declare function setEventListener(node: ISymbioteNode, name: string, value: unknown): void;
+export declare function getExplicitStyle(node: ISymbioteNode): unknown;
+export declare function routeProp(node: ISymbioteNode, key: string, value: unknown): void;
+export declare function setText(node: ISymbioteNode, text: string): void;
+export declare function appendChild(parent: ISymbioteNode, child: ISymbioteNode): void;
+export declare function insertBefore(parent: ISymbioteNode, child: ISymbioteNode, beforeChild: ISymbioteNode): void;
+export declare function removeChild(parent: ISymbioteNode, child: ISymbioteNode): void;
+export {};

package/build/node.js

@@ -0,0 +1,194 @@
+// The retained shadow-tree. Adapters mutate this cheap in-memory tree through a
+// tiny API; the commit engine (commit.ts) later walks it and translates the
+// whole thing into Fabric's clone-on-write child sets. Keeping the retained
+// tree mutable while the Fabric mirror stays persistent is the core R2 trick,
+// and it lives here in shared so no adapter re-implements it.
+import { isEventFor } from './view-config';
+import { isClassNameValue, resolveClassName } from './style-registry';
+const BRAND = Symbol('symbiote.node');
+// A node carries the Fabric view name directly, so adding a primitive (Image,
+// ScrollView, TextInput) is just a new string from the adapter, no core change.
+// The only name resolved at commit time is text: a <Text> nested inside another
+// <Text> becomes a virtual span. `isText` marks a text container so its
+// descendants pick the virtual variant.
+export const RAW_TEXT_COMPONENT = 'RCTRawText';
+export const TEXT_COMPONENT = 'RCTText';
+export const VIRTUAL_TEXT_COMPONENT = 'RCTVirtualText';
+export function createElement(component, isText = false) {
+    return {
+        [BRAND]: true,
+        component,
+        isText,
+        props: {},
+        listeners: undefined,
+        children: [],
+        parent: undefined,
+    };
+}
+export function createRawText(text) {
+    return {
+        [BRAND]: true,
+        component: RAW_TEXT_COMPONENT,
+        isText: false,
+        props: { text },
+        listeners: undefined,
+        children: [],
+        parent: undefined,
+    };
+}
+// `instanceHandle` round-trips through Fabric unchanged: the object we pass to
+// createNode comes back as the event target. We brand our nodes so the event
+// handler can confirm a target is one of ours before dispatching.
+export function isSymbioteNode(value) {
+    return typeof value === 'object' && value !== null && BRAND in value;
+}
+// Vue's runtime-core needs comment/anchor nodes (fragments, v-if, v-for) to track
+// sibling order; Fabric has no such concept. An anchor is a real retained node so
+// insert/nextSibling/parentNode ordering stays correct, but the commit walk SKIPS it
+// (commit.ts): no native view is ever created. Marked by a sentinel component name,
+// not a new field, so the hot SymbioteNode shape is untouched.
+export const ANCHOR_COMPONENT = '#anchor';
+export function createAnchor() {
+    return createElement(ANCHOR_COMPONENT);
+}
+export function isAnchor(node) {
+    return node.component === ANCHOR_COMPONENT;
+}
+// A pure prop set: no event inference. `onTintColor` is a Switch prop and reaches
+// Fabric like any other; the event-vs-prop decision is made by routeProp, never by
+// the key's name.
+export function setProp(node, key, value) {
+    if (value === undefined) {
+        delete node.props[key];
+    }
+    else {
+        node.props[key] = value;
+    }
+}
+// Fabric gates layout events behind a boolean prop (BaseViewProps.onLayout): unlike
+// scroll / touch / change, which the native component emits unconditionally, a
+// layout event fires only when the shadow node is flagged. So a `layout` listener
+// must also raise that prop, mirroring RN's `onLayout: true` validAttribute;
+// otherwise onLayout never fires and anything measuring its own box (VirtualizedList
+// viewport) stays at zero.
+const LAYOUT_EVENT = 'layout';
+const LAYOUT_FLAG_PROP = 'onLayout';
+// The explicit event channel. Structural adapters (Svelte addEventListener, Angular
+// Renderer2.listen) call this directly with an already-known event name; flat-bag
+// adapters reach it through routeProp. A non-function value clears the listener.
+export function setEventListener(node, name, value) {
+    const isHandler = typeof value === 'function';
+    if (isHandler) {
+        const handler = value;
+        const listeners = (node.listeners ??= new Map());
+        listeners.set(name, (event) => handler(event));
+    }
+    else {
+        node.listeners?.delete(name);
+    }
+    if (name === LAYOUT_EVENT)
+        setProp(node, LAYOUT_FLAG_PROP, isHandler ? true : undefined);
+}
+const ON_PREFIX = /^on[A-Z]/;
+// onChange -> change
+function listenerName(propName) {
+    return propName.charAt(2).toLowerCase() + propName.slice(3);
+}
+// The responder-negotiation events (PanResponder's panHandlers). They are a
+// JS-side protocol the event layer synthesizes from raw touches, NOT Fabric
+// ViewConfig events, so isEventFor never reports them. Treat them as listeners on
+// any node so PanResponder's handlers actually attach (rather than routing to
+// setProp and reaching Fabric as dead props). Names are post-listenerName.
+const RESPONDER_EVENTS = new Set([
+    'startShouldSetResponder',
+    'startShouldSetResponderCapture',
+    'moveShouldSetResponder',
+    'moveShouldSetResponderCapture',
+    'responderGrant',
+    'responderReject',
+    'responderStart',
+    'responderMove',
+    'responderEnd',
+    'responderRelease',
+    'responderTerminate',
+    'responderTerminationRequest',
+]);
+// React's JSX dev transform (transform-react-jsx-self / -source, injected by RN's babel
+// preset whenever dev=true) annotates every element with __self (the component instance)
+// and __source ({ fileName, lineNumber, columnNumber }). React's own Fabric host config
+// consumes both and never forwards them. A JSX-based adapter (Vue JSX, Solid JSX) instead
+// carries them onto the vnode as ordinary props, so they reach setProp and then Fabric,
+// where Android's folly::dynamic rejects __self with "JS Functions are not convertible to
+// dynamic" (the instance holds functions) and the surface paints black, while iOS silently
+// drops it. SFC/template authoring never produces them. Strip them here, once, so no
+// adapter leaks React JSX dev metadata to the host, mirroring React's host config.
+const REACT_JSX_DEV_PROPS = new Set(['__self', '__source']);
+const classStyleParts = new WeakMap();
+function commitClassStyle(node, patch) {
+    const entry = { ...classStyleParts.get(node), ...patch };
+    classStyleParts.set(node, entry);
+    setProp(node, 'style', [entry.classStyle, entry.explicitStyle]);
+}
+// The explicit (non-class-derived) style half, for an adapter that builds its style prop up
+// key-by-key (Angular's Ivy ɵɵstyleProp/setStyle) instead of handing over one whole object —
+// it must merge onto this, not onto node.props.style directly, which may be the
+// [classStyle, explicitStyle] array commitClassStyle writes above.
+export function getExplicitStyle(node) {
+    return classStyleParts.get(node)?.explicitStyle;
+}
+const CLASS_PROP_KEYS = new Set(['class', 'className']);
+// The flat-bag split (React / Vue / Solid): an `onX` prop becomes an event listener
+// ONLY when the node's component actually declares `x` as an event (per the shared
+// ViewConfig). Otherwise it is a plain prop, so `onTintColor` on a Switch, whose
+// only event is `change`, routes to setProp and reaches Fabric.
+export function routeProp(node, key, value) {
+    if (REACT_JSX_DEV_PROPS.has(key))
+        return;
+    if (CLASS_PROP_KEYS.has(key)) {
+        commitClassStyle(node, {
+            classStyle: resolveClassName(isClassNameValue(value) ? value : undefined),
+        });
+        return;
+    }
+    if (key === 'style') {
+        commitClassStyle(node, { explicitStyle: value });
+        return;
+    }
+    if (ON_PREFIX.test(key)) {
+        const name = listenerName(key);
+        if (RESPONDER_EVENTS.has(name) || isEventFor(node.component, name)) {
+            setEventListener(node, name, value);
+            return;
+        }
+    }
+    setProp(node, key, value);
+}
+export function setText(node, text) {
+    node.props.text = text;
+}
+function detach(child) {
+    const parent = child.parent;
+    if (!parent)
+        return;
+    const index = parent.children.indexOf(child);
+    if (index >= 0)
+        parent.children.splice(index, 1);
+    child.parent = undefined;
+}
+export function appendChild(parent, child) {
+    detach(child);
+    child.parent = parent;
+    parent.children.push(child);
+}
+export function insertBefore(parent, child, beforeChild) {
+    detach(child);
+    child.parent = parent;
+    const index = parent.children.indexOf(beforeChild);
+    parent.children.splice(index < 0 ? parent.children.length : index, 0, child);
+}
+export function removeChild(parent, child) {
+    const index = parent.children.indexOf(child);
+    if (index >= 0)
+        parent.children.splice(index, 1);
+    child.parent = undefined;
+}

package/build/pan-responder/index.d.ts

@@ -0,0 +1,53 @@
+import type { ISymbioteEvent } from '../node';
+export interface IPanResponderGestureState {
+    stateID: number;
+    moveX: number;
+    moveY: number;
+    x0: number;
+    y0: number;
+    dx: number;
+    dy: number;
+    vx: number;
+    vy: number;
+    numberActiveTouches: number;
+    _accountsForMovesUpTo: number;
+}
+type IActiveCallback = (event: ISymbioteEvent, gestureState: IPanResponderGestureState) => boolean;
+type IPassiveCallback = (event: ISymbioteEvent, gestureState: IPanResponderGestureState) => void;
+export interface IPanResponderCallbacks {
+    onStartShouldSetPanResponder?: IActiveCallback;
+    onStartShouldSetPanResponderCapture?: IActiveCallback;
+    onMoveShouldSetPanResponder?: IActiveCallback;
+    onMoveShouldSetPanResponderCapture?: IActiveCallback;
+    onPanResponderGrant?: IPassiveCallback;
+    onPanResponderStart?: IPassiveCallback;
+    onPanResponderMove?: IPassiveCallback;
+    onPanResponderEnd?: IPassiveCallback;
+    onPanResponderRelease?: IPassiveCallback;
+    onPanResponderReject?: IPassiveCallback;
+    onPanResponderTerminate?: IPassiveCallback;
+    onPanResponderTerminationRequest?: IActiveCallback;
+    onShouldBlockNativeResponder?: IActiveCallback;
+}
+export interface IGestureResponderHandlers {
+    onStartShouldSetResponder: (event: ISymbioteEvent) => boolean;
+    onStartShouldSetResponderCapture: (event: ISymbioteEvent) => boolean;
+    onMoveShouldSetResponder: (event: ISymbioteEvent) => boolean;
+    onMoveShouldSetResponderCapture: (event: ISymbioteEvent) => boolean;
+    onResponderGrant: (event: ISymbioteEvent) => boolean;
+    onResponderReject: (event: ISymbioteEvent) => void;
+    onResponderStart: (event: ISymbioteEvent) => void;
+    onResponderMove: (event: ISymbioteEvent) => void;
+    onResponderEnd: (event: ISymbioteEvent) => void;
+    onResponderRelease: (event: ISymbioteEvent) => void;
+    onResponderTerminate: (event: ISymbioteEvent) => void;
+    onResponderTerminationRequest: (event: ISymbioteEvent) => boolean;
+}
+export interface IPanResponderInstance {
+    panHandlers: IGestureResponderHandlers;
+    getInteractionHandle: () => number | null;
+}
+declare const PanResponder: {
+    create(config: IPanResponderCallbacks): IPanResponderInstance;
+};
+export default PanResponder;