@tamagui/native-registry 3.0.3 → 3.0.4

package/cpp/HybridTamaguiRegistry.cpp

@@ -2,6 +2,8 @@
 
 #include <jsi/JSIDynamic.h>
 #include <react/renderer/components/root/RootShadowNode.h>
+#include <react/renderer/components/text/ParagraphShadowNode.h>
+#include <react/renderer/textlayoutmanager/TextMeasureCache.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/core/ShadowNode.h>
@@ -12,7 +14,9 @@
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/renderer/uimanager/primitives.h>
 
+#include <cstring>
 #include <unordered_set>
+#include <vector>
 
 namespace margelo::nitro::tamagui::registry {
 
@@ -22,12 +26,13 @@ using margelo::nitro::Prototype;
 void HybridTamaguiRegistry::loadHybridMethods() {
   HybridTamaguiRegistrySpec::loadHybridMethods();
   registerHybrids(this, [](Prototype& prototype) {
-    prototype.registerRawHybridMethod("link", 3, &HybridTamaguiRegistry::link);
+    prototype.registerRawHybridMethod("link", 4, &HybridTamaguiRegistry::link);
+    prototype.registerRawHybridMethod("linkTables", 4,
+                                      &HybridTamaguiRegistry::linkTables);
     prototype.registerRawHybridMethod("applyViewStates", 1,
                                       &HybridTamaguiRegistry::applyViewStates);
-    prototype.registerRawHybridMethod(
-        "updateViewStateTables", 1,
-        &HybridTamaguiRegistry::updateViewStateTables);
+    prototype.registerRawHybridMethod("setTableState", 3,
+                                      &HybridTamaguiRegistry::setTableState);
     prototype.registerRawHybridMethod("getViewState", 1,
                                       &HybridTamaguiRegistry::getViewState);
   });
@@ -36,7 +41,7 @@ void HybridTamaguiRegistry::loadHybridMethods() {
 jsi::Value HybridTamaguiRegistry::link(jsi::Runtime& rt, const jsi::Value&,
                                        const jsi::Value* args, size_t count) {
   if (count < 3) {
-    throw jsi::JSError(rt, "link(shadowNode, slots, scopeId) requires 3 arguments");
+    throw jsi::JSError(rt, "link(shadowNode, slots | tableId, scopeId) requires 3 arguments");
   }
   if (!args[0].isObject()) return jsi::Value::undefined();
   auto obj = args[0].asObject(rt);
@@ -46,17 +51,90 @@ jsi::Value HybridTamaguiRegistry::link(jsi::Runtime& rt, const jsi::Value&,
 
   runtime_ = &rt;
 
-  auto slots = jsi::dynamicFromValue(rt, args[1]);
   const double id = nextId_++;
-  views_[id] = LinkedView{
-      wrapper->shadowNode,
-      args[2].asString(rt).utf8(rt),
-      slots.getDefault("base", nullptr),
-      slots.getDefault("state", nullptr),
-  };
+  auto& view = views_[id];
+  view.node = wrapper->shadowNode;
+  view.scopeId = args[2].asString(rt).utf8(rt);
+  if (args[1].isNumber()) {
+    auto& table = tables_[args[1].asNumber()];
+    if (!table) table = std::make_shared<Table>();
+    view.table = table;
+  } else {
+    auto slots = jsi::dynamicFromValue(rt, args[1]);
+    view.baseProps = slots.getDefault("base", nullptr);
+    view.stateProps = slots.getDefault("state", nullptr);
+  }
+
+  if (count > 3 && args[3].isBool() && args[3].getBool()) {
+    if (const auto* name = viewStateName(view)) {
+      LeafUpdates updates;
+      buildViewUpdate(view, *name, updates);
+      commitUpdates(rt, updates);
+    }
+  }
   return jsi::Value(id);
 }
 
+// links many views to shared tables in one call: entry i is shadow node
+// nodes[i] on table tableIds[i] under scope scopes[scopeIndexes[i]]. ids are
+// issued in order starting at the returned id; an entry without a live shadow
+// node still consumes its id and stays unlinked
+jsi::Value HybridTamaguiRegistry::linkTables(jsi::Runtime& rt, const jsi::Value&,
+                                             const jsi::Value* args, size_t count) {
+  if (count < 4 || !args[0].isObject() || !args[1].isObject() ||
+      !args[2].isObject() || !args[3].isObject()) {
+    throw jsi::JSError(
+        rt, "linkTables(nodes, tableIds, scopeIndexes, scopes) requires 4 arrays");
+  }
+  runtime_ = &rt;
+  auto nodes = args[0].asObject(rt).asArray(rt);
+  auto tableIds = args[1].asObject(rt).asArray(rt);
+  auto scopeIndexes = args[2].asObject(rt).asArray(rt);
+  auto scopeValues = args[3].asObject(rt).asArray(rt);
+
+  std::vector<std::string> scopes(scopeValues.size(rt));
+  for (size_t i = 0; i < scopes.size(); i++) {
+    scopes[i] = scopeValues.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+  }
+
+  const size_t size = nodes.size(rt);
+  const double firstId = nextId_;
+  nextId_ += static_cast<double>(size);
+
+  std::shared_ptr<Table> table;
+  double tableId = -1;
+  for (size_t i = 0; i < size; i++) {
+    auto value = nodes.getValueAtIndex(rt, i);
+    if (!value.isObject()) continue;
+    auto obj = value.asObject(rt);
+    if (!obj.hasNativeState(rt)) continue;
+    auto wrapper = obj.getNativeState<ShadowNodeWrapper>(rt);
+    if (!wrapper || !wrapper->shadowNode) continue;
+
+    // consecutive entries usually share a table
+    const double nextTableId = tableIds.getValueAtIndex(rt, i).asNumber();
+    if (!table || nextTableId != tableId) {
+      tableId = nextTableId;
+      auto& entry = tables_[tableId];
+      if (!entry) entry = std::make_shared<Table>();
+      table = entry;
+    }
+
+    auto& view = views_[firstId + static_cast<double>(i)];
+    view.node = wrapper->shadowNode;
+    view.scopeId = scopes.at(
+        static_cast<size_t>(scopeIndexes.getValueAtIndex(rt, i).asNumber()));
+    view.table = table;
+  }
+  return jsi::Value(firstId);
+}
+
+const std::string* HybridTamaguiRegistry::viewStateName(
+    const LinkedView& view) const {
+  return view.activeState.empty() ? activeStateName(view.scopeId)
+                                  : &view.activeState;
+}
+
 void HybridTamaguiRegistry::unlink(double id) {
   views_.erase(id);
 }
@@ -123,10 +201,32 @@ using LeafUpdates = HybridTamaguiRegistry::LeafUpdates;
 using AffectedNodes =
     std::unordered_map<const ShadowNodeFamily*, std::unordered_set<size_t>>;
 
+// records, for every ancestor of an updated view, which children lead to one.
+// returns whether `node` is or contains an updated view
+bool collectAffected(const ShadowNode& node, const LeafUpdates& updates,
+                     AffectedNodes& affected) {
+  bool hit = updates.contains(&node.getFamily());
+  const auto& children = node.getChildren();
+  for (size_t index = 0; index < children.size(); index++) {
+    if (collectAffected(*children[index], updates, affected)) {
+      affected[&node.getFamily()].insert(index);
+      hit = true;
+    }
+  }
+  return hit;
+}
+
 AffectedNodes findAffectedNodes(const RootShadowNode& root,
                                 const LeafUpdates& updates) {
   AffectedNodes affected;
-  for (const auto& [family, props] : updates) {
+  // getAncestors scans each parent's children to find the child, so many
+  // updates under one wide parent (a long list) cost updates x siblings; past
+  // a few updates one walk of the tree is cheaper
+  if (updates.size() > 32) {
+    collectAffected(root, updates, affected);
+    return affected;
+  }
+  for (const auto& [family, update] : updates) {
     // families of unmounted views have no ancestors in this root: skipped
     for (const auto& [parentNode, childIndex] : family->getAncestors(root)) {
       affected[&parentNode.get().getFamily()].insert(childIndex);
@@ -135,61 +235,165 @@ AffectedNodes findAffectedNodes(const RootShadowNode& root,
   return affected;
 }
 
+// RN dirties the measurement of every paragraph cloned with props, and the
+// dirty flag relays out each ancestor: one text color in each row of a long
+// list relays out the whole list. for a paragraph of plain strings, whose
+// fragments take exactly its own text attributes, rebuild those attributes
+// the way ParagraphShadowNode::getContent does; when RN's own measure cache
+// would call them layout-equivalent (colors, decorations, shadows, opacity),
+// restyle the laid-out text directly and build the node without the clone
+// step that dirties it. null when the update needs a real layout
+std::shared_ptr<ShadowNode> restyleParagraph(const ShadowNode& node,
+                                             const Props::Shared& props) {
+  if (std::strcmp(node.getComponentName(), ParagraphComponentName) != 0) {
+    return nullptr;
+  }
+  for (const auto& child : node.getChildren()) {
+    if (std::strcmp(child->getComponentName(), "RawText") != 0) return nullptr;
+  }
+  const auto& nextProps = static_cast<const ParagraphProps&>(*props);
+  const auto& paragraph = static_cast<const ParagraphShadowNode&>(node);
+  if (!(nextProps.paragraphAttributes ==
+        paragraph.getConcreteProps().paragraphAttributes)) {
+    return nullptr;
+  }
+
+  auto data = paragraph.getStateData();
+  auto layoutManager = data.layoutManager.lock();
+  if (!layoutManager || data.attributedString.getFragments().empty()) {
+    return nullptr;
+  }
+  const auto& laidOut = data.attributedString.getBaseTextAttributes();
+  auto attributes = TextAttributes::defaultTextAttributes();
+  attributes.fontSizeMultiplier = laidOut.fontSizeMultiplier;
+  attributes.apply(nextProps.textAttributes);
+  attributes.layoutDirection = laidOut.layoutDirection;
+  if (!areTextAttributesEquivalentLayoutWise(laidOut, attributes)) {
+    return nullptr;
+  }
+  for (auto& fragment : data.attributedString.getFragments()) {
+    fragment.textAttributes = attributes;
+  }
+  data.attributedString.setBaseTextAttributes(attributes);
+
+  const ShadowNodeFragment fragment{
+      .props = props,
+      .children = ShadowNodeFragment::childrenPlaceholder(),
+      .state = node.getComponentDescriptor().createState(
+          node.getFamily(), std::make_shared<const ParagraphState>(std::move(data))),
+  };
+  // what ConcreteComponentDescriptor::cloneShadowNode does, minus
+  // completeClone (the dirtying step); adopt only sets the layout manager.
+  // a yoga style change still dirties the node through its constructor
+  auto clone = std::make_shared<ParagraphShadowNode>(node, fragment);
+  clone->setTextLayoutManager(std::move(layoutManager));
+  node.transferRuntimeShadowNodeReference(clone, fragment);
+  return clone;
+}
+
 std::shared_ptr<ShadowNode> cloneSubtree(const ShadowNode& node,
                                          const LeafUpdates& updates,
                                          const AffectedNodes& affected) {
   const auto* family = &node.getFamily();
-  auto children = node.getChildren();
 
+  // only an ancestor of an updated view gets new children: RN dirties the
+  // layout of any measurable node (text) cloned with a children fragment,
+  // so passing them to the updated views themselves would re-measure every
+  // text and re-run layout for a color change
+  auto children = ShadowNodeFragment::childrenPlaceholder();
   if (auto it = affected.find(family); it != affected.end()) {
+    auto cloned = node.getChildren();
     for (auto index : it->second) {
-      children[index] = cloneSubtree(*children[index], updates, affected);
+      cloned[index] = cloneSubtree(*cloned[index], updates, affected);
     }
+    children = std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+        std::move(cloned));
   }
 
   Props::Shared newProps = ShadowNodeFragment::propsPlaceholder();
   if (auto it = updates.find(family); it != updates.end()) {
-    PropsParserContext ctx{node.getSurfaceId(), *node.getContextContainer()};
-    newProps = node.getComponentDescriptor().cloneProps(ctx, node.getProps(),
-                                                        RawProps(it->second));
+    const auto& update = it->second;
+    const auto parse = [&] {
+      PropsParserContext ctx{node.getSurfaceId(), *node.getContextContainer()};
+      return node.getComponentDescriptor().cloneProps(ctx, node.getProps(),
+                                                      RawProps(update.props()));
+    };
+    if (auto* warm = update.warm) {
+      if (warm->last != node.getProps() || warm->revision != update.revision) {
+        warm->byState.clear();
+        warm->revision = update.revision;
+      }
+      auto& props = warm->byState[*update.state];
+      if (!props) props = parse();
+      warm->last = props;
+      newProps = props;
+    } else {
+      newProps = parse();
+    }
+    if (auto restyled = restyleParagraph(node, newProps)) {
+      return restyled;
+    }
   }
 
   return node.clone({
       .props = newProps,
-      .children = std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
-          std::move(children)),
-      .state = node.getState(),
+      .children = children,
+      .state = ShadowNodeFragment::statePlaceholder(),
   });
 }
 
 }  // namespace
 
-// merge base + the named state's props for one view into `out`, syncing the
-// family's native props so React re-commits of unchanged children merge our
-// values instead of resurrecting a stale absorbed node (phase 0: the JS
-// mirror alone provably does not cover this). returns false on a state miss.
+// merge base + the named state's props for one view into `out`. a runtime
+// view also syncs its family's native props so React re-commits of unchanged
+// children merge our values instead of resurrecting a stale absorbed node.
+// returns false on a state miss.
 bool HybridTamaguiRegistry::buildViewUpdate(LinkedView& view,
                                             const std::string& stateName,
                                             LeafUpdates& out) {
-  folly::dynamic props =
-      view.baseProps.isObject() ? view.baseProps : folly::dynamic::object();
-
-  if (view.stateProps.isObject()) {
-    auto it = view.stateProps.find(stateName);
-    if (it == view.stateProps.items().end()) {
+  LeafUpdate update;
+  if (view.table) {
+    // a table view commits only its state keys, React rendered the rest
+    auto it = view.table->states.find(stateName);
+    if (it == view.table->states.items().end()) {
       missCount_ += 1;
       return false;
     }
-    if (props.empty()) {
-      props = it->second;
-    } else {
-      props.update(it->second);
+    update.shared = &it->second;
+    update.warm = &view.warm;
+    update.state = &it->first.getString();
+    update.revision = view.table->revision;
+  } else {
+    auto& props = update.owned;
+    props = view.baseProps.isObject() ? view.baseProps : folly::dynamic::object();
+    if (view.stateProps.isObject()) {
+      auto it = view.stateProps.find(stateName);
+      if (it == view.stateProps.items().end()) {
+        missCount_ += 1;
+        return false;
+      }
+      if (props.empty()) {
+        props = it->second;
+      } else {
+        props.update(it->second);
+      }
+    } else if (props.empty()) {
+      return false;
     }
-  } else if (props.empty()) {
-    return false;
   }
+  const auto& props = update.props();
 
   const auto& family = view.node->getFamily();
+  // the retained node keeps its family alive; unmounted views resolve to
+  // no ancestors during the transaction and are skipped safely
+  if (view.table) {
+    // React renders a table view with its scope's current state and the
+    // engine's clones take over React's handles, so nothing goes stale. a
+    // sticky copy would make RN re-parse the view's props on every clone
+    out[&family] = std::move(update);
+    return true;
+  }
+  std::lock_guard<std::mutex> lock(family.nativePropsMutex);
   if (family.nativeProps_DEPRECATED) {
     family.nativeProps_DEPRECATED->update(props);
   } else {
@@ -205,9 +409,7 @@ bool HybridTamaguiRegistry::buildViewUpdate(LinkedView& view,
     if (item.second.isNull()) sticky.erase(item.first.asString());
   }
 
-  // the retained node keeps its family alive; unmounted views resolve to
-  // no ancestors during the transaction and are skipped safely
-  out[&family] = std::move(props);
+  out[&family] = std::move(update);
   return true;
 }
 
@@ -218,6 +420,12 @@ void HybridTamaguiRegistry::commitUpdates(jsi::Runtime& rt,
   auto binding = UIManagerBinding::getBinding(rt);
   if (!binding) return;
 
+  // the clones this commit makes take over React's handles to the nodes they
+  // replace (RN's per-thread switch for updateRuntimeShadowNodeReferences), so
+  // React's next commit builds on them instead of its own stale nodes
+  const bool updatedReferences =
+      ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread();
+  ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(true);
   binding->getUIManager().getShadowTreeRegistry().enumerate(
       [this, &updates](const ShadowTree& tree, bool& /*stop*/) {
         auto status = tree.commit(
@@ -233,6 +441,7 @@ void HybridTamaguiRegistry::commitUpdates(jsi::Runtime& rt,
           commitCount_ += 1;
         }
       });
+  ShadowNode::setUseRuntimeShadowNodeReferenceUpdateOnThread(updatedReferences);
 }
 
 void HybridTamaguiRegistry::applyUpdates(jsi::Runtime& rt,
@@ -246,9 +455,9 @@ void HybridTamaguiRegistry::applyUpdates(jsi::Runtime& rt,
     // broadcasts must not fight their controller
     if (!view.activeState.empty()) continue;
 
-    const auto* name =
-        view.stateProps.isObject() ? activeStateName(view.scopeId) : nullptr;
-    if (view.stateProps.isObject() && !name) continue;
+    const bool hasStates = view.table || view.stateProps.isObject();
+    const auto* name = hasStates ? activeStateName(view.scopeId) : nullptr;
+    if (hasStates && !name) continue;
 
     buildViewUpdate(view, name ? *name : "", updates);
   }
@@ -286,6 +495,11 @@ jsi::Value HybridTamaguiRegistry::applyViewStates(jsi::Runtime& rt,
 
     const std::string stateName = stateIt->second.asString();
     auto props = entry.getDefault("props", nullptr);
+    if (props.isObject() && view.table) {
+      // a runtime controller takes the view over: it owns its tables now
+      view.stateProps = view.table->states;
+      view.table = nullptr;
+    }
     if (props.isObject()) {
       if (!view.stateProps.isObject()) {
         view.stateProps = folly::dynamic::object();
@@ -301,48 +515,28 @@ jsi::Value HybridTamaguiRegistry::applyViewStates(jsi::Runtime& rt,
   return jsi::Value::undefined();
 }
 
-jsi::Value HybridTamaguiRegistry::updateViewStateTables(
-    jsi::Runtime& rt, const jsi::Value&, const jsi::Value* args,
-    size_t count) {
-  if (count < 1 || !args[0].isObject()) {
-    throw jsi::JSError(rt, "updateViewStateTables(entries) requires an array");
+jsi::Value HybridTamaguiRegistry::setTableState(jsi::Runtime& rt,
+                                                const jsi::Value&,
+                                                const jsi::Value* args,
+                                                size_t count) {
+  if (count < 3 || !args[0].isNumber() || !args[1].isString() ||
+      !args[2].isObject()) {
+    throw jsi::JSError(rt, "setTableState(tableId, state, props) requires 3 arguments");
   }
   runtime_ = &rt;
 
-  auto entries = jsi::dynamicFromValue(rt, args[0]);
-  if (!entries.isArray()) {
-    throw jsi::JSError(rt, "updateViewStateTables(entries) requires an array");
-  }
+  auto& table = tables_[args[0].asNumber()];
+  if (!table) table = std::make_shared<Table>();
+  const std::string stateName = args[1].asString(rt).utf8(rt);
+  table->states[stateName] = jsi::dynamicFromValue(rt, args[2]);
+  table->revision += 1;
 
   LeafUpdates updates;
-  updates.reserve(entries.size());
-  for (auto& entry : entries) {
-    if (!entry.isObject()) continue;
-    auto idIt = entry.find("id");
-    auto stateIt = entry.find("state");
-    auto propsIt = entry.find("props");
-    if (idIt == entry.items().end() || stateIt == entry.items().end() ||
-        propsIt == entry.items().end() || !propsIt->second.isObject()) {
-      continue;
-    }
-
-    auto viewIt = views_.find(idIt->second.asDouble());
-    if (viewIt == views_.end()) continue;
-    auto& view = viewIt->second;
-    const std::string stateName = stateIt->second.asString();
-    if (!view.stateProps.isObject()) {
-      view.stateProps = folly::dynamic::object();
-    }
-    view.stateProps[stateName] = propsIt->second;
-
-    const auto* activeName = view.activeState.empty()
-                                 ? activeStateName(view.scopeId)
-                                 : &view.activeState;
-    if (activeName && *activeName == stateName) {
-      buildViewUpdate(view, stateName, updates);
-    }
+  for (auto& [id, view] : views_) {
+    if (view.table != table) continue;
+    const auto* name = viewStateName(view);
+    if (name && *name == stateName) buildViewUpdate(view, stateName, updates);
   }
-
   commitUpdates(rt, updates);
   return jsi::Value::undefined();
 }
@@ -358,8 +552,17 @@ jsi::Value HybridTamaguiRegistry::getViewState(jsi::Runtime& rt,
 
   folly::dynamic out = folly::dynamic::object("scopeId", view.scopeId)(
       "activeState", view.activeState)("base", view.baseProps)(
-      "states", view.stateProps);
+      "states", view.table ? view.table->states : view.stateProps);
+  if (view.table) {
+    const auto* name = viewStateName(view);
+    auto state = name ? view.table->states.find(*name) : view.table->states.items().end();
+    out["nativeProps"] = state != view.table->states.items().end()
+                             ? state->second
+                             : folly::dynamic(nullptr);
+    return jsi::valueFromDynamic(rt, out);
+  }
   const auto& family = view.node->getFamily();
+  std::lock_guard<std::mutex> lock(family.nativePropsMutex);
   out["nativeProps"] = family.nativeProps_DEPRECATED
                            ? *family.nativeProps_DEPRECATED
                            : folly::dynamic(nullptr);

package/cpp/HybridTamaguiRegistry.hpp

@@ -6,6 +6,9 @@
 #include <jsi/jsi.h>
 #include <react/renderer/core/ShadowNode.h>
 
+#include <cstdint>
+#include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 
@@ -38,9 +41,30 @@ namespace jsi = facebook::jsi;
  */
 class HybridTamaguiRegistry : public HybridTamaguiRegistrySpec {
  public:
+  // one view's props for a commit. table views point at their table's
+  // state entry, shared by every view of the table, so the commit can parse
+  // each distinct (props, update) pair once; per-view slots own theirs
+  // the props a table view committed per state. while the node still carries
+  // the props this engine committed last, a switch back to a state reuses
+  // that state's props instead of parsing them again; a React render or a
+  // table refill invalidates them
+  struct WarmProps {
+    facebook::react::Props::Shared last;
+    uint64_t revision = 0;
+    std::unordered_map<std::string, facebook::react::Props::Shared> byState;
+  };
+
+  struct LeafUpdate {
+    const folly::dynamic* shared = nullptr;
+    folly::dynamic owned;
+    // table views only
+    WarmProps* warm = nullptr;
+    const std::string* state = nullptr;
+    uint64_t revision = 0;
+    const folly::dynamic& props() const { return shared ? *shared : owned; }
+  };
   using LeafUpdates =
-      std::unordered_map<const facebook::react::ShadowNodeFamily*,
-                         folly::dynamic>;
+      std::unordered_map<const facebook::react::ShadowNodeFamily*, LeafUpdate>;
 
   HybridTamaguiRegistry() : HybridObject(TAG) {}
 
@@ -56,6 +80,14 @@ class HybridTamaguiRegistry : public HybridTamaguiRegistrySpec {
   double getMissCount() override;
 
  private:
+  // one state table shared by every view a compiler mapping links: state
+  // name -> props. filled once per mapping and state, never per view
+  struct Table {
+    folly::dynamic states = folly::dynamic::object();
+    // bumped on every refill so views drop props parsed from older states
+    uint64_t revision = 0;
+  };
+
   struct LinkedView {
     // retained so the family stays valid for in-transaction ancestor lookup;
     // unmounted views resolve to no ancestors and are skipped
@@ -63,13 +95,19 @@ class HybridTamaguiRegistry : public HybridTamaguiRegistrySpec {
     std::string scopeId;
     folly::dynamic baseProps;   // object, or nullptr when absent
     folly::dynamic stateProps;  // stateName -> props object, or nullptr
+    // shared table (compiler mappings); when set it replaces base/stateProps
+    // and a commit carries only the state's keys, React already rendered the rest
+    std::shared_ptr<Table> table;
     // per-view active state (runtime mode). empty = follow scope state.
     // runtime integrations resolve state names per view (nested themes);
     // scope broadcast stays for compiler-emitted tables.
     std::string activeState;
+    WarmProps warm;
   };
 
-  // raw JSI: link(shadowNode, slots, scopeId) -> id
+  // raw JSI: link(shadowNode, slots | tableId, scopeId, commitNow?) -> id
+  // commitNow commits the view's active state once (its render raced a
+  // scope change)
   jsi::Value link(jsi::Runtime& rt, const jsi::Value& thisValue,
                   const jsi::Value* args, size_t count);
 
@@ -77,15 +115,16 @@ class HybridTamaguiRegistry : public HybridTamaguiRegistrySpec {
   // batched per-view state selection: for each entry, `props` (when given)
   // replaces the view's state table entry under `state`, the view's active
   // state becomes `state`, and all changed views commit in ONE transaction.
+  jsi::Value linkTables(jsi::Runtime& rt, const jsi::Value& thisValue,
+                        const jsi::Value* args, size_t count);
+
   jsi::Value applyViewStates(jsi::Runtime& rt, const jsi::Value& thisValue,
                              const jsi::Value* args, size_t count);
 
-  // raw JSI: updateViewStateTables([{id, state, props}]) -> void
-  // compiler mappings resolve a state once in JS, then fill every matching
-  // linked view without moving it off scope-broadcast control.
-  jsi::Value updateViewStateTables(jsi::Runtime& rt,
-                                   const jsi::Value& thisValue,
-                                   const jsi::Value* args, size_t count);
+  // raw JSI: setTableState(tableId, state, props) -> void
+  // fills one state of a shared table; linked views showing that state commit
+  jsi::Value setTableState(jsi::Runtime& rt, const jsi::Value& thisValue,
+                           const jsi::Value* args, size_t count);
 
   // raw JSI: getViewState(id) -> {scopeId, activeState, base, states} | null
   // debug/test introspection of a linked view's tables; not a hot path
@@ -106,7 +145,11 @@ class HybridTamaguiRegistry : public HybridTamaguiRegistrySpec {
   // commit current props for all views (scopeFilter == nullptr) or one scope
   void applyUpdates(jsi::Runtime& rt, const std::string* scopeFilter);
 
+  // the state a view shows right now: its own runtime state, else its scope's
+  const std::string* viewStateName(const LinkedView& view) const;
+
   std::unordered_map<double, LinkedView> views_;
+  std::unordered_map<double, std::shared_ptr<Table>> tables_;
   std::unordered_map<std::string, std::string> scopeStates_;  // "" = root
   double nextId_ = 1;
   double commitCount_ = 0;

package/dist/cjs/index.cjs

@@ -27,11 +27,13 @@ __export(index_exports, {
 	getViewState: () => getViewState,
 	isAvailable: () => isAvailable,
 	link: () => link,
+	linkTables: () => linkTables,
 	processStyleColors: () => processStyleColors,
 	removeScope: () => removeScope,
 	resolveSlots: () => resolveSlots,
 	setStateName: () => setStateName,
-	updateViewStateTables: () => updateViewStateTables
+	setTableState: () => setTableState,
+	unlink: () => unlink
 });
 module.exports = __toCommonJS(index_exports);
 var import_mirror = require("./mirror.cjs");
@@ -39,11 +41,15 @@ var import_mirror2 = require("./mirror.cjs");
 function isAvailable() {
 	return false;
 }
-function link(_ref, _slots, _scopeId) {
+function link(_ref, _table, _scopeId, _commitNow) {
 	return null;
 }
+function linkTables(_refs, _tableIds, _scopeIndexes, _scopes) {
+	return 0;
+}
+function unlink(_id) {}
 function applyViewStates(_entries) {}
-function updateViewStateTables(_entries) {}
+function setTableState(_tableId, _state, _props) {}
 function getViewState(_id) {
 	return null;
 }