@symbiote-native/solid 1.0.0 → 3.0.0

package/build/renderer.js

@@ -17,13 +17,13 @@
 // babel.transformSync over representative JSX (elements, dynamic text, <Show>, <For>, spread,
 // ref) rather than read off the docs.
 import { createRenderer } from 'solid-js/universal';
-import { appendChild, createAnchor, createElement as createEngineElement, createRawText, dlog, insertBefore, removeChild as removeEngineChild, routeProp, setNodePressed, setProp as setEngineProp, setText as setEngineText, toPublicInstance, RAW_TEXT_COMPONENT, SymbioteSurface, } from '@symbiote-native/engine';
-import { descriptorFor } from '@symbiote-native/components';
+import { appendChild, createAnchor, createElement as createEngineElement, createRawText, dlog, firstChildOf, insertBefore, isRawTextNode, isTextContainer, nextSiblingOf, parentOf, removeChild as removeEngineChild, routeProp, setNodePressed, setProp as setEngineProp, setText as setEngineText, textOf, toPublicInstance, SymbioteSurface, propOf, } from '@symbiote-native/engine';
+import { descriptorFor, TEXT_INPUT_MULTILINE_TAG, } from '@symbiote-native/components';
 function isSurface(node) {
     return node instanceof SymbioteSurface;
 }
 function isRawText(node) {
-    return !isSurface(node) && node.component === RAW_TEXT_COMPONENT;
+    return !isSurface(node) && isRawTextNode(node);
 }
 // One active surface per process. This is FORCED here, not chosen: the compiled-JSX contract above
 // means every mutation arrives through module-level functions with no surface argument, so there is
@@ -50,11 +50,6 @@ function requestCommit() {
     }
     activeSurface.requestCommit();
 }
-function siblingsOf(node) {
-    if (node.parent !== undefined)
-        return node.parent.children;
-    return activeSurface?.children ?? [];
-}
 // Hoisted out of nodeOps and exported because descriptor-to-solid.ts needs the same text-update
 // path for a Descriptor's string child, and createRenderer() only hands back the 11 names the JSX
 // compiler imports — replaceText is not among them. Going through here rather than calling the
@@ -84,10 +79,7 @@ function asText(value) {
 // has to DETACH its anchor host from the portal target on cleanup. Going through here rather than
 // calling the engine's removeChild directly is what keeps the mutation paired with requestCommit(),
 // and keeps the surface-vs-node branch in one place.
-// The REFUSED path's half of `:active`, and the reason a refusal costs the component instance
-// rather than the pressed styling. A `<Pressable>` the lowering left as a component still owns its
-// own press machine, and one call here puts the node into its pressed state so `.btn:active`
-// applies exactly as it would on a lowered tag.
+// The `:active` half: one call here puts the node into its pressed state so `.btn:active` applies.
 //
 // Exported paired with requestCommit() for the same reason removeNode below is: the press arrives
 // from a NATIVE EVENT, outside any renderer mutation, so nothing else schedules a commit. React's
@@ -110,45 +102,35 @@ export function removeNode(parent, node) {
         removeEngineChild(parent, node);
     requestCommit();
 }
-const TEXT_FOLDS = new Map([
-    ['ellipsizeMode', value => value ?? 'tail'],
-    ['allowFontScaling', value => value !== false],
-]);
-function seedTextDefaults(node) {
-    for (const [key, fold] of TEXT_FOLDS)
-        setEngineProp(node, key, fold(undefined));
-}
-// Seeding at CREATE is not enough, and the gap is device-only. A framework that clears a prop it
-// set earlier hands us an explicit `undefined` at PATCH time, and the default has to come BACK
-// rather than stay cleared — RN treats a missing prop and an explicit undefined alike, and only a
-// literal `false` opts out of allowFontScaling. Two Map lookups on text nodes only, and none at
-// all on a View, so it stays off the hot path.
-function foldTextValue(node, key, value) {
-    if (!node.isText)
-        return value;
-    const fold = TEXT_FOLDS.get(key);
-    return fold === undefined ? value : fold(value);
-}
-// The alias fold, at the RENDERER and not only in the transform — the defect class Angular paid for
-// twice on 2026-08-31. A lowered element inherits nothing the component wrapper did, and the
-// compile-time rename in `babel-lower-host-primitives.cjs` covers exactly the call sites the
-// transform REWROTE: `<View id={x} />` is fine (the attribute name is renamed before the preset
-// compiles it, dynamic value included), but a hand-written `<symbiote-view id="x">` is not, and it
-// committed `id` — a key Fabric does not know — while the component committed `nativeID`. Measured
-// by mounting both forms and diffing committed key NAMES; totals were identical and said nothing.
+// RN's two Text defaults left this renderer on 2026-09-18, and the per-key FOLD went with them. It
+// was the last and subtlest of the three shapes this file tried: a create-time SEED (gone a month
+// earlier, 6 000 wasted crossings per 1 000-row create), then a substitute-on-`undefined`, then a
+// fold per key — because `?? 'tail'` has to catch a null too, and substituting only on `undefined`
+// meant `<text ellipsizeMode={null}>` committed null, device-only and silent.
 //
-// The transform's rename STAYS. It is not redundant: it means the markup path arrives here already
-// spelled `nativeID`, so the common case never takes the branch below with a key to rewrite.
+// All three were answering a question the layer below now answers for everyone: the rule reads the
+// AUTHORED bag at payload time (`foldTextDefaults`, `SymbioteFabricProps.cpp`), where a null, an
+// explicit `undefined` and an absent prop are all simply "not a value the author chose". The
+// null case that cost this file two revisions is `ellipsize->isNull()` there, in one place, for
+// every adapter.
+// The `id` -> `nativeID` fold and its `aliasedNodes` WeakSet left this file on 2026-09-18. The
+// memory was the right shape and the wrong LAYER: `routeProp` carries it now, so all five adapters
+// resolve the precedence identically instead of three of them doing it three ways.
+// `multiline` selects between TWO Fabric views, so the TAG decides and no prop write moves a node
+// between them. An author writing `<text-input multiline>` instead of `<text-input-multiline>` gets
+// the single-line view with a prop no ViewConfig on it declares — two silent divergences.
 //
-// One string comparison rather than a Map lookup, because this sits on the per-prop write path —
-// 32 001 prop writes on a benchmark create, where a Map.get is the kind of cost the engine spent
-// this month removing. That is only safe while every primitive shares ONE alias pair, which is a
-// property of the shared spec and not of this file, so `renderer-alias-fold.test.ts` re-derives
-// both constants from `HOST_PRIMITIVES` and fails the moment a second pair appears.
-const ALIAS_FROM = 'id';
-const ALIAS_TO = 'nativeID';
-function foldAliasKey(name) {
-    return name === ALIAS_FROM ? ALIAS_TO : name;
+// The shared behavior (`core/components/src/behaviors/text-input.ts`) already makes the PAYLOAD
+// follow the tag. The complaint has to live here instead of there: `foldPayload` runs inside the
+// commit, so a throw from it lands a tick later as an uncaught exception with no frame naming the
+// call site — measured, a test awaiting the mount sees `nothing committed` rather than the error.
+const MULTILINE_PROP = 'multiline';
+function assertMultilineMatchesTag(node, value) {
+    if ((value === true) === (propOf(node, MULTILINE_PROP) === true))
+        return;
+    throw new Error(`multiline={${String(value)}} contradicts the tag: <text-input> and ` +
+        `<text-input-multiline> are different Fabric views and no prop write moves a node ` +
+        `between them. Pick the tag (a runtime choice needs a <Show> around both).`);
 }
 const nodeOps = {
     createElement(tag) {
@@ -159,8 +141,10 @@ const nodeOps = {
         // nothing, and the press machine silently never attaches. Registering under the Fabric name
         // instead would be worse: every plain `View` would get a press machine.
         const node = createEngineElement(descriptor.component, descriptor.isText, tag);
-        if (descriptor.isText)
-            seedTextDefaults(node);
+        // Only the multiline tag is seeded: writing `multiline: false` on the single-line one would add
+        // a key the wrapper's payload does not carry, i.e. a divergence in the other direction.
+        if (tag === TEXT_INPUT_MULTILINE_TAG)
+            setEngineProp(node, MULTILINE_PROP, true);
         // Graft the imperative public-instance API (measure / setNativeProps / focus / …) onto the raw
         // node so a `ref` to a host element exposes it exactly like React's getPublicInstance.
         // toPublicInstance mutates in place and returns the SAME node identity, so the engine's commit
@@ -196,11 +180,13 @@ const nodeOps = {
     setProperty(node, name, value) {
         if (isSurface(node))
             return;
+        if (name === MULTILINE_PROP)
+            assertMultilineMatchesTag(node, 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), and centralizes the class+style
-        // merge. Shared with React and Vue — never re-implement an `onX` check here
-        // (symbiote-engine-core §2).
-        routeProp(node, foldAliasKey(name), foldTextValue(node, name, value));
+        // merge and the `id` -> `nativeID` rename. Shared with React and Vue — never re-implement an
+        // `onX` check here (symbiote-engine-core §2).
+        routeProp(node, name, value);
         requestCommit();
     },
     insertNode(parent, node, anchor) {
@@ -210,12 +196,12 @@ const nodeOps = {
         if (isSurface(node))
             return;
         const before = anchor !== undefined && !isSurface(anchor) ? anchor : undefined;
-        if (isRawText(node) && (isSurface(parent) || !parent.isText)) {
+        if (isRawText(node) && (isSurface(parent) || !isTextContainer(parent))) {
             // Fabric has no bare-text host: RCTRawText is only valid as a <Text> child. Reached by a
             // dynamic expression that resolves to a string outside a <Text>, e.g.
             // `<symbiote-view>{label()}</symbiote-view>`. Failing loudly at mount beats building an
             // invalid tree that crashes deeper in native with a far less legible error.
-            throw new Error(`Text string "${String(node.props.text)}" must be rendered inside a <Text>`);
+            throw new Error(`Text string "${textOf(node) ?? ''}" must be rendered inside a <Text>`);
         }
         if (isSurface(parent)) {
             if (before !== undefined)
@@ -232,10 +218,27 @@ const nodeOps = {
         requestCommit();
     },
     removeNode,
+    // Reverse of `getFirstChild`'s `childHost` redirect: a child under a composed primitive's slot
+    // has `node.parent` pointing at the SLOT, but `cleanChildren`'s `isParent = getParentNode(el)
+    // === parent` compares against the OWNER — the same reference the JSX-level `insert()` call was
+    // given. Left un-redirected, that comparison is false for every child of a bare `<scroll-view>`
+    // (or any other slotted primitive) with a following sibling, so `isParent` never fires,
+    // `removeNode` is never called on a full array clear, and the old children are orphaned: still
+    // committed to Fabric, still retained, and re-diffed against on the next reconciliation —
+    // reproduced as unbounded RAM growth and an increasingly slow "Clear" on the benchmark screen.
+    // One level up only: `childHost` is always a DIRECT child the owner built (see `buildStructure`),
+    // never a deeper descendant.
     getParentNode(node) {
         if (isSurface(node))
             return undefined;
-        return node.parent ?? activeSurface;
+        const parent = parentOf(node) ?? activeSurface;
+        if (parent === undefined || isSurface(parent))
+            return parent;
+        const grandparent = parentOf(parent);
+        if (grandparent !== undefined && grandparent.childHost === parent) {
+            return grandparent;
+        }
+        return parent;
     },
     // Anchors are NOT filtered out of this or getNextSibling, deliberately. solid-js/universal keeps
     // its own record of which nodes it put where and re-derives positions through these two lookups
@@ -243,15 +246,25 @@ const nodeOps = {
     // getFirstChild(parent) to replace text in place). Hiding a node the runtime itself inserted
     // desyncs that record from the real tree. Anchors are invisible to FABRIC — the commit walk skips
     // them — not to tree traversal.
+    //
+    // `childHost` redirected, same as the engine's own `appendChild`/`insertBefore`/`removeChild`
+    // (`hostFor`, core/engine/src/node.ts): a composed primitive's real children live on the slot it
+    // built, not on the owner it was asked to insert into, and `insert()`'s reconciliation reads this
+    // to know what is ALREADY there before deciding what to insert/move/remove. Reading the owner's
+    // own (single-child) array here would have every dynamic child on a bare `<scroll-view>` diffed
+    // against the wrong node — invisible on VirtualizedList, which never calls `insert()` on the
+    // owner directly, and wrong for any app writing `<scroll-view>{dynamicChildren}</scroll-view>`.
     getFirstChild(node) {
-        return node.children[0];
+        if (isSurface(node))
+            return node.children[0];
+        return firstChildOf(node.childHost ?? node);
     },
     getNextSibling(node) {
         if (isSurface(node))
             return undefined;
-        const siblings = siblingsOf(node);
-        const index = siblings.indexOf(node);
-        return index >= 0 ? siblings[index + 1] : undefined;
+        // The surface is handed over because a TOP-LEVEL node has no parent to read a sibling list
+        // from — the surface owns that list. The engine returns undefined rather than guessing.
+        return nextSiblingOf(node, activeSurface);
     },
 };
 // The compiled-JSX contract. See the module header: these names are imported by generated code,

package/build/utils/stable-keys.d.ts

@@ -1 +1 @@
-export declare function withStableKeys(props: () => Record<string, unknown>): () => Record<string, unknown>;
+export declare function withStableKeys<TProps extends object>(props: () => TProps): () => Record<string, unknown>;

package/build/utils/stable-keys.js

@@ -12,9 +12,10 @@
 // the actual diffing. Never hand-roll that diff instead.
 //
 // Lives here rather than beside either caller because BOTH reach for it: descriptorToSolid wraps
-// a render fn's Descriptor props, and the host primitives (View, Text) wrap their own
-// resolveAccessibilityProps output — the same function, the same two-branch key set. Any future
-// Solid component that folds props through a whole-object transform belongs on this too.
+// a render fn's Descriptor props, and a component that spreads a folded bag onto a bare `<view>`
+// (Pressable, KeyboardAvoidingView) wraps its own — the same function, the same two-branch key
+// set. This is the one capability a bare tag does NOT inherit from the wrappers that used to own
+// it, so any Solid component folding props through a whole-object transform belongs on it too.
 export function withStableKeys(props) {
     const seen = new Set();
     return () => {
@@ -22,9 +23,9 @@ export function withStableKeys(props) {
         const widened = {};
         for (const key of seen)
             widened[key] = undefined;
-        for (const key of Object.keys(next)) {
+        for (const [key, value] of Object.entries(next)) {
             seen.add(key);
-            widened[key] = next[key];
+            widened[key] = value;
         }
         return widened;
     };

package/metro-css-parser.cjs

@@ -5,4 +5,5 @@
 // .cjs, not .js: this package is "type": "module", but Metro's babelTransformerPath loading needs
 // a require()-able file. createCssMetroTransformer() is a factory — Metro needs the actual
 // {transform, getCacheKey} object it returns, not the css-parser package barrel.
-module.exports = require('@symbiote-native/css-parser').createCssMetroTransformer();
+module.exports =
+  require('@symbiote-native/css-parser').createCssMetroTransformer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/solid",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "description": "SymbioteNative's Solid adapter — a solid-js/universal createRenderer driving real native iOS/Android views through the same engine as every other adapter.",
   "keywords": [
     "react-native",
@@ -49,16 +49,11 @@
       "default": "./build/jsx-runtime.js"
     },
     "./babel-preset": "./babel-preset.cjs",
-    "./metro-css-parser": "./metro-css-parser.cjs",
-    "./state-style": {
-      "types": "./build/state-style.d.ts",
-      "default": "./build/state-style.js"
-    }
+    "./metro-css-parser": "./metro-css-parser.cjs"
   },
   "files": [
     "build",
     "babel-preset.cjs",
-    "babel-lower-host-primitives.cjs",
     "metro-css-parser.cjs"
   ],
   "publishConfig": {
@@ -67,19 +62,19 @@
   "dependencies": {
     "babel-preset-solid": "^1.9.12",
     "typescript": "~6.0.0",
-    "@symbiote-native/components": "1.0.0",
+    "@symbiote-native/components": "3.0.0",
     "@symbiote-native/css-parser": "0.5.0"
   },
   "peerDependencies": {
     "solid-js": ">=1.9.0",
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^0.4.0"
+    "@symbiote-native/engine": "^1.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "solid-js": "^1.9.14",
-    "@symbiote-native/engine": "0.4.0",
-    "@symbiote-native/test-utils": "0.3.0"
+    "@symbiote-native/engine": "1.0.0",
+    "@symbiote-native/test-utils": "0.3.1"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/babel-lower-host-primitives.cjs

@@ -1,323 +0,0 @@
-// Compile-time lowering of <View>/<Text> to the intrinsic tags the renderer maps to Fabric.
-//
-// WHY. Solid charges a props PROXY per component: `<View>` compiles to `createComponent(View, …)`,
-// and the component body then runs splitProps + withStableKeys + mergeProps + spread. Measured
-// 2026-08-23 on a 4 000-row create: keys/get/getOwnPropertyDescriptor traps 16.2% of the whole
-// create, splitProps another 6.1%. Lowered, the same element compiles to `createElement(tag)` plus
-// one `setProp` per attribute — no Proxy, no bag object, no spread render effect. Headless A/B with
-// both arms compiled for real and createNode asserted equal at 36 002: -24.3% min / -30.0% median.
-//
-// The Vue twin is the nodeTransform in adapters/vue/metro-vue-transformer.cjs, and the two share
-// their central rule: lower ONLY a tag this file imported from us, never a bare name match, or an
-// app's own <View> gets rewritten.
-//
-// THE SECOND RULE IS THE ONE THAT KEEPS IT HONEST: lower only when the WHOLE attribute set is
-// visible. The wrapper components do real work besides forwarding — resolveAccessibilityProps
-// folds aria-*/role into the composite accessibilityState/accessibilityValue, and `id` is RN's
-// W3C alias for `nativeID`. Deleting the wrapper without carrying those over breaks accessibility
-// silently. `id` is a pure rename and is done below FROM THE SHARED SPEC; the aria fold is a BAG
-// operation, so an
-// element carrying aria-*/role — or a spread whose keys cannot be read — is left as a component.
-// A folded-at-compile-time aria bag is a possible follow-up (the bag exists statically, so it
-// would cost nothing at runtime); refusing is what makes shipping this safe without it.
-//
-// .cjs because Babel require()s it and this package is "type": "module".
-
-// The tag map and the per-tag folds come from the SHARED spec, not from a copy here. Four
-// transforms carried their own before it existed and they had already disagreed on `id` (see that
-// file's `aliases` comment). Data only — every line of AST work below stays this adapter's, and so
-// does the whole refusal mechanism; only the SPECIFICATION is shared.
-const {
-  HOST_PRIMITIVES,
-  REFUSAL_CATEGORIES,
-} = require('@symbiote-native/components/host-primitives');
-
-const SOURCE = '@symbiote-native/solid';
-
-// name -> a projection of the shared spec. Built once at plugin load, so the per-element path stays
-// two Map lookups.
-//
-// This is a WHITELIST, and it fails silently in one direction: a field the shared spec grows and
-// this list does not copy simply never reaches the detections, which then behave as if it were
-// absent. Cost measured 2026-08-31 — `intrinsicWhen` was implemented end to end and every
-// multiline case still lowered to the single-line tag, because the field was dropped here. Add a
-// field to the spec, add it here.
-const LOWERABLE = new Map(
-  Object.entries(HOST_PRIMITIVES).map(([name, spec]) => [
-    name,
-    {
-      intrinsic: spec.intrinsic,
-      aliases: new Map(Object.entries(spec.aliases)),
-      // Every primitive refuses on the bag fold and on anything unreadable. A primitive whose
-      // STATE the template can observe refuses on more, and only the spec knows which those are —
-      // `observesState` is set for a tag the shared spec marks that way, so a transform that has
-      // not implemented the extra detections simply never sees such a tag in its map.
-      observesState: spec.observesState === true,
-      // The two-intrinsic selector (`{ prop, intrinsic }`), absent for a primitive with one tag.
-      intrinsicWhen: spec.intrinsicWhen,
-    },
-  ]),
-);
-
-function attributeName(attribute) {
-  const { name } = attribute;
-  if (name.type === 'JSXIdentifier') return name.name;
-  // JSXNamespacedName — `aria-label` parses as an identifier, but `xml:lang` style names land here.
-  return `${name.namespace.name}:${name.name.name}`;
-}
-
-// Every local name bound to a lowerable export of @symbiote-native/solid in THIS file, honouring
-// `import { View as Box }`. A file that imports nothing from us yields an empty map and is skipped
-// whole.
-function lowerableLocalNames(programPath) {
-  const names = new Map();
-  programPath.node.body.forEach(statement => {
-    if (
-      statement.type !== 'ImportDeclaration' ||
-      statement.source.value !== SOURCE
-    )
-      return;
-    statement.specifiers.forEach(specifier => {
-      if (specifier.type !== 'ImportSpecifier') return;
-      const imported =
-        specifier.imported.type === 'Identifier'
-          ? specifier.imported.name
-          : specifier.imported.value;
-      const spec = LOWERABLE.get(imported);
-      if (spec !== undefined) names.set(specifier.local.name, spec);
-    });
-  });
-  return names;
-}
-
-// REFUSAL_CATEGORIES.renderPropChild — a child function that TAKES the state.
-//
-// ARITY, not `typeof`, and that distinction is the whole rule. A zero-argument arrow is an ordinary
-// Solid child (`JSX.Element` covers `() => Element`), exactly as `<For>`'s map fn is; only a
-// function that accepts the state argument is a render prop. Measured over `examples/solid`: 12 of
-// the 19 `<Pressable>` sites pass a function child and TEN of those are zero-arity, so refusing on
-// `typeof` alone would throw away ten lowerable sites — including `ActionButton`, whose one
-// definition is instantiated 146 times.
-function isRenderPropChild(child) {
-  if (child.type !== 'JSXExpressionContainer') return false;
-  const { expression } = child;
-  return (
-    (expression.type === 'ArrowFunctionExpression' ||
-      expression.type === 'FunctionExpression') &&
-    expression.params.length >= 1
-  );
-}
-
-// A JSX element is lowerable only if every attribute is a plain, named one we can account for —
-// plus, for a state-observing primitive, only if nothing in it reads that state.
-function canLower(element, spec, types) {
-  const { openingElement } = element;
-  // Named attributes only — a spread cannot be enumerated
-  // (REFUSAL_CATEGORIES.unreadableAttributeSet).
-  //
-  // The category's STATED reason — that a transform cannot fold `id` -> `nativeID` inside a bag — is
-  // DEAD here, measured 2026-08-31: this adapter also folds at runtime (`renderer.ts`,
-  // `foldAliasKey`), which sees every key whatever shape it arrived in, and a lowered
-  // `<symbiote-view {...bag} />` commits a payload byte-identical to the wrapper's
-  // (`src/spread-fold-parity.test.tsx`). The refusal stands on two OTHER grounds it never named,
-  // both measured by lifting it and compiling:
-  //
-  //   <TextInput {...bag} />   ->  symbiote-text-input, whatever `bag.multiline` holds. The
-  //                                single-line tag is a different NATIVE VIEW and no later prop
-  //                                write repairs it (REFUSAL_CATEGORIES.dynamicIntrinsicChoice).
-  //   <Pressable {...bag} />   ->  no `activeStyle` emitted. The same functional style written
-  //                                directly emits it; inside a bag the expansion never runs, so a
-  //                                pressed style silently stops existing.
-  //
-  // So: a refuted rationale is not a refuted verdict. Do not lift this because the alias half is
-  // covered — check what ELSE reads the attribute list first.
-  //
-  // `role` / `aria-*` used to refuse here too, on the
-  // grounds that their fold needs to see sibling keys and a per-key element path cannot reproduce
-  // it. That was true of the ELEMENT path and is no longer true of anything: the fold moved into
-  // the engine (`core/engine/src/accessibility-props.ts`, called from `fabricProps` — the one place
-  // the whole bag is visible on both commit paths), so a lowered element gets it exactly as a
-  // wrapped one does. Proven on the committed payload, both arms, in `src/aria-fold-parity.test.tsx`.
-  const attributesAreReadable = openingElement.attributes.every(
-    attribute => attribute.type === 'JSXAttribute',
-  );
-  if (!attributesAreReadable) return false;
-  if (!selectsIntrinsicStatically(openingElement, spec)) return false;
-  // BEFORE the `observesState` early-return, not after. It rode below it while the only ref-refusing
-  // primitive was Pressable, which observes state — a coincidence, and TextInput broke it: it
-  // observes nothing, so the early-return fired first and a `<TextInput ref>` lowered anyway. The
-  // two questions are independent, so the checks are ordered by what they ask, not by what happened
-  // to work.
-  if (refWouldChangeSurface(spec) && openingElement.attributes.some(isInstanceBinding))
-    return false;
-  // Everything below is about a primitive whose STATE the template can observe.
-  if (!spec.observesState) return true;
-  // A functional `style` NEVER refuses, and since 2026-09-01 it is not rewritten either: the
-  // expression rides through unchanged and `routeProp` resolves it at both values of `pressed`
-  // (`isStyleCallback`, `core/engine/src/node.ts`). The build-time split that used to live here was
-  // removed after measuring it — `src/state-style-cost.bench.test.ts` — because it emitted TWO
-  // writes per node where the callback emits one, so it cost run time rather than saving it.
-  return !element.children.some(isRenderPropChild);
-}
-
-// REFUSAL_CATEGORIES.dynamicIntrinsicChoice.
-//
-// A primitive whose `intrinsicWhen` is set picks between TWO Fabric views by a prop —
-// `symbiote-text-input` vs `symbiote-text-input-multiline`, which are different native views rather
-// than one view with a flag (`core/components/src/view/render-text-input.ts`). The transform prints
-// a STATIC tag name, so it can only make that choice when the value is a compile-time literal.
-//
-// The refusal is stricter than the neighbouring ones and the difference is worth keeping in view:
-// an unreadable ATTRIBUTE VALUE means a prop arrives wrong, and a later write can still correct it.
-// Here the wrong NATIVE VIEW is committed, and no subsequent prop write repairs that — the node
-// would have to be destroyed and recreated. So a value this cannot read statically keeps the
-// component, which resolves the choice at runtime where the value is known.
-//
-// IDENTITY, not truthiness. The render fn is `view.multiline ? MULTILINE : SINGLE`, so truthiness
-// is what the RUNTIME does, and describing the compile-time check that way makes `multiline={1}`
-// look like something this should resolve. It must not: only three shapes are accepted — a bare
-// attribute is `true`, a boolean LITERAL is itself, an absent prop is `false` — and everything else
-// refuses, a truthy non-boolean literal included. A check justified by truthiness would let `{1}`
-// through at the next edit, which is exactly the silently-wrong native view the refusal exists to
-// prevent. Recorded as identity in the shared spec for the same reason.
-function staticTruthOf(openingElement, propName) {
-  const attribute = openingElement.attributes.find(
-    candidate =>
-      candidate.type === 'JSXAttribute' &&
-      attributeName(candidate) === propName,
-  );
-  if (attribute === undefined) return false;
-  if (attribute.value === null) return true;
-  if (attribute.value.type !== 'JSXExpressionContainer') return undefined;
-  const { expression } = attribute.value;
-  return expression.type === 'BooleanLiteral' ? expression.value : undefined;
-}
-
-function selectsIntrinsicStatically(openingElement, spec) {
-  return (
-    spec.intrinsicWhen === undefined ||
-    staticTruthOf(openingElement, spec.intrinsicWhen.prop) !== undefined
-  );
-}
-
-function intrinsicFor(openingElement, spec) {
-  if (spec.intrinsicWhen === undefined) return spec.intrinsic;
-  return staticTruthOf(openingElement, spec.intrinsicWhen.prop) === true
-    ? spec.intrinsicWhen.intrinsic
-    : spec.intrinsic;
-}
-
-// REFUSAL_CATEGORIES.instanceBoundDirective. The criterion is NOT "does the component expose a
-// ref" — that was a proxy, and it held only while two primitives existed. The rule is: would
-// lowering hand the app something DIFFERENT from what the component hands it? A lowering transform
-// is an optimisation, and an optimisation that moves the observable surface in EITHER direction is
-// a bug. Three shapes, one rule, all readable from the components' own props types:
-//
-//   View, Text   ref?: Ref<IHostInstance>      lowered yields the same node    -> lower
-//   Pressable    no ref declared               lowering would ADD a handle     -> refuse
-//   TextInput    ref?: Ref<ITextInputHandle>   lowering would SWAP the handle  -> refuse
-//
-// TextInput is the case that exposed the proxy: it declares a ref, so the old criterion said
-// "lower", and a lowered `<TextInput ref>` silently dropped `clear`, `isFocused` and
-// `setSelection` — the component's handle replaced by a bare public instance. Costing an app three
-// methods is exactly as wrong as granting it one it never had.
-//
-// PER-ADAPTER by construction, which is why this is a list here and not a field on the shared
-// spec: what a ref yields is a fact about THIS adapter's props types, and a correct adapter can
-// answer differently — Vue refuses on every primitive, because a Vue template ref yields the
-// component instance rather than the host node whatever the component declares.
-//
-// Kept honest by `ref-refusal-matches-components.test.ts`, which re-derives the answer from each
-// component source: a hand-written list of adapter members is what went stale three times this
-// month.
-// INVERTED 2026-09-01, and the inversion is the point rather than the contents. This was a
-// denylist of intrinsics that refuse a `ref`, so every primitive added to the spec defaulted to
-// LOWERING one — and the newest member falls out of a hand-written list every time, which is the
-// failure mode this repo has now recorded four times. As a denylist that default is a correctness
-// bug (a lowered element hands back an object the component never did); as an allowlist the same
-// omission costs only coverage, which is the direction a default should fail in.
-//
-// A name earns its place here by the criterion in `ref-refusal-matches-components.test.ts`: the
-// component hands a `ref` the ENGINE NODE, either by declaring `ref?: Ref<IHostInstance>` or by
-// rendering through `descriptorToSolid`, whose `spread` calls a bag ref with the node it built. Any
-// other answer — a different handle, or no ref at all — means lowering would move the surface.
-const INTRINSICS_YIELDING_HOST_REF = new Set([
-  'symbiote-view',
-  'symbiote-text',
-  'symbiote-image',
-]);
-
-
-function refWouldChangeSurface(spec) {
-  return !INTRINSICS_YIELDING_HOST_REF.has(spec.intrinsic);
-}
-
-function isInstanceBinding(attribute) {
-  return (
-    attribute.type === 'JSXAttribute' && attributeName(attribute) === 'ref'
-  );
-}
-
-// Per TAG, not global: the spec gives each primitive its own alias map, and reading it per tag is
-// what keeps this honest if they ever stop agreeing.
-function renameAliasedAttributes(openingElement, aliases, types) {
-  openingElement.attributes.forEach(attribute => {
-    // A spread has no name, and the author's own spread refuses in `canLower`, so nothing this
-    // loop sees is one. It used to be reachable: the state-style pass emitted a spread for an
-    // opaque style, and that pass is gone.
-    if (attribute.type !== 'JSXAttribute') return;
-    const renamed = aliases.get(attributeName(attribute));
-    if (renamed !== undefined) attribute.name = types.jsxIdentifier(renamed);
-  });
-}
-
-module.exports = function lowerHostPrimitives({ types }) {
-  return {
-    name: 'symbiote-solid-lower-host-primitives',
-    visitor: {
-      Program(programPath) {
-        const names = lowerableLocalNames(programPath);
-        if (names.size === 0) return;
-        programPath.traverse({
-          JSXElement(elementPath) {
-            const { openingElement, closingElement } = elementPath.node;
-            const tag = openingElement.name;
-            if (tag.type !== 'JSXIdentifier') return;
-            const spec = names.get(tag.name);
-            if (spec === undefined) return;
-            // A shadowing local binding (a parameter or a `const View = …` in scope) is NOT our
-            // import, even though the name matches. Only rewrite when the binding at this use site
-            // is still the module-level import.
-            const binding = elementPath.scope.getBinding(tag.name);
-            if (binding === undefined || binding.kind !== 'module') return;
-            if (!canLower(elementPath.node, spec, types)) return;
-            // Read BEFORE the passes below rewrite attributes — `renameAliasedAttributes` could
-            // in principle rename the selector out from under the choice.
-            const intrinsic = intrinsicFor(openingElement, spec);
-            renameAliasedAttributes(openingElement, spec.aliases, types);
-            openingElement.name = types.jsxIdentifier(intrinsic);
-            if (closingElement)
-              closingElement.name = types.jsxIdentifier(intrinsic);
-          },
-        });
-      },
-    },
-  };
-};
-
-// Attached AFTER the plugin assignment on purpose: `module.exports = fn` replaces the object, so a
-// named export written above it is silently discarded. Exists only so the test below can compare
-// this list against the component sources.
-module.exports.INTRINSICS_YIELDING_HOST_REF = INTRINSICS_YIELDING_HOST_REF;
-
-// The spec fields this transform reads, named so `spec-projection-covers-fields.test.ts` can check
-// the whitelist above against what `HOST_PRIMITIVES` actually carries. `defaults` is deliberately
-// absent: prop defaults are seeded at RUNTIME by the renderer (`seedTextDefaults`), where a patch
-// that clears a prop can restore them — a compile-time copy would cover only the initial render.
-module.exports.SPEC_FIELDS_READ = [
-  'intrinsic',
-  'aliases',
-  'observesState',
-  'intrinsicWhen',
-];
-module.exports.SPEC_FIELDS_IGNORED = ['defaults'];

package/build/components/activity-indicator/index.android.d.ts

@@ -1,2 +0,0 @@
-export type { IActivityIndicatorProps, IActivityIndicatorSize } from './shared';
-export declare const ActivityIndicator: (props: import("./shared").IActivityIndicatorProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;