@symbiote-native/engine 0.1.4 → 0.1.6

package/build/commit.js

@@ -13,26 +13,20 @@
 // references to specific child handles. That bubble is inherent to a persistent
 // tree and is exactly what React's own Fabric renderer does.
 import { getSlot, } from './fabric.js';
-import { createElement, isAnchor, RAW_TEXT_COMPONENT, VIRTUAL_TEXT_COMPONENT, } from './node.js';
+import { createElement, debugNodeId, isAnchor, VIRTUAL_TEXT_COMPONENT, } from './node.js';
 import { dlog, isDebug } from './debug.js';
 import { flattenStyle } from './style/index.js';
-import { registeredProcessor } from './registry.js';
 import { nextTag } from './tags.js';
-import { isOpaqueColorValue } from './platform-color.js';
-import { processBoxShadow } from './process-box-shadow/index.js';
 import { registerPostCommit, runPostCommitHooks } from './post-commit.js';
-import { processFilter } from './process-filter.js';
-import { processTransformOrigin } from './process-transform-origin/index.js';
-import { processTransform } from './process-transform/index.js';
-import { processAspectRatio } from './process-aspect-ratio.js';
-import { processFontVariant } from './process-font-variant.js';
-import { processBackgroundImage } from './process-background-image/index.js';
+import { fabricProps } from './fabric-props.js';
+import { isRecord } from './type-guards.js';
+// processColor/setColorProcessor now live in ./platform-color (the stable color-processing
+// leaf every color-touching module imports from); re-exported here so nothing outside this
+// module needs to change its import path.
+export { processColor, setColorProcessor } from './platform-color/index.js';
 // Per-commit work counters, surfaced via dlog so a device run can prove the
 // engine is incremental (created=0 with clones after the first mount).
 const stats = { created: 0, cloneProps: 0, cloneChildren: 0, reused: 0 };
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // Diagnostic (gated): Fabric serializes props to folly::dynamic, which rejects a JS
 // Symbol or function with "JS Symbols are not convertible to dynamic". A hard native
 // throw deep in cloneNode*. Walk a props payload and return the dotted path of the
@@ -84,202 +78,11 @@ function guardSerializable(propsDiff, viewName, tag) {
     if (bad !== undefined)
         dlog(`NON-SERIALIZABLE prop on ${viewName}#${tag}: ${bad}`);
 }
-// Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++
-// color parser silently drops strings. The actual conversion (processColor) is
-// RN-platform-specific, so it is injected here rather than imported, keeping
-// shared free of a react-native dependency (and the headless harness working).
-const COLOR_PROPS = new Set([
-    'backgroundColor',
-    'color',
-    'borderColor',
-    'borderTopColor',
-    'borderRightColor',
-    'borderBottomColor',
-    'borderLeftColor',
-    // Logical (writing-direction-relative) border colors + the block axis, all wired to
-    // processColor in RN's ReactNativeStyleAttributes. borderStartColor/borderEndColor are
-    // even publicly typed ColorValue, so they silently dropped on iOS / threw on Android.
-    'borderStartColor',
-    'borderEndColor',
-    'borderBlockColor',
-    'borderBlockStartColor',
-    'borderBlockEndColor',
-    'shadowColor',
-    // Text shadow + the W3C `outline`/image `overlay` colors, also processColor in RN.
-    'textShadowColor',
-    'overlayColor',
-    'outlineColor',
-    'tintColor',
-    // TextInput color props. iOS's native input accepts a CSS string, but Android's
-    // AndroidTextInput is strict ("ColorValue: the value must be a number or Object"),
-    // so these must be processColor'd here too, same as any other color reaching Fabric.
-    'placeholderTextColor',
-    'selectionColor',
-    'cursorColor',
-    'underlineColorAndroid',
-    // Text decoration color (underline/strike): same Fabric strictness as any color.
-    'textDecorationColor',
-    'selectionHandleColor',
-    // Switch track/thumb colors. RN processColors each via the Switch ViewConfig
-    // (SwitchNativeComponent / AndroidSwitchNativeComponent validAttributes). iOS takes
-    // onTintColor (ON) / tintColor (OFF); Android takes trackColorForTrue/False +
-    // trackTintColor, and Android's ColorPropConverter is strict ("the value must be a
-    // number or Object"), so a raw CSS string crashes. thumbTintColor reaches both.
-    'onTintColor',
-    'thumbTintColor',
-    'trackColorForTrue',
-    'trackColorForFalse',
-    'trackTintColor',
-]);
-// Accepts a CSS string or an opaque PlatformColor / DynamicColorIOS object. RN's
-// processColor (the value the canary injects) handles both, resolving the opaque
-// shapes to the platform ints/dicts iOS UIColor expects.
-let colorProcessor = value => value;
-export function setColorProcessor(process) {
-    colorProcessor = process;
-}
-// Public mirror of RN's processColor: run a color through the injected platform
-// processor (the canary wires RN's own). Off a real host it resolves CSS strings
-// and opaque PlatformColor objects to the platform ints Fabric expects; headless
-// (no processor wired) it is the identity, so smokes see the input unchanged.
-export function processColor(color) {
-    return colorProcessor(color);
-}
-// A color-keyed value the platform processor must convert before Fabric: a CSS
-// string, or an opaque PlatformColor / DynamicColorIOS object. Numbers (already
-// platform ints) and undefined are left untouched.
-function isProcessableColor(value) {
-    return typeof value === 'string' || isOpaqueColorValue(value);
-}
-// Structured CSS-style keys RN parses in JS before native (boxShadow/filter register
-// with enableNativeCSSParsing(), which DEFAULTS TO FALSE, so native CSS parsing is off
-// and the raw string is dropped). Each runs on the hoisted top-level style key, turning
-// a CSS string or structured array into the processed array Fabric's C++ expects.
-const STYLE_PROCESSORS = new Map([
-    ['boxShadow', value => processBoxShadow(asBoxShadowInput(value))],
-    ['filter', value => processFilter(asFilterInput(value))],
-    ['transformOrigin', value => processTransformOrigin(asTransformOriginInput(value))],
-    ['transform', processTransformValue],
-    ['aspectRatio', value => processAspectRatio(asAspectRatioInput(value))],
-    ['fontVariant', value => processFontVariant(asFontVariantInput(value))],
-    ['experimental_backgroundImage', value => processBackgroundImage(asBackgroundImageInput(value))],
-]);
-// boxShadow accepts a CSS string or an array of shadow objects; anything else is
-// undefined to processBoxShadow (which returns []). Narrowing avoids an `as` cast.
-function asBoxShadowInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// filter accepts a CSS string or an array of single-key filter objects; same narrowing.
-function asFilterInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// experimental_backgroundImage accepts a CSS string (gradient functions) or an array of
-// structured gradient objects; same narrowing as boxShadow/filter.
-function asBackgroundImageInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isRecord);
-    return undefined;
-}
-// transformOrigin accepts a CSS string or a [x, y, z] array of strings/numbers; anything
-// else is undefined to processTransformOrigin (which defaults to center/center/0).
-function asTransformOriginInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isStringOrNumber);
-    return undefined;
-}
-// aspectRatio accepts a number (the common, working form) or a ratio string; otherwise
-// undefined, which processAspectRatio drops.
-function asAspectRatioInput(value) {
-    if (typeof value === 'number' || typeof value === 'string')
-        return value;
-    return undefined;
-}
-// fontVariant accepts an array of variant strings (the common, working form) or a
-// space-separated string; anything else becomes an empty string, which yields [].
-function asFontVariantInput(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Array.isArray(value))
-        return value.filter(isString);
-    return '';
-}
-// transform accepts a CSS string (processTransform parses it) or an array of single-key
-// transform records (the hot animated / sticky-header path, passed through unchanged).
-// A non-string non-array value is NOT dropped: it may already be processed, so it passes
-// through verbatim rather than being coerced to [] (which would erase a valid transform).
-function processTransformValue(value) {
-    if (typeof value === 'string')
-        return processTransform(value);
-    if (Array.isArray(value))
-        return processTransform(value.filter(isRecord));
-    return value;
-}
-function isStringOrNumber(value) {
-    return typeof value === 'string' || typeof value === 'number';
-}
-function isString(value) {
-    return typeof value === 'string';
-}
-// Convert a prop to the shape Fabric's C++ expects. A third-party view contributes
-// its own processors, auto-derived from its ViewConfig (validAttributes[*].process,
-// e.g. processColor for a slider's track tints); those run first. Then the structured
-// CSS-style processors (boxShadow/filter). Built-ins are never in the registry, so they
-// fall through to the global color path, where any CSS-string color is run through the
-// injected platform processor (Fabric's C++ color parser silently drops strings).
-function processValue(component, key, value) {
-    const processor = registeredProcessor(component, key);
-    if (processor !== undefined)
-        return processor(value);
-    const styleProcessor = STYLE_PROCESSORS.get(key);
-    if (styleProcessor !== undefined)
-        return styleProcessor(value);
-    if (COLOR_PROPS.has(key) && isProcessableColor(value))
-        return colorProcessor(value);
-    return value;
-}
 function viewNameFor(node, hasTextAncestor) {
     // The only position-dependent name: a <Text> inside another <Text> becomes a
     // virtual span. Everything else is the component string the adapter chose.
     return node.isText && hasTextAncestor ? VIRTUAL_TEXT_COMPONENT : node.component;
 }
-// Translate the retained node's logical props into the flat payload Fabric's C++
-// props expect: `style` keys are hoisted to the top level, event handlers and
-// undefined values are dropped.
-function fabricProps(node) {
-    if (node.component === RAW_TEXT_COMPONENT) {
-        return { text: node.props.text };
-    }
-    const out = {};
-    for (const [key, value] of Object.entries(node.props)) {
-        if (key === 'style')
-            continue;
-        if (typeof value === 'function')
-            continue;
-        if (value === undefined)
-            continue;
-        out[key] = processValue(node.component, key, value);
-    }
-    // Collapse style (object | array | nested arrays) into one flat payload before
-    // hoisting: `style={[base, override]}` is RN's idiom and Fabric wants it flat.
-    const style = flattenStyle(node.props.style);
-    for (const [key, value] of Object.entries(style)) {
-        if (value !== undefined)
-            out[key] = processValue(node.component, key, value);
-    }
-    return out;
-}
 // Fabric's clone*WithNewProps MERGES the raw payload onto the node's existing props,
 // so the payload must be a MINIMAL diff: only the keys that actually changed, plus any
 // key the node held last time but no longer has, sent as `null` so Fabric resets it to
@@ -407,6 +210,13 @@ function reconcile(slot, node, rootTag, hasTextAncestor, renderableParent, force
             slot.appendChild(handle, reconcile(slot, child, rootTag, childInText, node, true).handle);
         }
         logScrollChildren(node, viewName, tag);
+        // Investigation instrumentation (search-bar-ref "node not committed" bug): scoped to RNS* so
+        // it can be directly compared against the ref-attach log in stack.ts and the dispatch-miss
+        // log below — same debugNodeId on both sides proves/disproves an identity mismatch. Kept
+        // behind DEBUG per <keep_logs_gate_behind_DEBUG>, never removed.
+        if (viewName.startsWith('RNS')) {
+            dlog(`mirror.set (create) node=${debugNodeId(node)} tag=${tag} view=${viewName}`);
+        }
         mirror.set(node, {
             handle,
             tag,
@@ -456,6 +266,11 @@ function reconcile(slot, node, rootTag, hasTextAncestor, renderableParent, force
         guardSerializable(propsDiff, viewName, committed.tag);
         handle = slot.cloneNodeWithNewProps(committed.handle, propsDiff);
     }
+    // Investigation instrumentation (search-bar-ref "node not committed" bug): see the create-path
+    // dlog above. Kept behind DEBUG per <keep_logs_gate_behind_DEBUG>, never removed.
+    if (viewName.startsWith('RNS')) {
+        dlog(`mirror.set (update) node=${debugNodeId(node)} tag=${committed.tag} view=${viewName}`);
+    }
     // The clone keeps the node's family, so its reactTag is unchanged; carry it.
     mirror.set(node, {
         handle,
@@ -500,7 +315,7 @@ function rootContainerFor(rootTag) {
 // from scratch (fresh tags, fresh mirror) instead of cloning handles that belonged to a
 // now-stopped surface. Called from unmount (the bridgeless surface-stop path): the host stops then restarts a
 // surface (Fast Refresh, focus/lifecycle) reusing the same rootTag, and a stale root
-// container would re-clone dead handles into the new surface → a blank screen. The old
+// container would re-clone dead handles into the new surface -> a blank screen. The old
 // container's descendants fall out of every reference and their mirror entries GC.
 export function disposeRoot(rootTag) {
     if (rootContainers.delete(rootTag))
@@ -514,7 +329,7 @@ export function commitChildren(rootTag, children) {
 }
 // Re-run the scoped commit for a surface from its synthetic root container, reusing
 // whatever top-level children it currently holds. The shared half of the engine: both
-// a full mutation→commit and a single-node Animated frame (setNativeProps) funnel here.
+// a full mutation->commit and a single-node Animated frame (setNativeProps) funnel here.
 function commitContainer(rootTag) {
     const slot = getSlot();
     const container = rootContainerFor(rootTag);
@@ -598,7 +413,7 @@ registerPostCommit(() => {
             pendingCommitWaiters.delete(waiter);
     }
 });
-// Run `action` once `node` has a committed Fabric tag — immediately if it already does, else after
+// Run `action` once `node` has a committed Fabric tag - immediately if it already does, else after
 // the commit that assigns it. The canonical fix for the Vue async-commit race: defer instead of
 // silently no-opping. Returns a cancel fn (drop the pending retry, e.g. on unmount).
 export function whenCommitted(node, action) {
@@ -625,10 +440,12 @@ export function getNativeNode(node) {
 export function dispatchViewCommand(node, commandName, args) {
     const record = mirror.get(node);
     if (record === undefined) {
-        dlog(`dispatchViewCommand "${commandName}" skipped: node not committed`);
+        // node=... compares directly against the mirror.set logs above (same debugNodeId scheme) to
+        // prove/disprove a node-identity mismatch — see the search-bar-ref investigation note there.
+        dlog(`dispatchViewCommand "${commandName}" skipped: node not committed (node=${debugNodeId(node)} component=${node.component})`);
         return;
     }
-    dlog(`dispatchViewCommand "${commandName}"`);
+    dlog(`dispatchViewCommand "${commandName}" (node=${debugNodeId(node)})`);
     getSlot().dispatchCommand(record.handle, commandName, args);
 }
 // Emit an accessibility event (focus/click/viewHoverEnter/windowStateChange) at a node's

package/build/dimensions/index.js

@@ -11,9 +11,10 @@
 // We resolve it through the same generic native-module bridge as Platform
 // (getNativeModule), so this module stays importable headless before a fake proxy
 // is installed.
-import { getNativeModule } from '../native-modules.js';
-import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
+import { createDeviceEventModule } from '../native-modules.js';
+import {} from '../native-events.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // The native module name RN registers device metrics under.
 const DEVICE_INFO_MODULE = 'DeviceInfo';
 // The device event native emits when metrics change; its payload is a fresh
@@ -32,9 +33,6 @@ const ZERO_METRICS = {
 // The trust boundary: native getConstants() crosses from an untyped HostObject into
 // our types here, behind a structural guard (no per-call cast). A shape that fails
 // the guard is treated as "module absent".
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function isDimensionsConstants(value) {
     return isRecord(value) && isRecord(value.Dimensions);
 }
@@ -86,20 +84,19 @@ function setDimensions(payload) {
     for (const listener of [...changeListeners])
         listener(cached);
 }
-// Resolve initial metrics lazily and subscribe to native updates once. Re-attempts
-// on each call until a valid module is cached, so a later-installed DeviceInfo still
-// gets picked up (same pattern as platform.ts).
-let updateSubscription;
-function ensureResolved() {
-    if (cached !== undefined)
-        return cached;
-    // Subscribe BEFORE reading constants so an update fired in between isn't missed
-    // (RN orders the addListener before the getConstants call for the same reason).
-    if (updateSubscription === undefined) {
-        const module = getNativeModule(DEVICE_INFO_MODULE);
-        installDeviceEventHub();
-        const emitter = new NativeEventEmitter(undefined);
-        updateSubscription = emitter.addListener(DID_UPDATE_DIMENSIONS, payload => {
+// The policy that diverges from a plain lazy-resolve+emitter: DeviceInfo carries no
+// observe-counters (only getConstants), so it never binds into the emitter -
+// bindModuleToEmitter stays false, matching the original `new
+// NativeEventEmitter(undefined)`. And the subscribe-BEFORE-reading-constants order
+// (native could push an update between the two, RN orders addListener before
+// getConstants for the same reason) lives in onEmitterCreated, which runs addListener
+// first and only then touches getConstants() - same order as before the extraction.
+const deviceEventModule = createDeviceEventModule({
+    moduleName: DEVICE_INFO_MODULE,
+    moduleLogPrefix: 'Dimensions: module',
+    bindModuleToEmitter: false,
+    onEmitterCreated: (emitter, module) => {
+        emitter.addListener(DID_UPDATE_DIMENSIONS, payload => {
             if (isDimensionsPayload(payload))
                 setDimensions(payload);
         });
@@ -116,7 +113,15 @@ function ensureResolved() {
                 dlog('Dimensions: DeviceInfo.getConstants() returned an unexpected shape — using zero metrics');
             }
         }
-    }
+    },
+});
+// Resolve initial metrics lazily and subscribe to native updates once. Re-attempts
+// on each call until a valid module is cached, so a later-installed DeviceInfo still
+// gets picked up (same pattern as platform.ts).
+function ensureResolved() {
+    if (cached !== undefined)
+        return cached;
+    deviceEventModule.getEmitter();
     return cached ?? { window: ZERO_METRICS, screen: ZERO_METRICS };
 }
 export const Dimensions = {

package/build/events/index.js

@@ -10,11 +10,10 @@ import { runWrapped } from '../dispatch.js';
 import { getSlot } from '../fabric.js';
 import { isAnchor, isSymbioteNode } from '../node.js';
 import { registeredNativeEvent } from '../registry.js';
-// Raw Fabric event name -> listener name. Generic bubbling events live here; press
-// is synthesized from a touch sequence and layout is direct, so both are handled
-// outside this table.
+import { attachTouchHistory, recordTouchTrack, resetTouchHistory, touchHistory, } from '../touch-history.js';
+import { isRecord } from '../type-guards.js';
 // Raw Fabric event -> listener name, split by dispatch phase. Press is synthesized
-// from a touch sequence (handled separately below); everything else is table-driven.
+// from a touch sequence and layout is direct, so neither lives in this table.
 // Bubbling events walk target -> root; direct events fire only on the target.
 const BUBBLING_EVENTS = {
     topFocus: 'focus',
@@ -92,146 +91,6 @@ const DEFAULT_LONG_PRESS_MS = 500;
 // Pressability cancels the pending long press when the touch drifts past this many
 // points from where it started (Pressability.DEFAULT_LONG_PRESS_DEACTIVATION_DISTANCE).
 const LONG_PRESS_DEACTIVATION_DISTANCE = 10;
-// RN's bank is indexed by touch identifier and warns above 20; we never warn (headless
-// events may carry larger or absent ids), we just skip anything out of a sane range.
-const MAX_TOUCH_BANK = 20;
-const touchBank = [];
-const touchHistory = {
-    touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0,
-};
-function toFiniteNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
-// Pull a recordable touch out of an untyped entry, or undefined when it lacks a usable
-// identifier or coordinates. RN's getTouchIdentifier throws on a null id; we skip
-// instead, so events without touch geometry leave the bank untouched.
-function normalizeTouch(raw) {
-    if (!isRecord(raw))
-        return undefined;
-    const identifier = toFiniteNumber(raw.identifier);
-    const pageX = toFiniteNumber(raw.pageX);
-    const pageY = toFiniteNumber(raw.pageY);
-    if (identifier === undefined || pageX === undefined || pageY === undefined)
-        return undefined;
-    if (identifier < 0 || identifier > MAX_TOUCH_BANK)
-        return undefined;
-    return { identifier, pageX, pageY, timestamp: toFiniteNumber(raw.timestamp) ?? 0 };
-}
-// The changed touches for this frame (start/move/end), defensively read.
-function changedTouchesOf(nativeEvent) {
-    const raw = nativeEvent.changedTouches;
-    if (!Array.isArray(raw))
-        return [];
-    const out = [];
-    for (const entry of raw) {
-        const touch = normalizeTouch(entry);
-        if (touch !== undefined)
-            out.push(touch);
-    }
-    return out;
-}
-// Count of all touches still down (RN reads nativeEvent.touches.length directly).
-function activeTouchCount(nativeEvent) {
-    const raw = nativeEvent.touches;
-    return Array.isArray(raw) ? raw.length : 0;
-}
-function recordTouchStart(touch) {
-    const record = touchBank[touch.identifier];
-    if (record) {
-        record.touchActive = true;
-        record.startPageX = touch.pageX;
-        record.startPageY = touch.pageY;
-        record.startTimeStamp = touch.timestamp;
-        record.currentPageX = touch.pageX;
-        record.currentPageY = touch.pageY;
-        record.currentTimeStamp = touch.timestamp;
-        record.previousPageX = touch.pageX;
-        record.previousPageY = touch.pageY;
-        record.previousTimeStamp = touch.timestamp;
-    }
-    else {
-        touchBank[touch.identifier] = {
-            touchActive: true,
-            startPageX: touch.pageX,
-            startPageY: touch.pageY,
-            startTimeStamp: touch.timestamp,
-            currentPageX: touch.pageX,
-            currentPageY: touch.pageY,
-            currentTimeStamp: touch.timestamp,
-            previousPageX: touch.pageX,
-            previousPageY: touch.pageY,
-            previousTimeStamp: touch.timestamp,
-        };
-    }
-    touchHistory.mostRecentTimeStamp = touch.timestamp;
-}
-// Move and end share the previous<-current shift; only `touchActive` differs.
-function shiftTouchRecord(touch, active) {
-    const record = touchBank[touch.identifier];
-    if (!record)
-        return;
-    record.touchActive = active;
-    record.previousPageX = record.currentPageX;
-    record.previousPageY = record.currentPageY;
-    record.previousTimeStamp = record.currentTimeStamp;
-    record.currentPageX = touch.pageX;
-    record.currentPageY = touch.pageY;
-    record.currentTimeStamp = touch.timestamp;
-    touchHistory.mostRecentTimeStamp = touch.timestamp;
-}
-// Maintain the bank as a touch frame flows. Mirrors RN's recordTouchTrack: moveish
-// shifts records, startish records + recomputes numberActiveTouches, endish marks the
-// record inactive + rescans for the single remaining touch. `kind` is the touch phase.
-function recordTouchTrack(kind, nativeEvent) {
-    if (kind === 'move') {
-        for (const touch of changedTouchesOf(nativeEvent))
-            shiftTouchRecord(touch, true);
-        return;
-    }
-    if (kind === 'start') {
-        for (const touch of changedTouchesOf(nativeEvent))
-            recordTouchStart(touch);
-        touchHistory.numberActiveTouches = activeTouchCount(nativeEvent);
-        if (touchHistory.numberActiveTouches === 1) {
-            const first = normalizeTouch(arrayFirst(nativeEvent.touches));
-            touchHistory.indexOfSingleActiveTouch = first?.identifier ?? -1;
-        }
-        return;
-    }
-    for (const touch of changedTouchesOf(nativeEvent))
-        shiftTouchRecord(touch, false);
-    touchHistory.numberActiveTouches = activeTouchCount(nativeEvent);
-    if (touchHistory.numberActiveTouches === 1) {
-        for (let i = 0; i < touchBank.length; i++) {
-            const record = touchBank[i];
-            if (record !== undefined && record.touchActive) {
-                touchHistory.indexOfSingleActiveTouch = i;
-                break;
-            }
-        }
-    }
-}
-function arrayFirst(value) {
-    return Array.isArray(value) ? value[0] : undefined;
-}
-// Drop all touch state. Called on a fully-released / cancelled gesture so a stale bank
-// never leaks geometry into the next gesture's first frame.
-function resetTouchHistory() {
-    touchBank.length = 0;
-    touchHistory.numberActiveTouches = 0;
-    touchHistory.indexOfSingleActiveTouch = -1;
-    touchHistory.mostRecentTimeStamp = 0;
-}
-// Attach the live touch history onto the event the responder handlers receive, matching
-// ResponderEventPlugin.js (`grantEvent.touchHistory = ...`, etc.). PanResponder reads
-// it for the per-touch dx/vx math; handlers that ignore it are unaffected.
-function attachTouchHistory(nativeEvent) {
-    nativeEvent.touchHistory = touchHistory;
-}
-// #endregion
 let installed = false;
 // Target of the in-flight touch, remembered at topTouchStart and consumed (or
 // cleared) at topTouchEnd / topTouchCancel.
@@ -279,14 +138,10 @@ function readTouchPoint(nativeEvent) {
     }
     return undefined;
 }
-// Narrow an unknown to a plain object so its properties can be read without a cast.
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // Whether any touch still down started inside the responder (its target IS the
 // responder or a descendant). RN's noResponderTouches walks nativeEvent.touches and
 // returns false the moment one is found; a release fires only when none remain. The
-// headless smokes fire with an empty `{}` event (no `touches`) → no remaining touch →
+// headless smokes fire with an empty `{}` event (no `touches`) -> no remaining touch ->
 // release fires, preserving single-touch behavior. (ResponderEventPlugin.noResponder-
 // Touches + isAncestor.)
 function hasRemainingResponderTouch(responder, nativeEvent) {
@@ -635,7 +490,7 @@ function bubble(target, listenerName, nativeEvent) {
     const path = pathToRoot(target);
     for (let i = path.length - 1; i >= 0; i--) {
         const node = path[i];
-        // Anchors (Angular's #anchor component hosts) never paint and have no native view — a
+        // Anchors (Angular's #anchor component hosts) never paint and have no native view. A
         // listener registered on one only exists because a framework's own output-binding
         // machinery (already delivered directly, e.g. Angular's EventEmitter.subscribe) also
         // registered it through Renderer2.listen. Bubbling into it would refire that same
@@ -655,7 +510,7 @@ function bubble(target, listenerName, nativeEvent) {
         }
     }
     // Bubble phase: target -> root, invoking each ancestor's plain listener. Anchors are
-    // transparent here too (see the capture-phase comment above) — same event, same reason.
+    // transparent here too, same reason (see the capture-phase comment above).
     let node = target;
     while (node) {
         const listener = isAnchor(node) ? undefined : node.listeners?.get(listenerName);

package/build/fabric-props.d.ts

@@ -0,0 +1,3 @@
+import type { IFabricProps } from './fabric';
+import { type ISymbioteNode } from './node';
+export declare function fabricProps(node: ISymbioteNode): IFabricProps;