symbiote-native

Symbiote Angular adapter build pipeline — read BEFORE touching the Angular AOT/Metro build (ngc, tsconfig.angular.json, compiler-cli/linker), an Angular-shipping package's package.json (prepare script, conditional exports), the repo ROOT's prepublish-build/build script, or the dev/watch scripts (symbiote-angular-dev.cjs). Covers: (1) two-stage AOT — Stage A ngtsc compilationMode:'partial' needs the WHOLE TS program (template type-check + cross-file imports), Stage B compiler-cli/linker/babel is a per-file plugin in Metro's babelTransformerPath; why Metro's per-file model can't run ngtsc directly; Variant 1 (two-phase ngc --watch beside Metro, shipping) vs Variant 2 (live ngtsc transformer, deferred); bench-spike compat facts (Babel 7, TS rootDir, CUSTOM_ELEMENTS_SCHEMA hyphen rule). (2) every package builds ITSELF via prepare + conditional exports, not a tsconfig paths/resolveRequest hack (TS500 ngc crash, decorators-not-enabled error). (3) why dev/start need ngc --watch beside Metro without wrapping Metro's

Symbiote add-component workflow — 'add component X to adapter Y' at FULL P0 feature-parity via the three-layer split. Read BEFORE adding or porting ANY visual component (Switch, Modal, TextInput, ScrollView, the lists, a new primitive). The split, mirroring wolf-tui: (1) LOGIC — core/components/src/state/X.ts: a pure reducer (state, action) => state + createInitialXState factory + pure predicates, ZERO framework/render (Switch: switchReducer, shouldSnapBack, valueFromChange). (2) VIEW — core/components/src/view/render-X.ts: a pure renderX(view, platform) => Descriptor built with el()/txt(), PLUS the agnostic public IXProps (extends IAccessibilityProps, IAriaProps), the IXViewProps with its `passthrough` bag (ref + handlers + a11y ride here untouched), and IXPlatform (per-host prop-name mapping). (3) LIFECYCLE — the adapter: React useReducer/useRef/useLayoutEffect + dispatchViewCommand + descriptorToReact; Vue shallowRef(identity!)/ref/watch(flush:'post') + runtime guards (no `as`) + descriptorToVue. React's S

Symbiote examples/ vs .examples/ split — read BEFORE wiring up, smoke-testing, or demoing ANY new component/adapter/package/third-party wrapper in an example app, or before editing any example app's package.json dependency versions, metro.config.js, or react-native.config.js. `examples/{react,vue-sfc,vue-tsx,angular}` are PUBLIC canary apps and, since 2026-07-14, are OUTSIDE the pnpm workspace entirely (removed from pnpm-workspace.yaml's `packages:`) — a standalone npm-installable tree with NO `catalog:`/`workspace:*` specifiers (those only resolve inside a pnpm workspace); every dependency is a literal version, and every `@symbiote-native/*` is a pkg.pr.new canary URL until each package has a real npm release. Install with plain `npm install` INSIDE the example directory, never `pnpm install` from repo root. `.examples/{react,vue-sfc,vue-tsx,angular}` (dot-prefixed, gitignored) is UNCHANGED — the ONLY place package/feature/adapter development happens, still inside the pnpm workspace on `workspace:*` for live

Symbiote file layout & placement conventions — read BEFORE creating, moving, or renaming ANY file in the SymbioteNative monorepo, or deciding where a type / module / component goes. Covers (1) the MONOREPO MAP — core/{engine,components}, adapters/{react,vue}, examples/{react,vue-sfc,vue-tsx}, packages/{slider,android}, .docs/, .ng-spike/. (2) ADR 0026 FOLDER-AS-MODULE — a module that has platform (X.ios/X.android) and/or shared (X-shared) variants lives in its OWN folder X/ with an index barrel (X/index.ts base, X/index.ios.ts, X/index.android.ts, X/shared.ts, co-located X/X.test.ts); the real example is core/engine/src/vibration/. A SINGLE-file module with no variants STAYS FLAT (node.ts, commit.ts). The import contract is unchanged: from '.../X' resolves to the folder; only an explicit platform import changes ('.../X.ios' → '.../X/index.ios', '.../X-shared' → '.../X/shared'). (3) ADAPTER src/ BUCKETS — components/ modules/ utils/ carry the SAME name in every adapter; the lifecycle bucket is framework-idioma

Symbiote React adapter — createPortal (create-portal.ts, host-config.ts's Container type) AND createTunnel (create-tunnel.tsx). Read BEFORE touching host-config.ts's Container/reconciler generics, adding createPortal, or reaching for cross-surface content sharing. Covers why real RN's Fabric can't support createPortal (persistent mode) while @symbiote-native/react (mutation mode) can; createPortal is an instance method on the built reconciler, not a package export; the Container-type widening; isSymbioteNode as the guard; why same-surface-only is createPortal's PERMANENT scope (researched: facebook/react#17147, pmndrs/tunnel-rat) — cross-surface uses createTunnel instead. createTunnel's In/Out are COMPONENTS (Context.Provider/Consumer shape), not hooks — an earlier hook-based version caused a real infinite-render-loop white screen when In/Out shared a component; separate components structurally prevent it (Out's forced re-render never bounces into In), which useMemo/deps-array approaches only patch around.

Symbiote dependency-version management — read BEFORE adding a dependency, bumping a version, scaffolding a new package, or touching ANY package.json / pnpm-workspace.yaml. The monorepo has ONE source of truth for versions: pnpm CATALOGS in pnpm-workspace.yaml. A package NEVER writes a literal version for an external dep — it references `catalog:` (default) or `catalog:NAME`. Covers: (1) the CATALOG LAYOUT — default `catalog:` holds every single-versioned dep (react, react-native 0.86 toolchain, vue, babel, jest, detox, typescript, vitest, prettier, eslint10 + root tooling); the named `catalogs.rn-app` holds ONLY the deps that legitimately cannot share the workspace version. (2) the RULES — prod+dev deps MUST be `catalog:`; peerDependencies are NEVER catalogued (they are compatibility RANGES like `0.86+`, not pins); `@symbiote-native/*` stay `workspace:*`; the `react` override is `'catalog:'` (quoted!). (3) the GUARD — syncpack `policy: catalog` in .syncpackrc.json, run via `pnpm deps:check` / auto-fixed via `

Symbiote navigation web-router-facade — DEFERRED ROADMAP decision (2026-07, beta). Read BEFORE building or re-proposing a web-router-style navigation API in packages/navigation (useRouter/useNavigate/Link/useParams/useLocalSearchParams/RouterLink/RouterView/router-outlet/routerLink/loaders), or when asked to make navigation feel like react-router / vue-router / expo-router / @angular/router, or to 'transfer web navigation knowledge to native'. Current package intentionally mirrors React Navigation (Stack.Screen name, useNavigation().navigate('Name'), useRoute/useFocusEffect/useIsFocused), NOT web routers. Holds: the DEFER rationale (beta bottleneck is shipping a minimal package set to build a real app, not evaluator-funnel DX); the SHAPE to build when resumed (lean verbs first — imperative router + Link + useParams/useRoute + linking-config route table; anchor to Expo Router shape; ONE shape lightly reskinned per framework not 3 clones; keep useNavigation as escape hatch and add useRouter; DEFER loaders/actio

Symbiote npm publishing & versioning — read before touching .changeset/**, a publishable package's `publishConfig`/`files`/`exports`, .github/workflows/release.yml, or running `pnpm changeset`/`pnpm run release`. Versioning is Changesets (`pnpm changeset` → PR → 'Version Packages' PR → merge → CI publishes). Core trick: `main`/`exports` keep pointing at `src/index.ts` for in-repo dev (Metro/tsc resolve live TS, unchanged) — `publishConfig` overrides those to `build/` ONLY inside the tarball, never touching local resolution. No new bundler: `tsc --build` already emits `build/`, so `typecheck` IS the build. `@symbiote-native/angular`/`@symbiote-native/slider`'s `./angular` entry predate this, use a DIFFERENT mechanism (conditional `exports`, AOT build) — don't convert or copy that onto plain packages. Covers the mechanism table, the `files`-mandatory gotcha (`.gitignore` excludes `build/`), the `fix-esm-extensions` argument-list gotcha (a package missing from it ships an unimportable `build/` for every real npm

Symbiote CSS/CSS-Modules compiler — CSS (a Vue SFC style block, or a standalone .css/.module.css file), PLUS optional SCSS/Sass, Less, and Stylus preprocessor sources, compiled at build time into RN style objects, resolved at runtime via a class-name registry shared by ALL adapters (React className, Vue class, Angular addClass/removeClass). Read BEFORE touching core/css-parser/**, core/engine/src/style-registry/**, the class+style merge in core/engine/src/node.ts routeProp, style-block handling in examples/*/metro-vue-transformer.js, any adapter's metro-css-parser.cjs / metro-css-transformer.js, or adapters/*/renderer.ts's class-prop handling. Covers @symbiote-native/css-parser (build-time postcss compiler, never shipped in the app bundle, distributed as a regular dependency of each adapter package rather than a per-app devDependency), core/css-parser/src/preprocessors.ts (lazy-optional sass/less/stylus, devDependencies only), core/engine/src/style-registry (registerStyles/resolveClassName/scopeClassName), ro

Symbiote Vue adapter/package attrs kebab-to-camel normalization — read BEFORE writing or porting any Vue lifecycle component (adapters/vue/src/**, or a new packages/*/src/vue/*.ts config-object component like Stack/Tab/Drawer) that reads options off the setup context's raw `attrs`. Use when a kebab-case-authored SFC template prop (`drawer-position="right"`, `:screen-options="..."`) is silently ignored / falls back to its default, or when porting a new Vue component and deciding how it should read multi-word option props. Root cause: Vue's compiler does NOT camelCase $attrs — it only camelCases DECLARED `props`, and this codebase's components deliberately never declare formal `props` schemas, so every one of them must manually normalize via `normalizeVueAttrs` at entry.

Symbiote Vue adapter — compiler-injected runtime helper shims (v-show, Teleport, custom directives) over the non-DOM renderer, PLUS createTunnel for cross-surface content sharing. Read BEFORE touching examples/*/metro-vue-transformer.js, any 'from vue' import rewrite, wiring a Vue built-in (v-show, Teleport) or custom directive over a host node, or reaching for cross-surface content sharing. Covers why v-show/Teleport silently no-op or fail to build by default, the runtime-helpers shim (adapters/vue/src/runtime-helpers.ts), setNativeProps for v-show, isSymbioteNode as Teleport's guard, and why same-surface-only is Teleport's PERMANENT scope, not a gap — use createTunnel (adapters/vue/src/create-tunnel.ts, its In/Out are SLOT-BASED COMPONENTS, not composables — the React twin also lands on In/Out components, not hooks, after an earlier hook version caused a real infinite-render-loop bug) instead, do not invent commit-scheduling plumbing or duck-typed validation for any of this.

Symbiote raw-Vue-TSX (.tsx, @vue/babel-plugin-jsx) typecheck setup — read BEFORE adding a typecheck script to any Vue app authored in raw TSX (not .vue SFC — those go through vue-tsc's Volar plugin and don't hit this), or when vue-tsc/tsc reports a component 'is not a valid JSX element type... missing properties from type Component<any,any,any>: context, setState, forceUpdate, render' or 'Tag X expects at least 2 arguments, but the JSX factory React.createElement provides at most 1'. Root cause: TS's JSX checker resolves JSX.* via the configured jsxFactory's OWN namespace FIRST (default 'React.createElement' -> 'React.JSX', which @types/react exports) and only falls back to a global JSX namespace if that lookup finds nothing — so a plain `declare global { namespace JSX {...} }` shim has ZERO effect whenever react/react-native are also top-level deps in the same tsconfig program, which every symbiote example app requires. Fix: point jsxFactory at a dummy namespace React never touches so the fallback actually t

Symbiote Angular adapter change detection — read BEFORE debugging why a component renders but does not REPAINT after a flat-bag onX/responder/PanResponder mutation, before touching SymbioteHostPropsDirective or render.ts's CD wiring, or before assuming ApplicationRef.tick() fixes a whole-tree rebuild on press. Covers: whenCommitted async-commit gotcha (from Vue); SignalView vs CheckAlways (Angular 20 @Component views are SignalView, so a flat-bag onX mutation dirties nothing — fix is markForCheck(), NOT detectChanges()); zoneless scheduling + ApplicationRef.tick() (unreachable pre-fix, missing INJECTOR_SCOPE:'root', Targeted vs Global mode); a hypothesis DISPROVED: Targeted mode does NOT stop a press re-running the root template (markViewDirty walks RefreshView|Dirty to root); protected (@Component) vs not (@if/@for). Trigger: 'renders but doesn't repaint', 'rebuild whole tree on press', markForCheck vs detectChanges, NG0201/ApplicationRef failures, template literals losing referential stability.

Symbiote Angular adapter event conversion — read BEFORE converting a callback @Input() (onPress, onValueChange, onFocus…) to a real @Output() EventEmitter in adapters/angular/**, or debugging: a handler firing TWICE per interaction, an NG2007 AOT-only 'not decorated' error from ngc (not plain tsc), an NG8002 'binding to event property disallowed' error after converting an INNER wrapped component's prop, an @Output() name colliding with an existing method (focus/blur), or whether onScroll-family props should ever become @Output() (never — Animated.event() markers can't bind to a listener). Covers listen()'s anchor-transparency double-fire cause, @Directive()-required-on-abstract-base (SwitchBase), wrapped-component forwarding breakage (FlatList→VirtualizedList→ScrollView/RefreshControl, ImageBackground→Image), the @Output('focus') alias trick, and the Button/IButtonProps fork mirroring Vue. Angular twin of vue-adapter-events — read that instead for Vue's emits/attrs conversion.

Symbiote Angular adapter — FlatList/SectionList/VirtualizedList/VirtualizedSectionList/ScrollView bugs. Read BEFORE touching adapters/angular/src/components/{flat-list,section-list,virtualized-list,virtualized-section-list,scroll-view}/** or debugging blank list cells, cells outside the ScrollView (horizontal FlatList painting as a full vertical stack), an infinite CD loop/freeze once cells render, an unwanted RefreshControl (SCROLL-MULTI), or 2+ ng-content declarations projecting into only ONE. Covers: (1) bare ng-content passthrough breaking @ContentChild across a second re-projection hop (VListOutletDirective, asItem cast helper); (2) an ngDoCheck rebuilding a child's context unconditionally — a real infinite loop, fixed via a dependency-snapshot guard; (3) (event)="x.emit($event)" forwarding poisoning .observed (refreshRequested fix) — real cause of a freeze first misattributed to bug 2; (4) ng-content duplicated across @if/@else, fixed on iOS (one host tag) and Android (one shared ng-template + outlet).

Symbiote Angular adapter — createPortal + createTunnel (create-portal.ts, create-tunnel.ts) AND AppRegistry + dynamic component composition (modules/app-registry/index.ts). Read BEFORE touching either file, adding a structural directive relocating content, wiring projectableNodes/createComponent, or extending AppRegistry's wrapperComponentProvider. Angular twin of react-adapter-portal, analog of vue-adapter-directives' portal half — read those two FIRST for the cross-surface-out-of-scope rationale. Covers why Angular can't be a per-call factory (no runtime JIT); PortalOutletDirective/PortalDirective (structural directive into the destination's ViewContainerRef, not a Renderer2 move; strictTemplates replaces isSymbioteNode); createTunnel's signal store + TunnelInDirective/TunnelOut (a rendering slot); the redesign from components to structural directives; AND AppRegistry's createDetachedViewHost + projectableNodes recipe for composing dynamic components without JIT, plus the selectRootElement bug surfaced.

Detox e2e test suites for the four canary example apps (examples/{react,vue-sfc,vue-tsx,angular}/e2e). Read before touching examples/*/e2e/canary-journeys.test.ts, examples/*/e2e/probe.test.ts, or any examples/*/detox.config.js, and before running `npx detox test` to debug a failure. canary-journeys.test.ts is BYTE-IDENTICAL across react/vue-sfc/vue-tsx (the file's own header explains why: Detox attaches below the renderer, so the same journeys prove any adapter) — a fix in one MUST be copied to the other two, never patched in just one. Documents two real, fixed flakiness bugs (scroll-momentum drift after bringIntoView, a bare expect racing the JS->recommit round-trip under detoxEnableSynchronization:0) and one OPEN, unresolved investigation (the counter-card second-tap 'not hittable' failure, proven to be a Detox-side false negative, not an app bug, via manual mobile-mcp taps) — read the open-investigation section before re-diagnosing this from scratch. Also covers general workflow gotchas: leftover Metro on

Symbiote docs-site package-page template — read BEFORE writing or restructuring apps/docs-site/src/content/docs/docs/packages/*.mdx for any @symbiote-native/* wrapper package (slider, splash-screen, and every future one). Fixes the section order and, specifically, mandates a canonical `## API` heading (never `## Props` / `## Props / config` / any ad-hoc name) with one `###` sub-table per surface group (Props, Events, an imperative function's Signature, a hook/composable's config, a hook/composable's return value). Every table row MUST carry a real one-line human-readable Description — inspired by VueUse's function pages (vueuse.org/core/useX), which pair each TypeScript field with an inline JSDoc comment so the description can never drift from the type; we don't auto-generate from TSDoc (no build-time extractor yet), so the discipline is manual: no blank/empty Description cells, ever — an empty cell is the single most common way this template rots. Reference implementations: docs/packages/slider.mdx (Props ta

Symbiote engine core — how to drive @symbiote-native/engine correctly, read BEFORE writing or debugging any core/engine/** code OR any adapter renderer seam (host-config / createRenderer / Renderer2) that calls the engine. The engine is a retained MUTABLE shadow-tree that the engine alone translates into Fabric's persistent CLONE-ON-WRITE child sets; every adapter drives the same tiny mutation API and NONE re-implements persistence. Covers (1) the MUTATION API in core/engine/src/node.ts — createElement / createRawText / createAnchor / appendChild / insertBefore / removeChild / setProp / setEventListener / setText, and the ONE entry point flat-bag adapters use, routeProp (it decides onX→event-vs-prop via the ViewConfig, strips React __self/__source, attaches responder events) — do NOT pre-split events yourself. (2) NODE IDENTITY — the engine keeps mirror = WeakMap<ISymbioteNode, …> in commit.ts; every imperative API does mirror.get(node) and bails if absent, so a node must be held by IDENTITY, never wrapped (V

Read when investigating a visual glitch on iOS (flicker, seam, border, color snap, momentary artifact near screen edges/corners/navigation header) reported against a Symbiote example app on iOS 26+. Covers two confirmed iOS 26 'Liquid Glass' system rendering behaviors mistaken for app bugs during a real navigation investigation: (1) a 1px anti-aliasing seam at the device's rounded screen corners, brightness ~130-215 gray, position drifting by x as y changes (following the corner arc) — confirmed present in Settings.app, not Symbiote-specific; (2) UINavigationBar back buttons rendering as a translucent floating pill immediately after a push/pop, then morphing into the flat/opaque bar style — also confirmed in Settings.app on a dark screen. Covers the decisive verification method: reproduce the SAME interaction in a stock system app (Settings) at the same screen position/theme, since iOS 26 chrome varies by background lightness (near-invisible on light screens, obvious on dark ones) — this cross-app comparison

Symbiote new-adapter workflow — building a NEW framework adapter (Svelte, Solid, …) or porting/debugging an existing one's renderer seam. Read ALONGSIDE symbiote-engine-core (that skill is the engine API you target; this one is how a framework attaches to it). The core idea: every modern UI framework exposes a framework-agnostic rendering abstraction — Vue createRenderer(RendererOptions), React react-reconciler host config, Angular Renderer2/RendererFactory2 — and the adapter is just that abstraction's methods mapped onto the engine mutation API (createElement / appendChild / insertBefore / removeChild / routeProp / setText), nothing more. Covers (1) the seam mapping, with the LITERAL Vue nodeOps table (adapters/vue/src/renderer.ts) as the reference. (2) COMMIT STRATEGY — the single biggest choice: sync surface.commit() (React, already batches) vs microtask-coalesced surface.requestCommit() after every mutation (Vue/Svelte/Angular). (3) toPublicInstance graft on createElement so a host ref exposes measure/foc

Symbiote parity-check workflow — verify a component reaches FULL feature-parity across adapters, the P0 'proven by a parity check' gate. Run it as the LAST phase of symbiote-add-component, or standalone to audit an existing component for drift. React is the REFERENCE surface (M1/M2 done, widest prop-edge coverage). Method: (1) enumerate X's complete surface on React — every prop, event, imperative method, and platform (.ios/.android) branch. (2) prop-by-prop DIFF against X on Vue (and each future adapter); any prop/event/method present on React but missing on the other is a P0 gap, NOT a follow-up. (3) confirm parity is STRUCTURAL — the shared half (reducer + renderX + prop resolution) lives in @symbiote-native/components and both adapters call it, rather than each re-implementing the surface (a hand-copied surface that happens to match today will drift). (4) confirm the agnostic public prop type (ISwitchProps etc.) is RE-EXPORTED from @symbiote-native/components by every adapter, never redeclared. (5) smoke

Symbiote react-native-import testability — read BEFORE writing any NEW file in core/engine, core/components, or an adapter (adapters/react|vue|angular) that imports from 'react-native' directly (processColor, DeviceEventEmitter, Image, AppRegistry, a deep RN internal path, etc.), or before adding a new package.json 'exports' subpath, or when a Vitest run throws 'RolldownError: Parse failure: Flow is not supported' / 'Cannot find package react-native'. Covers: (1) WHY — react-native's own source is Flow syntax; Vitest's Rolldown/Vite transform cannot parse it, so a file that imports 'react-native' must stay OUTSIDE every package's main index.ts barrel and outside anything a test transitively imports. (2) THE PATTERN — export such a file via a separate package.json 'exports' subpath (precedent: './metro-css-parser', './runtime-helpers', './bootstrap') instead of the main barrel; Metro resolves these subpaths fine (unstable_enablePackageExports is on by default in this repo's metro-config). (3) THE TEST RECIPE —

Symbiote third-party native-VIEW wrapper workflow — read BEFORE making a React-Native library that ships a native VIEW component (@react-native-community/slider, react-native-*, any codegenNativeComponent) usable from a NON-React adapter (Vue/Angular/Svelte/Solid), or building/debugging a @symbiote-native/PKG wrapper package, or deciding where such a wrapper and its native dependency go. This is the realized track of ADR 0014 + the third_party_rn_packages_are_react_only invariant; the reference implementation is @symbiote-native/slider (packages/slider, ADR 0027). Covers: (1) WHY a wrapper at all — the library's default export is a React component (useState/hooks) that throws under a non-React adapter's null dispatcher; you reach the native view through the engine createNode-by-ViewConfig path instead, never by importing the React component. (2) PACKAGE SHAPE — a self-contained packages/PKG package (NOT core/components, NOT an adapter), one framework-agnostic src/core (pure folds + renderX returning a Descrip

Symbiote web-library portability check — read BEFORE adding any npm library marketed as 'pure', 'framework-agnostic', or 'isomorphic' (react-router's matchPath/matchRoutes, vue-router's memory history, any 'works everywhere' utility) as a dependency of core/, adapters/*, or packages/*. Apparent purity from docs/memory is not sufficient evidence in this DOM-free Metro/Hermes monorepo. Covers the concrete case that motivated this: react-router's matchPath/matchRoutes/generatePath were evaluated for packages/navigation's deep-linking layer and REJECTED after actually installing and inspecting the package — its only general `.` export eagerly imports `./lib/dom/*` and `./lib/server-runtime/*` (no pure-matcher subpath exists), its peerDependencies pin react-dom (conflicts with `<react_native_is_an_explicit_top_level_peer>`), and its param-name typing relies on compile-time literal-string inference that degrades to plain `string` for our runtime-computed patterns — forcing an `as` cast, which ts-js-best-practices f

Symbiote Vue adapter event typing + attrs routing — read BEFORE adding or changing Vue component events in adapters/vue/** or packages/*/src/vue/**. Use when converting React-style onX callback props to Vue emits, fixing Volar payload inference for SFC/TSX, deciding whether an event should be emits or raw passthrough, wiring a host callback after Vue removed a listener from $attrs, or adding v-model / update:modelValue support to a controlled-value component (TextInput, Switch, Slider…). Core rule: typed emits are for wrapper-synthesized/normalized events; raw Fabric/native passthrough listeners must remain attrs unless the wrapper manually re-supplies the host onX callback.

Symbiote Vue adapter reactivity + commit-timing gotchas — read BEFORE writing or debugging any Vue adapter code (adapters/vue/**) that holds an engine SymbioteNode or other engine/native object in Vue reactive state (ref/reactive/computed), or wires a host-element ref, or calls an imperative/native engine API (dispatchViewCommand / measure / measureInWindow / setNativeProps / getNativeTag / focus / blur / sendAccessibilityEvent / connectAnimatedNodeToView / addAnimatedEventToView / attachNativeEvent). TWO distinct gotchas. (1) IDENTITY: a snap-back / imperative command that silently does nothing, the engine dlog 'dispatchViewCommand "X" skipped: node not committed' (or '… skipped: node not committed' from measure/setNativeProps), a host ref that 'holds the right node but the command misses' — engine nodes must be held by identity (shallowRef / markRaw), never a deep ref, which wraps the object in a reactive Proxy the engine WeakMap mirror misses. (2) ASYNC-COMMIT TIMING: a NATIVE-driven feature that works on

Symbiote Vue adapter scoped slots + slot typing — read BEFORE adding or changing how any Vue component (adapters/vue/**) renders children / cells / headers / separators, or when a slot scope types as `any` (e.g. Pressable `pressed`, a list `item`). Core rule: parametrized rendering on Vue is a SCOPED SLOT, never a React-style renderItem / ItemSeparatorComponent / render-prop — those are removed from the Vue public contract (no duality; ADR 0028). Use when converting a renderItem-prop component to slots, typing a slot scope so SFC `template #item=...` and JSX infer it (thread the slots type through ICtx Emits+Slots), wiring a slot to the shared render layer via slots-to-render-props, killing the `Non-function value encountered for default slot` warn, or wiring vue-tsc typecheck for an SFC example. Slot return type is VNode[] or VNode. Triggers: Vue slot typing, pressed is any, item is any in template, scoped slot, renderItem to slot, SlotsType, vue-tsc example typecheck.