@symbiote-native/vue 1.0.0 → 3.0.0

package/build/modules/animated/index.d.ts

@@ -5,25 +5,7 @@ export declare const Animated: {
     Value: typeof AnimatedValue;
     ValueXY: typeof AnimatedValueXY;
     Color: typeof AnimatedColor;
-    Easing: {
-        step0(n: number): number;
-        step1(n: number): number;
-        linear(t: number): number;
-        ease(t: number): number;
-        quad(t: number): number;
-        cubic(t: number): number;
-        poly(n: number): import("@symbiote-native/engine").IEasingFunction;
-        sin(t: number): number;
-        circle(t: number): number;
-        exp(t: number): number;
-        elastic(bounciness?: number): import("@symbiote-native/engine").IEasingFunction;
-        back(s?: number): import("@symbiote-native/engine").IEasingFunction;
-        bounce(t: number): number;
-        bezier(x1: number, y1: number, x2: number, y2: number): import("@symbiote-native/engine").IEasingFunction;
-        in(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
-        out(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
-        inOut(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
-    };
+    Easing: import("@symbiote-native/engine").IEasing;
     timing: typeof timing;
     spring: typeof spring;
     decay: typeof decay;
@@ -50,7 +32,46 @@ export declare const Animated: {
     Image: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
         [key: string]: any;
     }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-    ScrollView: ReturnType<typeof createAnimatedComponent>;
+    ScrollView: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    FlatList: ReturnType<typeof createAnimatedComponent>;
+    SectionList: ReturnType<typeof createAnimatedComponent>;
+    createAnimatedComponent: typeof createAnimatedComponent;
+} | {
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    Color: typeof AnimatedColor;
+    Easing: import("@symbiote-native/engine").IEasing;
+    timing: (value: AnimatedValue, config: import("@symbiote-native/engine").ITimingConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    spring: (value: AnimatedValue, config: import("@symbiote-native/engine").ISpringConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    decay: (_value: AnimatedValue, _config: import("@symbiote-native/engine").IDecayConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    parallel: (animations: import("@symbiote-native/engine").ICompositeAnimation[], _config?: import("@symbiote-native/engine").IParallelConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    sequence: (animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    stagger: (_time: number, animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    loop: (_animation: import("@symbiote-native/engine").ICompositeAnimation) => import("@symbiote-native/engine").ICompositeAnimation;
+    delay: (_time: number) => import("@symbiote-native/engine").ICompositeAnimation;
+    add: typeof add;
+    subtract: typeof subtract;
+    multiply: typeof multiply;
+    divide: typeof divide;
+    modulo: typeof modulo;
+    diffClamp: typeof diffClamp;
+    event: typeof event;
+    forkEvent: typeof forkEvent;
+    unforkEvent: typeof unforkEvent;
+    View: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Text: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Image: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ScrollView: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
     FlatList: ReturnType<typeof createAnimatedComponent>;
     SectionList: ReturnType<typeof createAnimatedComponent>;
     createAnimatedComponent: typeof createAnimatedComponent;

package/build/modules/animated/index.js

@@ -4,25 +4,29 @@
 // meet here so `Animated.timing(new Animated.Value(0), ...).start()` works against the
 // Vue-driven engine.
 import { AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedMock, Easing, Platform, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, } from '@symbiote-native/engine';
-import { View, Text } from '../../components.js';
-import { Image } from '../../components/image.js';
-import { ScrollView } from '../../components/scroll-view';
 import { FlatList } from '../../components/flat-list/index.js';
 import { SectionList } from '../../components/section-list/index.js';
 import { createAnimatedComponent } from './create-animated-component.js';
 export { createAnimatedComponent } from './create-animated-component.js';
-// View/Text are pure host primitives; Image is the functional renderImage wrapper, and all expose
-// their host node via ref fall-through, so wrap them eagerly.
-const AnimatedView = createAnimatedComponent(View);
-const AnimatedText = createAnimatedComponent(Text);
-const AnimatedImage = createAnimatedComponent(Image);
-// LAZY, memoized getters, mirroring RN's `get ScrollView()`. Every scrolling container reaches
-// scroll-view/sticky-header, which imports this Animated namespace back, so a wrap at module
-// scope captures whatever the half-evaluated cycle holds at that instant. Under a bundler's ESM
-// interop that is `undefined`, not a ReferenceError - the wrapper builds fine and then renders
-// nothing. Deferring past module init is what keeps it from firing. FlatList and SectionList
-// reach ScrollView through VirtualizedList, so they sit on the same cycle and take the same shape.
-let animatedScrollView;
+// The TAGS, not components — there are no View/Text/Image components left to alias, and a string
+// base is what `createAnimatedComponent` already handles (`animated-tag-base.test.ts`): it renders
+// the intrinsic and the ref falls through to the raw engine node, the same fall-through the
+// functional wrappers used to provide.
+//
+// Wrapping is itself vestigial — the engine resolves an AnimatedNode written into any prop of any
+// host node (`core/engine/src/animated/host-binding.ts`), so `<view :style="{ opacity: v }">` needs
+// no wrapper at all. These stay as RN-compatible aliases until the namespace is retired.
+const AnimatedView = createAnimatedComponent('view');
+const AnimatedText = createAnimatedComponent('text');
+const AnimatedImage = createAnimatedComponent('image');
+// `scroll-view` is a TAG now too (no more component, no more scroll-view/sticky-header cycle to
+// dodge), so it takes the same eager shape as View/Text/Image above.
+const AnimatedScrollView = createAnimatedComponent('scroll-view');
+// LAZY, memoized getters, mirroring RN's `get FlatList()`. Kept deferred past module init even
+// though the scroll-view cycle these once rode is gone (ScrollView above is eager now) — neither
+// FlatList nor VirtualizedList imports this module, so there is no proven cycle left, but nothing
+// forces one to stay absent either. Cheap insurance against a half-evaluated module handing back
+// `undefined` and rendering nothing.
 let animatedFlatList;
 let animatedSectionList;
 // The live, JS-driven driver namespace (real frames). RN's AnimatedImplementation.
@@ -58,10 +62,7 @@ export const Animated = {
     View: AnimatedView,
     Text: AnimatedText,
     Image: AnimatedImage,
-    get ScrollView() {
-        animatedScrollView ??= createAnimatedComponent(ScrollView);
-        return animatedScrollView;
-    },
+    ScrollView: AnimatedScrollView,
     get FlatList() {
         animatedFlatList ??= createAnimatedComponent(FlatList);
         return animatedFlatList;

package/build/modules/image/index.d.ts

@@ -0,0 +1,3 @@
+import { type IImageStatics } from '@symbiote-native/components';
+export type { IImageStatics };
+export declare const Image: IImageStatics;

package/build/modules/image/index.js

@@ -0,0 +1,13 @@
+// RN's Image STATICS — `getSize`, `prefetch`, `queryCache`, `abortPrefetch`, `resolveAssetSource`.
+//
+// IN `modules/`, NOT `components/`. The primitive is the `<image>` tag and its fold runs in the
+// engine (`behaviors/image.ts`); what is left under the name `Image` is an imperative API with no
+// view, which is what this bucket is for. Sitting in `components/` made a statics object read as a
+// component.
+//
+// A NAMESPACE OBJECT rather than five bare functions, deliberately: `Alert`, `Share`, `Linking`
+// and `Vibration` are all `export const X = {…}`, and an app porting from RN writes
+// `Image.getSize(...)` verbatim. Shared verbatim via `imageStatics`, the same source every other
+// adapter's Image uses.
+import { imageStatics } from '@symbiote-native/components';
+export const Image = imageStatics;

package/build/register.d.ts

@@ -1 +1 @@
-export {};
+import '@symbiote-native/components/register';

package/build/register.js

@@ -1,35 +1,15 @@
-// Side-effect ONLY. This module exports nothing, on purpose.
+// Side-effect ONLY. Exports nothing, and must never be re-exported from the barrel.
 //
-// A lowered `<symbiote-pressable>` is an element, so the press machine lives on the engine node
-// instead of inside a component — and it gets there by `registerPressableBehavior()` having run
-// before the first node of that tag is created. The entry imports this file as a bare
-// `import './register';`.
+// The fourteen calls live once, in `@symbiote-native/components/register` — they were identical in
+// all five adapters, and each copy carried a migration ledger justifying a call against a wrapper
+// that no longer exists. What is per-adapter is only the SPELLING of the import below: every
+// `*-tag.test.*` here reaches the registry through `import './register';`, and this adapter's own
+// barrel guard pins that line.
 //
-// WHY IT CANNOT BE A RE-EXPORT, and why this file has no exports to re-export in the first place.
-// Metro turns on `inlineRequires` for production only: it moves a `require()` down to the first
-// place its binding is USED, and a barrel's `export { X } from './x'` compiles to a lazy getter. A
-// module reached only that way never evaluates unless something names X as a VALUE, so its
-// registration silently never happens — in RELEASE builds only, invisible to tsc, to vitest, and
-// even to grepping the bundle, because the code IS bundled and simply never runs. A bare
-// `import './register';` placed NEXT TO a re-export of the same specifier does not help either:
-// Babel merges the two into one dependency and the merged one stays lazy. See CLAUDE.md, "Never
-// make correctness depend on a module's load-time side effect".
-//
-// `adapters/vue/src/index.test.ts` pins the barrel against both halves of that.
-import { registerImageBehavior, registerInputAccessoryViewBehavior, registerPressableBehavior, registerSwitchBehavior, registerTextInputBehavior, } from '@symbiote-native/components';
-registerPressableBehavior();
-// Only the LOWERED tags carry this — the wrapper renders `symbiote-text-input-managed` and
-// keeps running its own lifecycle. One owner per node; see `component-names/shared.ts`.
-registerTextInputBehavior();
-// Same reason as TextInput: the wrapper renders `symbiote-switch-managed` and runs its own
-// lastNativeReport/snap-back lifecycle, so the engine's copy attaches only to the bare tag.
-registerSwitchBehavior();
-// Image owns no runtime — its behavior is a prop FOLD and nothing else, and it is registered on the
-// same `symbiote-image` the wrapper already emits rather than on a `-managed` twin. That is safe
-// only because the mapping is idempotent, which `core/components/src/behaviors/image.test.ts`
-// asserts rather than assumes; a wrapper-built node simply folds a second time and nothing moves.
-registerImageBehavior();
-// Fold-only, and it shares the wrapper's tag for the same reason Image does: the mapping has no
-// aliasing at all, so a wrapper-built node folding a second time moves nothing.
-// `core/components/src/behaviors/input-accessory-view.test.ts` asserts that rather than assuming it.
-registerInputAccessoryViewBehavior();
+// WHY A SIDE-EFFECT SUBPATH AND NOT A BARREL EXPORT. Metro turns on `inlineRequires` for PRODUCTION
+// only: it moves a `require` down to the first place its binding is used as a VALUE, and
+// `export { X } from './x'` compiles to a lazy getter. A registration reached that way never
+// evaluates in a Release build — invisible to tsc, to vitest, and to grepping the bundle. A bare
+// `import` placed NEXT TO a re-export of the same specifier does not help either: Babel merges the
+// two into one dependency and the merged dependency stays lazy.
+import '@symbiote-native/components/register';

package/build/renderer/index.js

@@ -2,47 +2,67 @@
 // the engine's tiny mutation API; the engine owns all Fabric clone-on-write, so Vue
 // drives the exact same retained tree React does: the proof the core is framework-
 // agnostic.
-import { createRenderer } from '@vue/runtime-core';
-import { appendChild, createAnchor, createElement, createRawText, dlog, insertBefore, removeChild, routeProp, setProp, setText, toPublicInstance, RAW_TEXT_COMPONENT, SymbioteSurface, } from '@symbiote-native/engine';
+import { callWithErrorHandling, createRenderer, ErrorCodes, markRaw, } from '@vue/runtime-core';
+import { appendChild, createAnchor, createElement, createRawText, childrenOf, dlog, insertBefore, isRawTextNode, isTextContainer, nextSiblingOf, parentOf, removeChild, routeProp, setProp, setText, textOf, toPublicInstance, SymbioteSurface, } from '@symbiote-native/engine';
 import { descriptorFor } from '@symbiote-native/components';
 import { normalizeVueAttrKey } from '../utils/normalize-attrs.js';
 function isSurface(parent) {
     return parent instanceof SymbioteSurface;
 }
 function isRawText(node) {
-    return node.component === RAW_TEXT_COMPONENT;
+    return isRawTextNode(node);
 }
-// RN's Text.js applies two defaults on the way to native (core/components/src/text-props.ts:
-// ellipsizeMode 'tail', allowFontScaling true unless literally false). The Vue <Text> wrapper
-// folded them with resolveTextProps; a template that the SFC transformer lowered to the
-// intrinsic `symbiote-text` has no wrapper, so the renderer seeds them instead. Without this a
-// numberOfLines={1} line clips mid-word with no ellipsis — device-observed, and silent.
-const TEXT_DEFAULTS = new Map([
-    ['ellipsizeMode', 'tail'],
-    ['allowFontScaling', true],
-]);
-function seedTextDefaults(node) {
-    for (const [key, value] of TEXT_DEFAULTS)
-        setProp(node, key, value);
-}
-// RN's `id` is the modern W3C-named alias for `nativeID` — View.js copies it over
-// (`processedProps.nativeID = id`), so the two name ONE native prop. React folds it in its
-// component wrapper and Svelte and Solid in their transforms; Vue had it nowhere, so `<View
-// id="x">` reached Fabric with an unknown `id` and no `nativeID`, silently and on device only.
-// It lives in the renderer rather than in a transform because that covers all four Vue paths at
-// once — lowered SFC, lowered TSX, the component wrapper, and a hand-written
-// `h('symbiote-view', { id })` no compiler ever sees.
+// RN's two Text defaults left this renderer entirely on 2026-09-18, in two steps a month apart. The
+// CREATE seed went first, because writing them as props cost a crossing every time the app authored
+// the same value — 6 000 per 1 000-row create, measured with `writesOfUnchanged`. What stayed was a
+// clear-back: an explicit `undefined` at patch time was substituted for the default, since RN treats
+// a missing prop and an explicit `undefined` alike.
+//
+// That substitution is gone too, and it was redundant rather than wrong. The rule reads the AUTHORED
+// bag at payload time (`foldTextDefaults`, `SymbioteFabricProps.cpp`), so it cannot tell a cleared
+// prop from one never written — both are absent by the time it looks, and both get the default. The
+// adapter was re-supplying an answer the layer below already had.
+// `PROP_ALIASES` (`id` -> `nativeID`) left this renderer on 2026-09-18 — `routeProp` resolves it
+// for every adapter now, and carries the per-node state the caveat here said was not worth it: with
+// both names on one element upstream gives `id` unconditional priority, where a per-key rename
+// resolved it by write order.
+// RN-style event prop naming ('onPress', 'onValueChange', ...), the same convention JSX itself
+// uses to separate an event from a plain value prop — good enough to decide whether to wrap,
+// without duplicating routeProp's own ViewConfig-derived event lists here.
+const EVENT_PROP_NAME = /^on[A-Z]/;
+// A native event (a Fabric touch, a responder gesture) invokes a Pressable/TextInput/etc.
+// listener straight out of the engine's own event dispatch (core/engine/src/dispatch.ts,
+// core/components/src/behaviors/pressable.ts's `dispatch`), entirely outside anything Vue ever
+// wraps — no render, no watcher, no lifecycle hook sits between the native event and the app's
+// callback. So a throw inside `onPress={throwNow}` was a genuinely UNCAUGHT JS exception: it
+// skipped `onErrorCaptured`, skipped `app.config.errorHandler`, skipped even this adapter's own
+// default reporter (render.ts's `reportToHost`) and reached Hermes's own top-level handler
+// directly — the raw, component-stack-less redbox this was device-reported as, not the "vue
+// render (...)" framed one `reportToHost` produces. Real Vue DOM has the identical seam
+// (`patchEvent`'s `createInvoker`) for the identical reason: a DOM event is native too.
 //
-// Caveat, and it matches what Solid's compile-time rename already does: with BOTH `id` and
-// `nativeID` on one element the last patchProp wins, where upstream gives `id` priority
-// unconditionally. Honouring that needs per-node state to remember an `id` arrived; no example or
-// test sets both, so the state is not worth carrying.
-const PROP_ALIASES = new Map([['id', 'nativeID']]);
-// An explicit `undefined` must NOT clear one of those defaults: RN treats a missing prop and an
-// explicit undefined alike, and only a literal `false` opts out of allowFontScaling. Reached
-// only when a value is already undefined, so it costs nothing on the hot path.
-function textDefaultFor(node, key) {
-    return node.isText ? TEXT_DEFAULTS.get(key) : undefined;
+// Wrapping here, at `patchProp`, needs the OWNING instance — and `getCurrentInstance()` cannot
+// supply it: Vue resets `currentRenderingInstance` at the END of `renderComponentRoot`, BEFORE
+// the subsequent `patch()` call that actually reaches `mountElement`/`patchProp`, so by the time
+// this runs it always reads null (measured via a real thrown press listener — `handleError` never
+// found the `onErrorCaptured` ancestor because `if (instance)` was false). Real Vue DOM does not
+// use `getCurrentInstance()` for this either: `hostPatchProp` is called with an explicit 6th
+// argument, `parentComponent`, threaded down through `patch`/`mountElement` from the component
+// whose render produced the vnode — the same instance the DOM renderer's own `patchEvent` passes
+// to `callWithAsyncErrorHandling`. That parameter, not the global pointer, is the correct capture.
+//
+// `callWithErrorHandling` (the SYNC form, not `callWithAsyncErrorHandling`) is deliberate: a
+// responder-negotiation callback (`onStartShouldSetResponder`, ...) returns a boolean the engine
+// reads synchronously, and the sync form is the one that returns the call's result directly
+// rather than folding it into promise-handling for the multi-hook case.
+function wrapListenerForErrorHandling(listener, instance) {
+    const wrapper = (...args) => callWithErrorHandling(listener, instance, ErrorCodes.NATIVE_EVENT_HANDLER, args);
+    // Some listeners are marker-carrying functions, not plain callbacks — Animated.event's
+    // __getHandler() (core/engine/src/animated/event.ts) hands back exactly this shape,
+    // `Object.assign((...) => {...}, { __getEvent: () => this })`, and the engine's native-driver
+    // attach path reads `__getEvent` off the prop value it was given. A fresh closure with none of
+    // the original's own properties silently breaks that — carry them forward.
+    return Object.assign(wrapper, listener);
 }
 // One renderer per mounted surface: the options close over the surface so every mutation
 // can ask it to (microtask-coalesced) recommit. Vue has no resetAfterCommit; instead
@@ -53,12 +73,10 @@ export function createSymbioteRenderer(surface) {
         createElement(type) {
             const descriptor = descriptorFor(type);
             // `type` as the third argument, not just `descriptor.component`: the behavior registry is
-            // keyed by the INTRINSIC TAG (`symbiote-pressable`), while a node only ever carries the
-            // resolved Fabric name (`RCTView`). This is the one place that still holds both, so a
-            // lowered primitive whose machine lives on the engine node can be matched at all.
+            // keyed by the INTRINSIC TAG (`pressable`), while a node only ever carries the
+            // resolved Fabric name (`RCTView`). This is the one place that holds both, so a primitive
+            // whose machine lives on the engine node can be matched at all.
             const node = createElement(descriptor.component, descriptor.isText, type);
-            if (descriptor.isText)
-                seedTextDefaults(node);
             // The imperative public-instance API (measure / setNativeProps / focus / …) is already on
             // the node's prototype, so a template/function ref to a host element exposes it exactly
             // like React's getPublicInstance and toPublicInstance is the identity. The ref must keep
@@ -69,7 +87,16 @@ export function createSymbioteRenderer(surface) {
             // one benchmark press — and a literal is built at the call site before dlog can decide
             // anything (see core/engine/src/debug.ts).
             dlog(() => `vue createElement ${descriptor.component} -> public instance`);
-            return toPublicInstance(node);
+            // markRaw is load-bearing, not an optimization: useTemplateRef()'s return value is
+            // `readonly(shallowRef(null))` (runtime-core.cjs.js), and Vue's readonly() wraps ANY
+            // `.value` whose Object.prototype.toString reads "[object Object]" — true of a plain class
+            // instance, unlike a real DOM Element, which fails that check for free. Unmarked, a node
+            // reached through useTemplateRef() (not a plain ref()/shallowRef(), both of which skip the
+            // wrap) came back as a deep-readonly Proxy: reads worked, so `committedOf`/`whenCommitted`
+            // saw a "committed" node, but `setNativeProps`'s `node.props.style = …` silently no-op'd
+            // with a dev-only "Set operation… target is readonly" warning — device-reported 2026-09-11
+            // as "flash the right chip" doing nothing on press.
+            return markRaw(toPublicInstance(node));
         },
         createText(text) {
             // Vue mounts Fragment boundaries (v-for / v-if lists / multi-root) as EMPTY text
@@ -98,25 +125,26 @@ export function createSymbioteRenderer(surface) {
             // this instead of insert() when an element's children collapse to a single string, so
             // without the check a raw text lands under a non-Text parent - an invalid Fabric tree
             // built silently, which is worse than the throw insert() would have given.
-            if (!el.isText) {
+            if (!isTextContainer(el)) {
                 throw new Error(`Text string "${text}" must be rendered inside a <Text>`);
             }
             // An RCTText carries its string as a single raw-text child. Reuse a lone existing
             // one to avoid churn; otherwise replace all children with a fresh raw-text node.
-            const [first] = el.children;
-            if (el.children.length === 1 && first !== undefined && isRawText(first)) {
+            const existing = childrenOf(el);
+            const [first] = existing;
+            if (existing.length === 1 && first !== undefined && isRawText(first)) {
                 setText(first, text);
             }
             else {
-                for (const child of el.children.slice())
+                for (const child of existing.slice())
                     removeChild(el, child);
                 appendChild(el, createRawText(text));
             }
             surface.requestCommit();
         },
         insert(child, parent, anchor) {
-            if (isRawText(child) && (isSurface(parent) || !parent.isText)) {
-                throw new Error(`Text string "${String(child.props.text)}" must be rendered inside a <Text>`);
+            if (isRawText(child) && (isSurface(parent) || !isTextContainer(parent))) {
+                throw new Error(`Text string "${textOf(child) ?? ''}" must be rendered inside a <Text>`);
             }
             if (isSurface(parent)) {
                 if (anchor)
@@ -135,7 +163,7 @@ export function createSymbioteRenderer(surface) {
         remove(child) {
             // A top-level node has no parent (it lives in surface.children); everything else
             // detaches from its retained parent.
-            const parent = child.parent;
+            const parent = parentOf(child);
             if (parent !== undefined)
                 removeChild(parent, child);
             else
@@ -143,27 +171,53 @@ export function createSymbioteRenderer(surface) {
             surface.requestCommit();
         },
         parentNode(node) {
-            return node.parent ?? surface;
+            return parentOf(node) ?? surface;
         },
         nextSibling(node) {
-            const siblings = node.parent !== undefined ? node.parent.children : surface.children;
-            const index = siblings.indexOf(node);
-            return index >= 0 ? (siblings[index + 1] ?? null) : null;
+            // `?? null` because Vue's RendererOptions types the miss as null, not undefined; the
+            // engine answers undefined uniformly and the surface fallback lives there now.
+            return nextSiblingOf(node, surface) ?? null;
         },
-        patchProp(el, key, _prev, next) {
+        patchProp(el, key, prev, next, _namespace, parentComponent) {
             if (isSurface(el))
                 return;
             // Kebab -> camel happens HERE, not only inside a component wrapper: the SFC transformer
             // lowers View/Text to their intrinsic tags (metro-vue-transformer.cjs), so those props
             // arrive one key at a time with no component to fold the bag. Idempotent for the wrapped
             // path, which already normalized.
-            const normalized = normalizeVueAttrKey(key);
-            const name = PROP_ALIASES.get(normalized) ?? normalized;
+            const name = normalizeVueAttrKey(key);
+            const value = next;
+            const routed = EVENT_PROP_NAME.test(name) && typeof value === 'function'
+                ? wrapListenerForErrorHandling(value, parentComponent ?? null)
+                : value;
             // routeProp makes the prop-vs-event decision from the node's ViewConfig (onPress on a
             // View becomes a listener; onTintColor on a Switch stays a prop), shared with React. The
             // class/style merge (explicit :style always winning, regardless of which of Vue's two
             // independent patchProp calls lands last) is centralized there too (core/engine/src/node.ts).
-            routeProp(el, name, next === undefined ? textDefaultFor(el, name) : next);
+            //
+            // `value` REACHES HERE UNCHANGED, on every re-render, and that is upstream by design:
+            // `patchProps` excludes it from its own diff and then patches it on its own line
+            // (@vue/runtime-core 3.5.39 — `if (next !== prev && key !== "value")`, then
+            // `if ("value" in newProps)`). The reason is a DOM one: typing mutates `el.value` directly,
+            // so what Vue last SET is not what the element now HOLDS, and only the element can say.
+            // Upstream pairs it with a guard in the patcher, and that half we did not have — `patchDOMProp`
+            // writes only on a difference against the element's live value (@vue/runtime-dom,
+            // `if (oldValue !== newValue || !("_value" in el))`). So every `<text-input>` re-routed its
+            // value on every re-render of its parent: 1 000 writes and ~6 000 wire slots per relabel of
+            // the benchmark list, against solid's 0 for the identical tree.
+            //
+            // On `prev` rather than on the node's own prop: the divergence upstream protects against is
+            // not visible from here — native text lives on the far side and TextInput's behavior owns the
+            // mirror — and asking the host would cost a crossing per input per render to be told the
+            // declarative value, which is what `prev` already is.
+            //
+            // The COMMIT REQUEST still goes out, which is why this skips the route and does not return.
+            // The controlled handshake hangs off the commit beat, not off the write: `afterCommit` reads
+            // the node's own `value` against its native mirror. An idle commit is O(1) (F-12) and its
+            // post-commit hooks run whether or not the commit reached the host (F-7).
+            if (key !== 'value' || prev !== next) {
+                routeProp(el, name, routed);
+            }
             surface.requestCommit();
         },
         // RN has no querySelector / scope-id / innerHTML. The first two are inert; static

package/build/runtime-helpers/index.d.ts

@@ -1,7 +1,6 @@
 export * from '@vue/runtime-core';
 import { type ObjectDirective } from '@vue/runtime-core';
 import { type ISymbioteNode } from '@symbiote-native/engine';
-export { Teleport, type ITeleportTarget } from '../create-portal';
 export declare function normalizeProps(props: Record<string, unknown> | null | undefined): Record<string, unknown> | null;
 export declare function normalizeStyle(value: unknown): unknown;
 export declare function mergeProps(...args: Record<string, unknown>[]): Record<string, unknown>;
@@ -28,6 +27,16 @@ type IEventHandler<TEvent> = ((event: TEvent, ...args: never[]) => unknown) & {
  * typed as required, matching upstream Vue's own declaration — its runtime-only `!fn` guard below
  * (for a compiler-generated call site that could pass a falsy handler) isn't reflected in the
  * type there either.
+ *
+ * `@press.self` on an element reaches this, and both halves were measured 2026-09-11 rather
+ * than assumed — the question arose because a modifier on a COMPONENT takes Vue's own event path
+ * and only an element emits the helper. `<pressable @press.self>` compiles to
+ * `_withModifiers(fn, ["self"])` imported `from "@symbiote-native/vue/runtime-helpers"` (the Metro
+ * transformer retargets every compiled `from 'vue'`), so the compiler-emitted call lands here and
+ * not on @vue/runtime-dom's. And `ISymbioteEvent` (`core/engine/src/node.ts`) declares `target`,
+ * `currentTarget` and `stopPropagation` as REQUIRED fields with the DOM semantics these guards
+ * read, so `.self` genuinely filters a bubbled press instead of degenerating to
+ * `undefined !== undefined`.
  */
 export declare function withModifiers<TEvent extends IModifierGuardableEvent>(fn: IEventHandler<TEvent>, modifiers: readonly IEventModifier[]): IEventHandler<TEvent>;
 type IKeyedEvent = {