@symbiote-native/solid 0.1.0 → 1.0.0

package/README.md

@@ -3,24 +3,24 @@
 SolidJS adapter for SymbioteNative. Compiled Solid JSX drives real native iOS/Android views through
 the same `@symbiote-native/engine` every other adapter uses — React's renderer is never in the path.
 
-**Status: L4 in progress (parity phase).** The renderer seam, `mount`/`unmount`, the primitives, the
-stateful touch components, the Touchable family, Button / ImageBackground / InputAccessoryView,
-StatusBar and the list family all ship at full parity with the React reference — off
-`@symbiote-native/components`, via `descriptorToSolid` where the component has a shared render fn.
-The engine-owned runtime modules are re-exported from the barrel. Still absent: `createPortal` and
-`createTunnel`, both of which need a same-surface replacement for `solid-js/web`'s DOM-bound
-`Portal`/`Dynamic`. See `symbiote-new-adapter` §7 for what each layer means and why the adapter is
-built in that order.
+**Status: L4 done (parity phase complete).** The renderer seam, `mount`/`unmount`, the
+primitives, the stateful touch components, the Touchable family, Button / ImageBackground /
+InputAccessoryView, StatusBar and the list family all ship at full parity with the React
+reference — off `@symbiote-native/components`, via `descriptorToSolid` where the component has a
+shared render fn. The engine-owned runtime modules are re-exported from the barrel. `Portal`
+(same-surface content relocation, this adapter's twin of React's `createPortal`) and
+`createTunnel` (cross-surface) both ship, built over the universal renderer rather than
+`solid-js/web`'s DOM-bound `Portal`/`Dynamic`. `Dynamic` itself stays absent by design — nothing
+here needs it, and no other adapter ships a twin for parity to require one. See
+`symbiote-new-adapter` §7 for what each layer means.
 
 Solid's own control-flow `Switch`/`Match` are NOT re-exported from this package: `Switch` collides
 with RN's Switch component, which every adapter must export under that name. Import the control-flow
 pair from `solid-js` directly.
 
-Publishing is gated by `"private": true` in `package.json`, which is what
-`scripts/lib/publishable-packages.mjs` filters on — so `changeset publish` and the pkg.pr.new canary
-both skip this package until that flag comes off. Without it `0.0.0` (a version absent from npm) would
-be published on the next release run, shipping a reduced surface and violating the repo's
-`<adapters_reach_full_feature_parity>` invariant. Remove the flag in the commit that finishes parity.
+The adapter is a regular publishable package (`@symbiote-native/solid` on npm, alongside React,
+Vue, Svelte and Angular) — it carries no `"private"` flag, so `changeset publish` and the
+pkg.pr.new canary cover it the same as every other adapter.
 
 ## Why Solid needs no DOM shim and no Metro transformer
 
@@ -61,6 +61,17 @@ exactly what react-refresh's `isLikelyComponentType` heuristic looks for. It the
 React Fiber tree that does not exist in this path, and the update is swallowed with no error. Force a
 full reload instead: `unstable_forceFullRefreshPatterns: [/\.tsx$/]`.
 
+## Host-primitive lowering — `<View>`/`<Text>`/`<Pressable>` compile to intrinsics, not components
+
+`babel-preset-solid` (wired above) runs `babel-lower-host-primitives.cjs` before compiling: a
+`<View>`/`<Text>` with no reactive prop, and a `<Pressable>` whose `style`/children don't need a
+component instance, rewrite to the engine's intrinsic tags (`symbiote-view`, `symbiote-text`,
+`symbiote-pressable`) instead of going through `createComponent` + a props Proxy. Nothing in app
+code has to opt in — the preset does it transparently, and a call site that can't be lowered
+(a spread, a render-prop child, an unreadable attribute) falls back to the component path
+unchanged. See root `CLAUDE.md`, "Where we stand against stock React Native", for the measured
+device numbers this bought — do not hand-copy them here, they move with every engine/adapter cut.
+
 ## `./renderer` is a compiler target, not a convenience export
 
 `babel-preset-solid` with `generate: 'universal'` rewrites JSX into direct calls imported from the
@@ -123,7 +134,7 @@ reached the same single-root conclusion for its own reasons.
 
 ## Reference
 
-- The canary app: `examples/solid` (its README covers the tarball loop and what is verified).
+- The canary app: `examples/solid` (its README covers running it and the checks it carries).
 - The engine API this targets: the `symbiote-engine-core` skill, `core/engine/src/node.ts`.
 - Building/porting an adapter: the `symbiote-new-adapter` skill.
 - The nodeOps table this mirrors: `adapters/vue/src/renderer/index.ts`.

package/babel-lower-host-primitives.cjs

@@ -0,0 +1,323 @@
+// 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/babel-preset.cjs

@@ -24,6 +24,11 @@
 // React-JSX transform gets a chance to claim the same JSX nodes.
 module.exports = function symbioteSolidBabelPreset(_api, options = {}) {
   return {
+    // Babel runs PLUGINS before PRESETS, which is exactly the order this needs: the lowering
+    // rewrites <View>/<Text> to their intrinsic tags while they are still JSX, so babel-preset-solid
+    // then compiles them as elements (createElement + setProp) instead of as components
+    // (createComponent + a props Proxy). Reversed, there would be nothing left to rewrite.
+    plugins: [require('./babel-lower-host-primitives.cjs')],
     presets: [
       [
         require('babel-preset-solid'),

package/build/components/pressable.d.ts

@@ -28,3 +28,4 @@ export interface IPressableProps extends IAccessibilityProps, IAriaProps {
     children?: IPressableChildren;
 }
 export declare function Pressable(props: IPressableProps): JSX.Element;
+export declare function TouchablePressable(props: IPressableProps): JSX.Element;

package/build/components/pressable.jsx

@@ -22,9 +22,10 @@
 // NOTHING here destructures `props`. Solid props are getters and a component body runs ONCE, so a
 // destructure would freeze the Pressable at its mount-time config; every read below sits inside an
 // accessor, a memo or an event handler.
-import { createEffect, createMemo, createSignal, splitProps, untrack, } from 'solid-js';
-import { buildPressableListeners, createPressHandlers, createPressRuntime, noteHoverNoop, resolveDisabledAccessibilityState, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, } from '@symbiote-native/components';
+import { createEffect, createMemo, onCleanup, createSignal, splitProps, untrack, } from 'solid-js';
+import { buildPressableListeners, createPressHandlers, createPressRuntime, disposePressRuntime, noteHoverNoop, resolveDisabledAccessibilityState, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, } from '@symbiote-native/components';
 import { dlog, } from '@symbiote-native/engine';
+import { setHostPressed } from '../renderer.js';
 import { View } from './view.jsx';
 // Read by Pressable itself; everything else forwards onto View. The user's press callbacks MUST be
 // split off — they are pure JS, and it is the machine's SYNTHESIZED handlers that go on the host.
@@ -51,7 +52,7 @@ const HANDLED_PROPS = [
 ];
 // `hitSlop` is deliberately NOT in that list: the machine reads it for the retention test AND the
 // host needs it to enlarge the touch target, so it forwards through `rest` untouched.
-export function Pressable(props) {
+function PressableImpl(props, minPressDuration) {
     const [local, rest] = splitProps(props, HANDLED_PROPS);
     const [pressed, setPressed] = createSignal(false);
     // The mutable press runtime (in-flight timers, suppression flags, measured region). A plain
@@ -71,7 +72,20 @@ export function Pressable(props) {
     // and not a whenCommitted case: the measure is triggered by a touch, which cannot arrive before
     // the view exists.
     const host = {
-        setPressed,
+        // Two sinks for one fact, and both are needed. The signal drives the FRAMEWORK-visible half —
+        // a functional `style`, a render-prop child — which is what forces this element to stay a
+        // component at all. `setHostPressed` drives the ENGINE-visible half, so `.btn:active` applies
+        // to a refused Pressable exactly as it would to a lowered `symbiote-pressable`. That is what
+        // makes a refusal cost the component instance and NOT the pressed styling
+        // (`.claude/rules/host-primitive-tier.md`).
+        //
+        // Before the first commit `responder` is null and the engine call is skipped: nothing is
+        // painted yet, and a press cannot arrive before the view exists.
+        setPressed: next => {
+            setPressed(next);
+            if (responder !== null)
+                setHostPressed(responder, next);
+        },
         getMeasureFn: () => {
             const node = responder;
             if (node === null)
@@ -86,7 +100,11 @@ export function Pressable(props) {
                 clearTimeout(id);
             };
         },
+        now: Date.now,
     };
+    onCleanup(() => {
+        disposePressRuntime(runtime);
+    });
     // Rebuilt when the caller's config changes (the closures capture live values); the runtime
     // persists across rebuilds, so an in-flight timer or drift flag survives one. Deliberately does
     // NOT read `pressed` — a press must not churn the handler identities the host node holds.
@@ -98,6 +116,7 @@ export function Pressable(props) {
         onLongPress: local.onLongPress,
         delayLongPress: local.delayLongPress ?? DEFAULT_DELAY_LONG_PRESS_MS,
         unstable_pressDelay: local.unstable_pressDelay ?? 0,
+        minPressDuration,
         hitSlop: rest.hitSlop,
         pressRetentionOffset: local.pressRetentionOffset,
     }, runtime, host));
@@ -183,3 +202,10 @@ export function Pressable(props) {
       {renderContent()}
     </View>);
 }
+export function Pressable(props) {
+    return PressableImpl(props, DEFAULT_MIN_PRESS_DURATION_MS);
+}
+// Relative-only composition seam; the public component barrel exports Pressable, never this.
+export function TouchablePressable(props) {
+    return PressableImpl(props, 0);
+}

package/build/components/safe-area-view.d.ts

@@ -3,6 +3,7 @@ import { type IAccessibilityProps, type IAriaProps } from '@symbiote-native/comp
 import { type IClassNameValue, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
 export interface ISafeAreaViewProps extends IAccessibilityProps, IAriaProps {
     style?: IStyleProp<IViewStyle>;
+    id?: string;
     class?: IClassNameValue;
     onLayout?: (event: ISymbioteEvent) => void;
     children?: JSX.Element;

package/build/components/text-input.js

@@ -206,6 +206,28 @@ export function TextInput(props) {
     // echoing the acknowledged count so native applies them. Every method reads `host` LIVE, so a
     // multiline swap cannot leave the handle pointing at a dead node.
     const handle = {
+        // Forwarded to the node so a TextInput ref is not poorer than any other host ref. Measured
+        // 2026-08-31: the wrapper's handle used to be five methods and thereby CLOSED OVER the node,
+        // costing the component path `measure`/`measureInWindow`/`measureLayout`/`setNativeProps`,
+        // while a lowered element handed back the bare node and lost `clear`/`isFocused`/
+        // `setSelection`. Two different surfaces, crossed by writing `multiline={isLong}` instead of
+        // `multiline`. The union is the fix; refusing to lower would only swap which four go missing.
+        measure: (callback) => {
+            if (host !== null)
+                host.measure(callback);
+        },
+        measureInWindow: (callback) => {
+            if (host !== null)
+                host.measureInWindow(callback);
+        },
+        measureLayout: (relativeToNativeNode, onSuccess, onFail) => {
+            if (host !== null)
+                host.measureLayout(relativeToNativeNode, onSuccess, onFail);
+        },
+        setNativeProps: (nativeProps) => {
+            if (host !== null)
+                host.setNativeProps(nativeProps);
+        },
         focus: () => {
             if (host !== null)
                 dispatchViewCommand(host, 'focus', []);

package/build/components/touchable/index.jsx

@@ -20,7 +20,7 @@ import { createEffect, createMemo, createSignal, onCleanup, splitProps, untrack,
 import { createHighlightUnderlayHandlers, createHighlightUnderlayRuntime, createTouchableFeedbackHandlers, createTouchableFeedbackRuntime, hasTouchablePressHandler, resolveHighlightExtraStyles, restingOpacityFromStyle, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, TOUCHABLE_MIN_PRESS_DURATION_MS, } from '@symbiote-native/components';
 import { dlog, } from '@symbiote-native/engine';
 import { Animated } from '../../modules/animated/index.js';
-import { Pressable } from '../pressable.jsx';
+import { TouchablePressable as Pressable, } from '../pressable.jsx';
 // The real timers both shared machines schedule on — core/components carries no timer globals, so
 // scheduling is the adapter's half. Every canceller is retained so unmount cancels what is still in
 // flight: a Solid body runs once, so there is no re-render that would otherwise drop a stale timer,

package/build/components/touchable-native-feedback/index.jsx

@@ -22,7 +22,7 @@ import { splitProps } from 'solid-js';
 import { backgroundProps, canUseNativeForeground, rippleBackground, selectableBackground, selectableBackgroundBorderless, } from '@symbiote-native/components';
 import { dlog } from '@symbiote-native/engine';
 import { withStableKeys } from '../../utils/stable-keys.js';
-import { Pressable } from '../pressable.jsx';
+import { TouchablePressable as Pressable, } from '../pressable.jsx';
 function TouchableNativeFeedbackImpl(props) {
     const [local, rest] = splitProps(props, [
         'background',

package/build/host-instance.js

@@ -2,9 +2,9 @@
 // adapters/vue/src/host-instance. RN's "ref/instance -> native reactTag" lookup, the seam
 // imperative-interop libraries (reanimated, gesture-handler, react-navigation) reach through.
 //
-// A Solid `ref={el}` on a symbiote host tag assigns the raw engine SymbioteNode, and the renderer
-// grafts the public-instance API onto it (toPublicInstance in renderer.ts), so the node a ref
-// receives carries measure / setNativeProps / focus exactly like React's getPublicInstance.
+// A Solid `ref={el}` on a symbiote host tag assigns the raw engine SymbioteNode, which already
+// carries measure / setNativeProps / focus on its prototype, exactly like React's
+// getPublicInstance.
 //
 // The node -> tag resolution itself belongs to the engine (getNativeTag, keyed on the raw node in the
 // commit mirror); this only unwraps the Solid-shaped inputs onto it. An uncommitted or unknown input

package/build/index.d.ts

@@ -1,3 +1,4 @@
+import './register';
 export { mount, unmount } from './render';
 export { findNodeHandle } from './host-instance';
 export type { IHostInstance } from './host-instance';

package/build/index.js

@@ -21,6 +21,8 @@
 // ./jsx-runtime, which an app reaches by config rather than by import:
 // `"jsxImportSource": "@symbiote-native/solid"` (see that file). The earlier
 // `declare module 'solid-js'` shim is gone with it — one mechanism, not two.
+// Bare, side-effect only, and deliberately NOT `export * from './register'` — see that file.
+import './register.js';
 export { mount, unmount } from './render.js';
 export { findNodeHandle } from './host-instance.js';
 export * from './components.js';

package/build/modules/animated/create-animated-component.d.ts

@@ -7,4 +7,4 @@ export interface IAnimatedComponentProps {
     children?: JSX.Element;
     [key: string]: unknown;
 }
-export declare function createAnimatedComponent(Base: Component<any>): (props: IAnimatedComponentProps) => JSX.Element;
+export declare function createAnimatedComponent(Base: Component<any> | string): (props: IAnimatedComponentProps) => JSX.Element;

package/build/modules/animated/create-animated-component.jsx

@@ -23,6 +23,7 @@
 // next reconcile drops.
 import { createEffect, mergeProps, onCleanup, splitProps, } from 'solid-js';
 import { createAnimatedLeafLifecycle, isNativeAnimatedAvailable, isSymbioteNode, readPassthroughStyle, reduceProps, resolveHostNode, whenCommitted, } from '@symbiote-native/engine';
+import { createElement, spread } from '../../renderer.js';
 import { withStableKeys } from '../../utils/stable-keys.js';
 // RN's prop carrying already-rasterized values that OVERRIDE the animated prop in the committed
 // props, so the ShadowTree (hit-testing) stays current while the native driver animates.
@@ -31,6 +32,15 @@ const PASSTHROUGH_PROP = 'passthroughAnimatedPropExplicitValues';
 // from). A precise generic cannot work: the bag handed to the base is assembled at RUNTIME from a
 // key set that grows, so no static prop type describes it. The RETURN type stays precise, so a
 // caller of Animated.View still gets a real prop type.
+// `Base` accepts a TAG as well as a component, and the string branch is not symmetry — it is the
+// only shape that works once a primitive becomes a public intrinsic. `<Base {...props} />` on a
+// capitalized identifier compiles to `createComponent(Base, …)`, which is `untrack(() => Comp(props))`
+// in solid-js, so a string base is a `TypeError: Comp is not a function` at first paint. There is
+// nothing to widen INTO either: `createRenderer()` from solid-js/universal returns twelve names and
+// `Dynamic` is not among them (solid-js/web's Dynamic is DOM-only), so the element has to be built
+// through this renderer's own createElement + spread — the same two calls solid's own Dynamic makes
+// on its string branch. `spread` handles `ref` and `children` itself (universal's spreadExpression
+// skips both in its prop loop and drives them separately), which is why nothing is threaded by hand.
 export function createAnimatedComponent(Base) {
     return function AnimatedComponent(props) {
         // The passthrough is CONSUMED (it only overrides the committed style below); `children` and
@@ -100,6 +110,18 @@ export function createAnimatedComponent(Base) {
                 return local.children;
             },
         });
+        // Narrowed HERE and not around the whole factory: `Base` is a parameter captured by this inner
+        // function, so a check outside it does not reach the JSX below.
+        if (typeof Base === 'string') {
+            const element = createElement(Base);
+            spread(element, childProps, false);
+            // createElement's return type is the renderer's node union, which includes the SURFACE — a
+            // root the renderer is handed, never something a tag produces. Narrowed rather than cast, and
+            // thrown rather than defaulted: returning null here would paint nothing and stay green.
+            if (!isSymbioteNode(element))
+                throw new Error(`createAnimatedComponent: <${Base}> did not build a host node`);
+            return element;
+        }
         return <Base {...childProps}/>;
     };
 }

package/build/register.d.ts

@@ -0,0 +1 @@
+export {};

package/build/register.js

@@ -0,0 +1,31 @@
+// Side-effect ONLY. Exports nothing, and must never be re-exported from the barrel.
+//
+// The engine's host-behavior registry is reached through a `register*` call, and CLAUDE.md records
+// what happens to one of those behind a barrel: Metro turns on `inlineRequires` for PRODUCTION
+// only, moving a `require` down to the first place its binding is used as a VALUE, and
+// `export { X } from './x'` compiles to a lazy getter. If nothing ever names the module as a value,
+// it never evaluates and the registration silently never happens — in Release builds alone,
+// invisible to tsc, to vitest, and to grepping the bundle.
+//
+// A bare `import './register';` next to a re-export of the same specifier does NOT help: Babel
+// merges the two into one dependency and the merged dependency stays lazy. The shape that works is
+// this one — a module imported ONLY for its side effect and never re-exported — the same shape
+// `packages/slider/src/{react,vue,svelte,angular}/index.ts` uses. `barrel-side-effect.test.ts` is
+// what stops a later tidy-up from "fixing" the bare import into a re-export.
+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();

package/build/renderer.d.ts

@@ -2,6 +2,7 @@ import { SymbioteSurface, type ISymbioteNode } from '@symbiote-native/engine';
 type IHostNode = ISymbioteNode | SymbioteSurface;
 export declare function setActiveSurface(surface: SymbioteSurface | undefined): void;
 export declare function replaceText(textNode: IHostNode, value: string): void;
+export declare function setHostPressed(node: IHostNode, pressed: boolean): void;
 export declare function removeNode(parent: IHostNode, node: IHostNode): void;
 export declare const render: (code: () => IHostNode, node: IHostNode) => () => void, effect: <T>(fn: (prev?: T) => T, init?: T) => void, memo: <T>(fn: () => T, equal: boolean) => () => T, createComponent: <T>(Comp: (props: T) => IHostNode, props: T) => IHostNode, createElement: (tag: string) => IHostNode, createTextNode: (value: string) => IHostNode, insertNode: (parent: IHostNode, node: IHostNode, anchor?: IHostNode | undefined) => void, insert: <T>(parent: any, accessor: T | (() => T), marker?: any | null, initial?: any) => IHostNode, spread: <T>(node: any, accessor: (() => T) | T, skipChildren?: boolean) => void, setProp: <T>(node: IHostNode, name: string, value: T, prev?: T | undefined) => T, mergeProps: (...sources: unknown[]) => unknown, use: <A, T>(fn: (element: IHostNode, arg: A) => T, element: IHostNode, arg: A) => T;
 export {};

package/build/renderer.js

@@ -17,7 +17,7 @@
 // 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, setText as setEngineText, toPublicInstance, RAW_TEXT_COMPONENT, SymbioteSurface, } from '@symbiote-native/engine';
+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';
 function isSurface(node) {
     return node instanceof SymbioteSurface;
@@ -84,6 +84,23 @@ 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.
+//
+// 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
+// twin (`setNodeHidden` from hideInstance) needs none because its reconciler is already mid-commit
+// when it calls; Solid's is not. Costs nothing when no `:active` rule is registered — the engine
+// hands back the same style object and `isAlreadyPublished` turns the re-push away without dirtying
+// the node.
+export function setHostPressed(node, pressed) {
+    if (isSurface(node))
+        return;
+    setNodePressed(node, pressed);
+    requestCommit();
+}
 export function removeNode(parent, node) {
     if (isSurface(node))
         return;
@@ -93,10 +110,57 @@ 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.
+//
+// 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.
+//
+// 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;
+}
 const nodeOps = {
     createElement(tag) {
         const descriptor = descriptorFor(tag);
-        const node = createEngineElement(descriptor.component, descriptor.isText);
+        // The TAG goes over as well, not just the resolved Fabric name. The host-behavior registry is
+        // keyed by intrinsic tag while a node only ever carries the resolved view name — `symbiote-
+        // pressable` resolves to `RCTView` — so without this the lookup asks for `RCTView` and finds
+        // 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);
         // 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
@@ -136,7 +200,7 @@ const nodeOps = {
         // 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, name, value);
+        routeProp(node, foldAliasKey(name), foldTextValue(node, name, value));
         requestCommit();
     },
     insertNode(parent, node, anchor) {

package/build/state-style.d.ts

@@ -0,0 +1 @@
+export { resolveStateStyle, type IPressStateArgument, type IResolvedStateStyle, } from '@symbiote-native/components/state-style';

package/build/state-style.js

@@ -0,0 +1,13 @@
+// Re-export only. The implementation is shared (`@symbiote-native/components`) because two adapters
+// had written byte-identical copies; this file exists so the code a transform EMITS keeps importing
+// from the adapter package the app already depends on, rather than reaching past it.
+//
+// Imported from the SUBPATH, not the barrel: every adapter barrel re-exports
+// `@symbiote-native/components` wholesale, so a name on that barrel silently becomes public API on
+// all five — which is how a transform internal nearly shipped as a supported export.
+//
+// Present on every adapter, including those with no lowering transform yet: a per-framework subpath
+// that four of five declare is exactly the silent gap `tests/package-subpath-parity.test.ts` exists
+// to catch, and the file costs a re-export. Deliberately NOT on the public barrel — the emitted
+// code names it, app code does not.
+export { resolveStateStyle, } from '@symbiote-native/components/state-style';

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "@symbiote-native/solid",
-  "version": "0.1.0",
+  "version": "1.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",
+    "symbiote-native",
+    "solid",
+    "solid-js",
+    "fabric",
+    "cross-platform",
+    "ios",
+    "android"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -39,11 +49,16 @@
       "default": "./build/jsx-runtime.js"
     },
     "./babel-preset": "./babel-preset.cjs",
-    "./metro-css-parser": "./metro-css-parser.cjs"
+    "./metro-css-parser": "./metro-css-parser.cjs",
+    "./state-style": {
+      "types": "./build/state-style.d.ts",
+      "default": "./build/state-style.js"
+    }
   },
   "files": [
     "build",
     "babel-preset.cjs",
+    "babel-lower-host-primitives.cjs",
     "metro-css-parser.cjs"
   ],
   "publishConfig": {
@@ -52,18 +67,19 @@
   "dependencies": {
     "babel-preset-solid": "^1.9.12",
     "typescript": "~6.0.0",
-    "@symbiote-native/components": "0.5.0",
-    "@symbiote-native/css-parser": "0.4.0"
+    "@symbiote-native/components": "1.0.0",
+    "@symbiote-native/css-parser": "0.5.0"
   },
   "peerDependencies": {
-    "@symbiote-native/engine": ">=0.1.7",
     "solid-js": ">=1.9.0",
-    "react-native": ">=0.86"
+    "react-native": ">=0.86",
+    "@symbiote-native/engine": "^0.4.0"
   },
   "devDependencies": {
+    "@babel/core": "^7.25.2",
     "solid-js": "^1.9.14",
-    "@symbiote-native/engine": "0.3.0",
-    "@symbiote-native/test-utils": "0.2.0"
+    "@symbiote-native/engine": "0.4.0",
+    "@symbiote-native/test-utils": "0.3.0"
   },
   "scripts": {
     "typecheck": "tsc --build",