@symbiote-native/engine 0.2.0 → 0.4.0

package/build/layout-animation/index.js

@@ -42,7 +42,7 @@ const ANIMATION_PROPERTY = {
 // (`FabricUIManager?.configureNextLayoutAnimation` in LayoutAnimation.js) before
 // calling it, no `as` cast needed.
 function hasConfigureNextLayoutAnimation(value) {
-    return isRecord(value) && typeof value.configureNextLayoutAnimation === 'function';
+    return (isRecord(value) && typeof value.configureNextLayoutAnimation === 'function');
 }
 // Resolved FRESH on every configureNext, deliberately NOT memoized. Either mechanism can
 // come and go at runtime (the Fabric global installs during bootstrap; a TurboModule can be
@@ -93,9 +93,15 @@ const Presets = {
     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 },
+        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 },
+        delete: {
+            type: ANIMATION_TYPE.linear,
+            property: ANIMATION_PROPERTY.opacity,
+        },
     },
 };
 // ---- enabled gate --------------------------------------------------------
@@ -154,7 +160,9 @@ function configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
 class LayoutAnimationImpl {
     // Frozen so callers can't mutate the shared type/property tables.
     Types = Object.freeze({ ...ANIMATION_TYPE });
-    Properties = Object.freeze({ ...ANIMATION_PROPERTY });
+    Properties = Object.freeze({
+        ...ANIMATION_PROPERTY,
+    });
     Presets = Presets;
     // Methods (not class fields) so they stay overridable under
     // useDefineForClassFields.

package/build/native-events.js

@@ -70,7 +70,8 @@ export function setDeviceEventSource(source) {
 // 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';
+    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

package/build/native-modules/index.js

@@ -110,7 +110,9 @@ export function createDeviceEventModule(config) {
             installDeviceEventHub();
             const resolved = getModule();
             const bindModule = config.bindModuleToEmitter ?? true;
-            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved) ? resolved : undefined;
+            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved)
+                ? resolved
+                : undefined;
             emitter = new NativeEventEmitter(boundModule);
             config.onEmitterCreated?.(emitter, resolved);
         }

package/build/node.d.ts

@@ -1,3 +1,6 @@
+import type { IFabricNode, IFabricProps, IRootTag, IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess } from './fabric';
+import { type IClassNameValue } from './style-registry';
+import { type IPayloadFold } from './host-behavior';
 declare const BRAND: unique symbol;
 export declare const RAW_TEXT_COMPONENT = "RCTRawText";
 export declare const TEXT_COMPONENT = "RCTText";
@@ -13,26 +16,142 @@ export type IListener = (event: ISymbioteEvent) => unknown;
 export declare function isSymbioteEvent(value: unknown): value is ISymbioteEvent;
 export interface ISymbioteNode {
     readonly [BRAND]: true;
-    readonly component: string;
+    component: string;
     readonly isText: boolean;
     props: Record<string, unknown>;
     listeners: Map<string, IListener> | undefined;
     children: ISymbioteNode[];
     parent: ISymbioteNode | undefined;
+    dirty: boolean;
+    propsDirty: boolean;
+    hasAriaAlias: boolean;
+    payloadFold: IPayloadFold | undefined;
+    structureDirty: boolean;
+    committed: IMirror | undefined;
+    styleParts: IClassStyleParts | undefined;
+    measure(callback: IMeasureOnSuccess): void;
+    measureInWindow(callback: IMeasureInWindowOnSuccess): void;
+    measureLayout(relativeToNativeNode: ISymbioteNode | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;
+    setNativeProps(nativeProps: Record<string, unknown>): void;
+    focus(): void;
+    blur(): void;
 }
-export declare function createElement(component: string, isText?: boolean): ISymbioteNode;
+export interface IMirror {
+    handle: IFabricNode;
+    tag: number;
+    rootTag: IRootTag;
+    props: IFabricProps;
+    children: readonly ISymbioteNode[];
+    viewName: string;
+    parent: ISymbioteNode | undefined;
+    owner: ISymbioteNode;
+}
+/**
+ * The committed record for `node`, or `undefined` if it has never been committed - or if `node` is
+ * not the raw retained node at all.
+ *
+ * That second case is the reason this is a function rather than a bare `node.committed` read. The
+ * engine identifies a node BY IDENTITY, and the classic way to break that is to hand the engine a
+ * wrapper instead of the node: a Vue `reactive()`/deep-`ref()` Proxy around a host element is the
+ * one that actually happens (see the vue-adapter-reactivity skill; `shallowRef` is the fix).
+ *
+ * The old WeakMap caught this for free - a Proxy is a different object, so `mirror.get(proxy)` missed
+ * and every imperative API bailed with a clear "node not committed". A plain property read does NOT:
+ * a Proxy forwards `proxy.committed` straight to the target and hands back a real record, whose
+ * `handle` Vue would then deep-wrap on the way out. That handle is a JSI host object; a Proxy around
+ * it reaches `cloneNodeWithNewProps` and fails somewhere deep in native, far from the cause.
+ *
+ * So the identity check that was implicit in the WeakMap is explicit here: a record written on the
+ * raw node names it, and `record.owner !== node` means whatever we were handed is not that node.
+ * One reference comparison, and the wrap now fails LOUDER than it used to rather than quieter.
+ */
+export declare function committedOf(node: ISymbioteNode): IMirror | undefined;
+export declare function createElement(component: string, isText?: boolean, tag?: string): ISymbioteNode;
 export declare function createRawText(text: string): ISymbioteNode;
 export declare function isSymbioteNode(value: unknown): value is ISymbioteNode;
 export declare function debugNodeId(node: ISymbioteNode): number;
 export declare const ANCHOR_COMPONENT = "#anchor";
 export declare function createAnchor(): ISymbioteNode;
 export declare function isAnchor(node: ISymbioteNode): boolean;
+export declare function isEmptyRawText(node: ISymbioteNode): boolean;
+/**
+ * Change which Fabric view a node commits as, keeping the node's identity.
+ *
+ * The commit walk already re-creates a node whose `viewName` no longer matches its committed one —
+ * that is how a `<Text>` moving in or out of another `<Text>` flips between RCTText and
+ * RCTVirtualText (`commit.ts`, reason `view-kind`). This exposes the same door for a prop-driven
+ * view choice, so `intrinsicWhen` is honoured on UPDATE and not only at create.
+ *
+ * The POLICY stays out of the engine: which prop decides, and which view it decides between, lives
+ * in `HOST_PRIMITIVES` and is read by `resolveIntrinsicTag` in `@symbiote-native/components`. The
+ * engine only knows how to swap the name — the same split every other spec-driven fold has here.
+ *
+ * A no-op when the name is unchanged, so a renderer may call it on every update without comparing
+ * first.
+ */
+export declare function setNodeComponent(node: ISymbioteNode, component: string): void;
+export declare function markDirty(node: ISymbioteNode): void;
+export declare function markPropsDirty(node: ISymbioteNode): void;
+export declare function markStructureDirty(parent: ISymbioteNode): void;
+export declare function takePropStats(): {
+    writes: number;
+    noops: number;
+};
 export declare function setProp(node: ISymbioteNode, key: string, value: unknown): void;
+/**
+ * Install a listener the BEHAVIOR owns, bypassing the ownership check.
+ *
+ * `setEventListener` diverts an owned name into the stash, which is right for an app listener and
+ * circular for the behavior's own dispatcher — it would stash itself and never occupy the slot it
+ * exists to hold. This is the one writer allowed past that gate.
+ */
+export declare function setBehaviorListener(node: ISymbioteNode, name: string, listener: IListener): void;
 export declare function setEventListener(node: ISymbioteNode, name: string, value: unknown): void;
+export interface IClassStyleParts {
+    classStyle: unknown;
+    explicitStyle: unknown;
+    hiddenStyle: unknown;
+    className: IClassNameValue | undefined;
+    isPressed: boolean;
+    activeStyle: unknown;
+    activeStyleFromCallback: boolean;
+}
+/**
+ * Stop a node painting without unmounting it, or let it paint again.
+ *
+ * The seam React's `Activity`/`Suspense` reach for through `hideInstance`/`unhideInstance`. It
+ * lives in the engine rather than an adapter because the reversibility problem — restoring the
+ * author's style byte for byte — belongs to whoever owns the style merge, and that is here.
+ */
+export declare function setNodeHidden(node: ISymbioteNode, hidden: boolean): void;
+/**
+ * Put a node into (or out of) its pressed state, so `.x:active` rules apply.
+ *
+ * The engine-owned half of what `:active` is on the web: the press state resolves BELOW the
+ * framework and never crosses into it, which is what lets a pressable be an intrinsic tag rather
+ * than a component (`.claude/rules/host-primitive-tier.md`, tier 2). A component is forced only
+ * when the TEMPLATE must read the state — `v-slot="{ pressed }"` and the function form of `style`
+ * — and this exists so the common case does not have to.
+ *
+ * Costs nothing when no `:active` rule is registered anywhere: `resolveActiveClassName` hands back
+ * the very same object the unpressed path returns, so `isAlreadyPublished` turns the re-push away
+ * and the node is never dirtied.
+ */
+export declare function setNodePressed(node: ISymbioteNode, pressed: boolean): 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 interface ITreeCensus {
+    nodes: number;
+    anchors: number;
+    emptyRawTexts: number;
+    /** Nodes the commit walk actually reconciles: `nodes` minus everything it skips. */
+    renderable: number;
+    /** children.length of every parent holding at least one skipped child, widest first. */
+    flattenWidths: number[];
+}
+export declare function censusRetainedTree(roots: readonly ISymbioteNode[]): ITreeCensus;
 export {};