@symbiote-native/engine 0.3.0 → 0.5.0

package/build/animated/leaf-lifecycle.js

@@ -1,6 +1,6 @@
 // The AnimatedProps leaf lifecycle every Animated.* wrapper needs: build a leaf from the current
-// props, swap it into the value graph, bind it to the committed node, go native when asked, and
-// rebind native event props. Framework-agnostic on purpose - it knows nothing about hooks,
+// props, swap it into the value graph, bind it to the committed node, and go native when asked.
+// Framework-agnostic on purpose - it knows nothing about hooks,
 // effects, change detection or reactivity, only the engine's own Animated primitives.
 //
 // WHY THIS LIVES IN THE ENGINE. It used to live four times, once per adapter (React's
@@ -15,7 +15,6 @@
 // What stays in the adapter: WHEN to call reconcile (an effect, onUpdated, ngOnChanges, a $effect)
 // and HOW to find the host node (a ref, a ViewChild, a shim). Everything below is the same for all.
 import { AnimatedProps } from './props.js';
-import { attachNativeEventHandler } from './event.js';
 import { dlog } from '../debug.js';
 // Diagnostic-only, DEBUG-gated: a process-wide sequence number so every reconcile call across
 // every Animated.* instance in a log dump is individually identifiable and orderable.
@@ -66,7 +65,6 @@ function describeTransform(value) {
 }
 export function createAnimatedLeafLifecycle(label) {
     let attached = null;
-    let eventDetachers = [];
     // Diagnostic-only: the last node identity, plus a reentrancy flag to catch reconcile() being
     // called AGAIN from inside its own call stack - the smoking-gun shape for a synchronous
     // same-flush loop, as opposed to merely "called often".
@@ -77,11 +75,6 @@ export function createAnimatedLeafLifecycle(label) {
     let lastWantsNative = false;
     // Canceller for a native bind the caller deferred and that has not run yet.
     let cancelPendingBind;
-    function detachEvents() {
-        for (const detach of eventDetachers)
-            detach();
-        eventDetachers = [];
-    }
     return {
         reconcile(props, node, wantsNative, scheduleNativeBind) {
             const seq = ++globalReconcileSeq;
@@ -142,23 +135,19 @@ export function createAnimatedLeafLifecycle(label) {
                 if (attached !== null && attached !== newLeaf)
                     attached.__detach();
                 attached = newLeaf;
-                // The native half, which a caller may defer. Rebinds events each reconcile so a new inline
-                // event re-attaches, detaching first so the prior binding does not leak;
-                // attachNativeEventHandler no-ops unless the prop really is a native event handler on a
-                // committed node, so the JS path stays the fallback.
+                // The native half, which a caller may defer.
+                //
+                // It used to native-attach every `Animated.event` prop here as well. It must not any more:
+                // a wrapper hands those same props DOWN to a host element, so they reach `routeProp`,
+                // which binds them itself (`host-binding.ts`, `bindAnimatedEvent`) — that is what makes a
+                // bare `<scroll-view onScroll={…} />` work with no wrapper at all. Doing it here too
+                // registered the SAME mapping twice on one view tag, caught by the Vue and Svelte
+                // wrapper tests the day the engine half landed.
                 const bindNative = () => {
                     if (node !== null)
                         newLeaf.setNativeView(node);
                     if (wantsNative)
                         newLeaf.__makeNative();
-                    detachEvents();
-                    if (node === null)
-                        return;
-                    for (const key of Object.keys(props)) {
-                        const attachment = attachNativeEventHandler(node, key, props[key]);
-                        if (attachment !== undefined)
-                            eventDetachers.push(attachment.detach);
-                    }
                 };
                 cancelPendingBind?.();
                 cancelPendingBind = undefined;
@@ -175,7 +164,6 @@ export function createAnimatedLeafLifecycle(label) {
         teardown() {
             cancelPendingBind?.();
             cancelPendingBind = undefined;
-            detachEvents();
             if (attached !== null) {
                 attached.__detach();
                 attached = null;

package/build/app-registry/index.d.ts

@@ -14,6 +14,7 @@ export type ITaskCanceller = () => void;
 export type ITaskCancelProvider = () => ITaskCanceller;
 export interface IHostRegistrar {
     registerRunnable(appKey: string, run: IRunnable): string;
+    registerCancellableHeadlessTask?(taskKey: string, taskProvider: ITaskProvider, taskCancelProvider: ITaskCancelProvider): void;
     unmountAtRootTag?(rootTag: IRootTag): void;
 }
 export interface IAppRegistry<TComponentProvider, TWrapperComponentProvider> {

package/build/app-registry/index.js

@@ -6,11 +6,9 @@
 // the one thing each adapter supplies; everything else (registry bookkeeping, sections, the
 // host-registrar bridge, headless tasks) is byte-identical across adapters and lives here once.
 //
-// The catch: the native Fabric host invokes RN's AppRegistry (a registered callable module) by
-// app key, and it can't see ours. So registerComponent must also hand its runnable to RN's
-// registrar. Reached the same way shared reaches processColor: a dependency-injected seam
-// (setHostRegistrar), so the core stays react-native-free and the app glue wires the host once
-// at startup.
+// The catch: native invokes RN's registered callable AppRegistry for both surface runnables and
+// headless tasks; it cannot see this local registry. `setHostRegistrar` mirrors those native-facing
+// registrations there while the core remains react-native-free.
 import { getNativeModule } from '../native-modules/index.js';
 import { dlog } from '../debug.js';
 const HEADLESS_TASK_MODULE = 'HeadlessJsTaskSupport';
@@ -121,6 +119,7 @@ export function createAppRegistry(runnableFor) {
             }
             taskProviders.set(taskKey, taskProvider);
             taskCancelProviders.set(taskKey, taskCancelProvider);
+            hostRegistrar?.registerCancellableHeadlessTask?.(taskKey, taskProvider, taskCancelProvider);
         },
         startHeadlessTask(taskId, taskKey, data) {
             runHeadlessTask(taskId, taskKey, data);
@@ -138,7 +137,18 @@ export function createAppRegistry(runnableFor) {
     return {
         AppRegistry,
         setHostRegistrar(registrar) {
+            if (hostRegistrar === registrar)
+                return;
             hostRegistrar = registrar;
+            // Headless tasks are commonly registered before adapter bootstrap attaches RN's callable
+            // AppRegistry. Replay only this missing native-facing registry; app runnables retain their
+            // existing register-after-bootstrap contract.
+            for (const [taskKey, taskProvider] of taskProviders) {
+                const taskCancelProvider = taskCancelProviders.get(taskKey);
+                if (taskCancelProvider !== undefined) {
+                    registrar.registerCancellableHeadlessTask?.(taskKey, taskProvider, taskCancelProvider);
+                }
+            }
         },
     };
 }

package/build/commit.d.ts

@@ -1,12 +1,19 @@
 import { type IFabricNode, type IRootTag, type IMeasureOnSuccess, type IMeasureInWindowOnSuccess, type IMeasureLayoutOnSuccess } from './fabric';
 import { type ISymbioteNode } from './node';
 export { processColor, setColorProcessor } from './platform-color';
+declare global {
+    var __SYMBIOTE_BATCH_CREATE__: boolean | undefined;
+}
 export declare function disposeRoot(rootTag: IRootTag): void;
 export declare function commitChildren(rootTag: IRootTag, children: readonly ISymbioteNode[]): void;
 export interface ICommitProfile {
     commits: number;
     walkMs: number;
     nodesVisited: number;
+    /** Update-path nodes that rebuilt their Fabric payload and deep-compared it. */
+    propsBuilt: number;
+    /** Update-path nodes that re-cloned for a child but reused the committed payload by reference. */
+    propsReused: number;
     propWrites: number;
     propNoops: number;
     childScans: number;
@@ -16,7 +23,22 @@ export interface ICommitProfile {
     childFlattenWidest: number;
 }
 export declare function readCommitProfile(): ICommitProfile;
+export declare function flushNativeProps(): void;
 export declare function setNativeProps(node: ISymbioteNode, partial: Record<string, unknown>): void;
+/**
+ * Publish a node whose props were changed OUTSIDE any renderer mutation.
+ *
+ * Dirtying is not publishing. Every other write reaches Fabric because the framework's own commit
+ * follows it; a change driven by a NATIVE EVENT has no such follow-up — `native-events.ts`
+ * requests no commit and no adapter does either, so a node marked dirty from an event handler
+ * simply stays dirty. The host-behavior press path (`setNodePressed` for `:active`) is the first
+ * caller that is not `setNativeProps`, and `setNodeHidden`'s React twin never needed it because
+ * the reconciler is already in its commit phase when it calls.
+ *
+ * Queued rather than committed on the spot, sharing `setNativeProps`' batch: several writes in one
+ * task publish together at the microtask boundary, one commit per surface.
+ */
+export declare function requestCommitFor(node: ISymbioteNode): void;
 export declare function getNativeTag(node: ISymbioteNode): number | undefined;
 export declare function whenCommitted(node: ISymbioteNode, action: () => void): () => void;
 export declare function getNativeNode(node: ISymbioteNode): IFabricNode | undefined;