@tamagui/native-registry 0.0.0-bootstrap.0 → 3.0.0-beta.643.1

package/package.json

@@ -1,15 +1,78 @@
 {
   "name": "@tamagui/native-registry",
-  "version": "0.0.0-bootstrap.0",
-  "description": "Tamagui v3 package bootstrap",
+  "version": "3.0.0-beta.643.1",
+  "description": "Generic native style registry: zero-re-render style updates via Fabric ShadowTree commits",
+  "type": "module",
+  "sideEffects": false,
+  "types": "./types/index.d.ts",
+  "main": "dist/cjs",
+  "module": "dist/esm",
+  "react-native": "src/index.native.ts",
+  "files": [
+    "src",
+    "!src/__tests__",
+    "types",
+    "dist",
+    "nitrogen",
+    "android",
+    "cpp",
+    "nitro.json",
+    "TamaguiRegistry.podspec"
+  ],
+  "scripts": {
+    "build": "tamagui-build",
+    "watch": "tamagui-build --watch",
+    "clean": "tamagui-build clean",
+    "clean:build": "tamagui-build clean:build",
+    "codegen": "nitrogen",
+    "test": "vitest run"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "react-native": {
+        "types": "./types/index.d.ts",
+        "module": "./dist/esm/index.native.js",
+        "import": "./dist/esm/index.native.js",
+        "require": "./dist/cjs/index.native.js"
+      },
+      "types": "./types/index.d.ts",
+      "browser": "./dist/esm/index.mjs",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.cjs",
+      "default": "./dist/esm/index.mjs"
+    }
+  },
+  "devDependencies": {
+    "@tamagui/build": "3.0.0-beta.643.1",
+    "react": ">=19",
+    "react-native": "0.86.2",
+    "react-native-nitro-modules": "^0.36.5",
+    "typescript": "~6.0.3",
+    "vitest": "4.0.4",
+    "nitrogen": "^0.36.5"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": ">=0.81.0",
+    "react-native-nitro-modules": ">=0.36.0",
+    "react-native-web": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native-nitro-modules": {
+      "optional": true
+    },
+    "react-native-web": {
+      "optional": true
+    }
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tamagui/tamagui.git"
+    "url": "git+https://github.com/tamagui/tamagui.git",
+    "directory": "code/core/native-registry"
   },
   "license": "MIT",
-  "files": [
-    "README.md"
-  ],
   "publishConfig": {
     "access": "public"
   }

package/src/index.native.ts

@@ -0,0 +1,174 @@
+/**
+ * Native implementation backed by the TamaguiRegistry Nitro HybridObject.
+ * The C++ engine commits style updates directly to Fabric's ShadowTree via
+ * UIManager::updateShadowTree (RN >= 0.81), with zero React re-renders.
+ */
+import { NitroModules } from 'react-native-nitro-modules'
+import type { TamaguiRegistry } from './specs/TamaguiRegistry.nitro'
+import type {
+  LinkHandle,
+  RegistryStats,
+  Unlink,
+  ViewSlots,
+  ViewStateSnapshot,
+  ViewStateTableUpdate,
+  ViewStateUpdate,
+} from './types'
+import {
+  ROOT_SCOPE,
+  getMirroredStateName,
+  removeMirroredScope,
+  setMirroredStateName,
+} from './mirror'
+import { processStyleColors } from './processStyleColors'
+
+export type {
+  LinkHandle,
+  RegistryStats,
+  Unlink,
+  ViewSlots,
+  ViewStateSnapshot,
+  ViewStateTableUpdate,
+  ViewStateUpdate,
+} from './types'
+export { ROOT_SCOPE, getMirroredStateName } from './mirror'
+export { processStyleColors } from './processStyleColors'
+
+/** Full engine surface: typed Nitro methods plus the raw-JSI methods. */
+interface Engine extends TamaguiRegistry {
+  link(shadowNode: unknown, slots: object, scopeId: string): number
+  applyViewStates(entries: ViewStateUpdate[]): void
+  updateViewStateTables(entries: ViewStateTableUpdate[]): void
+  getViewState(id: number): ViewStateSnapshot | null
+}
+
+let engine: Engine | null = null
+let initError: unknown = null
+try {
+  engine = NitroModules.createHybridObject<TamaguiRegistry>('TamaguiRegistry') as Engine
+} catch (error) {
+  initError = error
+}
+
+export function isAvailable(): boolean {
+  return engine !== null
+}
+
+function getEngine(): Engine {
+  if (engine) return engine
+  const detail = initError instanceof Error ? ` ${initError.message}` : ''
+  throw new Error(
+    `[@tamagui/native-registry] TamaguiRegistry failed to initialize; is react-native-nitro-modules installed and the app rebuilt?${detail}`
+  )
+}
+
+/**
+ * Extract the opaque ShadowNode JSI wrapper from a Fabric host component ref.
+ * Same internals access as Unistyles; verified against RN 0.86.
+ */
+function getShadowNode(ref: unknown): unknown | null {
+  const handle = (ref as Record<string, unknown>)?.__internalInstanceHandle as
+    | { stateNode?: { node?: unknown } }
+    | undefined
+  return handle?.stateNode?.node ?? null
+}
+
+/**
+ * Link a mounted view to the engine. Captures the ShadowNode once, returns
+ * a handle keyed by the engine-issued id: unlink never re-derives anything
+ * from the ref, so a torn-down ref cannot leave a stale entry behind.
+ */
+export function link(
+  ref: unknown,
+  slots: ViewSlots,
+  scopeId: string = ROOT_SCOPE
+): LinkHandle | null {
+  const node = getShadowNode(ref)
+  if (!node) return null
+
+  const e = getEngine()
+  const prepared: Record<string, unknown> = {}
+  if (slots.base) prepared.base = processStyleColors(slots.base)
+  if (slots.state) {
+    const state: Record<string, unknown> = {}
+    for (const name in slots.state) {
+      state[name] = processStyleColors(slots.state[name])
+    }
+    prepared.state = state
+  }
+
+  const id = e.link(node, prepared, scopeId)
+  let unlinked = false
+  return {
+    id,
+    unlink: () => {
+      if (unlinked) return
+      unlinked = true
+      e.unlink(id)
+    },
+  }
+}
+
+/**
+ * Batched per-view state selection: cold entries carry `props` (computed by
+ * the caller, colors already processed via processStyleColors), warm entries
+ * just name the state. One native commit for the whole batch.
+ */
+export function applyViewStates(entries: ViewStateUpdate[]): void {
+  if (entries.length === 0) return
+  getEngine().applyViewStates(entries)
+}
+
+/**
+ * Fill lazily resolved state-table entries without switching a view to the
+ * per-view runtime controller. The native engine commits an entry immediately
+ * only when that state is already active for the view's scope.
+ */
+export function updateViewStateTables(entries: ViewStateTableUpdate[]): void {
+  if (entries.length === 0) return
+  getEngine().updateViewStateTables(
+    entries.map((entry) => ({ ...entry, props: processStyleColors(entry.props) }))
+  )
+}
+
+/**
+ * Set the active state name (e.g. theme name) for a scope and commit the
+ * update natively. The JS mirror updates first so any concurrent React
+ * render paints the same styles the engine commits.
+ */
+export function setStateName(stateName: string, scopeId: string = ROOT_SCOPE): void {
+  setMirroredStateName(scopeId, stateName)
+  getEngine().setStateName(scopeId, stateName)
+}
+
+export function removeScope(scopeId: string): void {
+  removeMirroredScope(scopeId)
+  getEngine().removeScope(scopeId)
+}
+
+/** Resolve the props a view should render right now, mirror-consistent. */
+export function resolveSlots(
+  slots: ViewSlots,
+  scopeId: string = ROOT_SCOPE
+): Record<string, unknown> {
+  const name = getMirroredStateName(scopeId)
+  return {
+    ...slots.base,
+    ...(name ? slots.state?.[name] : undefined),
+  }
+}
+
+/** Debug/test introspection of a linked view's engine tables. Not a hot path. */
+export function getViewState(id: number): ViewStateSnapshot | null {
+  if (!engine) return null
+  return engine.getViewState(id)
+}
+
+export function getStats(): RegistryStats {
+  if (!engine) return { viewCount: 0, commitCount: 0, missCount: 0 }
+  return {
+    viewCount: engine.getViewCount(),
+    commitCount: engine.getCommitCount(),
+    missCount: engine.getMissCount(),
+  }
+}

package/src/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Web/no-native fallback. The registry is a native-only optimization; on web
+ * (or when the native module is absent) the mirror still tracks scope state
+ * so shared code can resolve slots, but nothing links and nothing commits.
+ */
+import type {
+  LinkHandle,
+  RegistryStats,
+  ViewSlots,
+  ViewStateSnapshot,
+  ViewStateTableUpdate,
+  ViewStateUpdate,
+} from './types'
+import {
+  ROOT_SCOPE,
+  getMirroredStateName,
+  removeMirroredScope,
+  setMirroredStateName,
+} from './mirror'
+
+export type {
+  LinkHandle,
+  RegistryStats,
+  Unlink,
+  ViewSlots,
+  ViewStateSnapshot,
+  ViewStateTableUpdate,
+  ViewStateUpdate,
+} from './types'
+export { ROOT_SCOPE, getMirroredStateName } from './mirror'
+
+export function isAvailable(): boolean {
+  return false
+}
+
+export function link(
+  _ref: unknown,
+  _slots: ViewSlots,
+  _scopeId?: string
+): LinkHandle | null {
+  return null
+}
+
+export function applyViewStates(_entries: ViewStateUpdate[]): void {}
+
+export function updateViewStateTables(_entries: ViewStateTableUpdate[]): void {}
+
+export function getViewState(_id: number): ViewStateSnapshot | null {
+  return null
+}
+
+export function setStateName(stateName: string, scopeId: string = ROOT_SCOPE): void {
+  setMirroredStateName(scopeId, stateName)
+}
+
+export function removeScope(scopeId: string): void {
+  removeMirroredScope(scopeId)
+}
+
+export function resolveSlots(
+  slots: ViewSlots,
+  scopeId: string = ROOT_SCOPE
+): Record<string, unknown> {
+  const name = getMirroredStateName(scopeId)
+  return {
+    ...slots.base,
+    ...(name ? slots.state?.[name] : undefined),
+  }
+}
+
+export function getStats(): RegistryStats {
+  return { viewCount: 0, commitCount: 0, missCount: 0 }
+}
+
+export function processStyleColors(
+  props: Record<string, unknown>
+): Record<string, unknown> {
+  return props
+}

package/src/mirror.ts

@@ -0,0 +1,31 @@
+/**
+ * JS mirror of the engine's scope state.
+ *
+ * React re-renders of a linked component must never revert a native commit,
+ * so components read their current state name from this mirror at render
+ * time (without subscribing) and always paint styles that match what the
+ * engine last committed. The mirror is updated synchronously before the
+ * native call in setStateName, so render and engine can never disagree.
+ */
+const scopeStates = new Map<string, string>()
+
+export const ROOT_SCOPE = ''
+
+export function getMirroredStateName(scopeId: string = ROOT_SCOPE): string | undefined {
+  return (
+    scopeStates.get(scopeId) ??
+    (scopeId === ROOT_SCOPE ? undefined : scopeStates.get(ROOT_SCOPE))
+  )
+}
+
+export function setMirroredStateName(scopeId: string, stateName: string): void {
+  scopeStates.set(scopeId, stateName)
+}
+
+export function removeMirroredScope(scopeId: string): void {
+  scopeStates.delete(scopeId)
+}
+
+export function resetMirror(): void {
+  scopeStates.clear()
+}

package/src/processStyleColors.ts

@@ -0,0 +1,42 @@
+/**
+ * Fabric's C++ prop parser takes colors as ARGB ints, not CSS strings, so
+ * every color prop must be converted before props reach the engine. The
+ * compiler mappings and runtime-mode pushes both use this exact runtime
+ * processor before props cross into the engine.
+ */
+import { processColor } from 'react-native'
+
+const COLOR_PROPS = new Set([
+  'color',
+  'backgroundColor',
+  'borderColor',
+  'borderTopColor',
+  'borderBottomColor',
+  'borderLeftColor',
+  'borderRightColor',
+  'borderStartColor',
+  'borderEndColor',
+  'borderBlockColor',
+  'borderBlockStartColor',
+  'borderBlockEndColor',
+  'shadowColor',
+  'textShadowColor',
+  'textDecorationColor',
+  'tintColor',
+  'overlayColor',
+])
+
+export function processStyleColors(
+  props: Record<string, unknown>
+): Record<string, unknown> {
+  let out: Record<string, unknown> | null = null
+  for (const key in props) {
+    const value = props[key]
+    if (COLOR_PROPS.has(key) && typeof value === 'string') {
+      out ??= { ...props }
+      const processed = processColor(value)
+      if (processed != null) out[key] = processed
+    }
+  }
+  return out ?? props
+}

package/src/specs/TamaguiRegistry.nitro.ts

@@ -0,0 +1,51 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+
+/**
+ * Typed surface of the native registry.
+ *
+ * The engine is deliberately generic: it knows nothing about Tamagui themes
+ * beyond "a named state per scope selects which slot props apply". Tamagui
+ * semantics (theme names, scope wiring, compiler output) live in JS.
+ *
+ * Two methods are NOT in this spec because they take values Nitro cannot
+ * type: `link(shadowNode, slots, scopeId) -> number` and internal raw-JSI
+ * registration. They are registered as raw hybrid methods in C++ and typed
+ * on the JS side in index.native.ts.
+ *
+ * Threading: every method must be called from the JS thread. The engine is
+ * single-threaded by contract and holds no locks.
+ */
+export interface TamaguiRegistry extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  /**
+   * Set the active state name for a scope ('' = root scope) and commit the
+   * matching slot props for every affected linked view in one ShadowTree
+   * transaction.
+   */
+  setStateName(scopeId: string, stateName: string): void
+
+  /** Read the active state name for a scope ('' = root). */
+  getStateName(scopeId: string): string
+
+  /** Drop a scope entry (cleanup when a scope provider unmounts). */
+  removeScope(scopeId: string): void
+
+  /** Unlink by the id returned from link(). Safe to call twice. */
+  unlink(id: number): void
+
+  /** Number of currently linked views. */
+  getViewCount(): number
+
+  /**
+   * Number of ShadowTree commits performed. Benchmark honesty counter: a
+   * measurement where this does not increase never exercised the fast path.
+   */
+  getCommitCount(): number
+
+  /**
+   * Number of linked views skipped during commits because their slots had no
+   * entry for the active state name. Always 0 when the compiler emitted
+   * exhaustive keys; anything else is an upstream bug, not a runtime
+   * condition to recover from.
+   */
+  getMissCount(): number
+}

package/src/types.ts

@@ -0,0 +1,65 @@
+/**
+ * Slot props for one linked view.
+ *
+ * v1 implements two slot kinds: `base` (state-independent props, applied
+ * under every state) and `state` (props keyed by state name, e.g. theme
+ * name; the scope's active name selects which entry applies). Future kinds
+ * (media, press, group, container) extend this shape; the engine merge
+ * order is fixed: base, then state, then future kinds.
+ *
+ * Keys must be exhaustive for every state name the scope can take. The
+ * engine does exact lookups only: no fallback chains, no name parsing. A
+ * miss increments the engine's miss counter and is a bug in the emitter.
+ */
+export interface ViewSlots {
+  base?: Record<string, unknown>
+  state?: Record<string, Record<string, unknown>>
+}
+
+export interface RegistryStats {
+  viewCount: number
+  commitCount: number
+  missCount: number
+}
+
+/** Returned by link(); call to unlink. Safe to call more than once. */
+export type Unlink = () => void
+
+/**
+ * Handle for a linked view. `id` addresses the view in batched per-view
+ * operations (applyViewStates); `unlink` removes it. null when the ref had
+ * no shadow node (never mounted) or the engine is unavailable (web).
+ */
+export interface LinkHandle {
+  id: number
+  unlink: Unlink
+}
+
+/**
+ * One entry of a batched per-view state update. When `props` is present it
+ * is merged into the view's state table under `state` first (lazy warm-up
+ * for runtime integrations); the view's active state then becomes `state`
+ * and all entries commit natively in one transaction.
+ */
+export interface ViewStateUpdate {
+  id: number
+  state: string
+  props?: Record<string, unknown>
+}
+
+/** add or replace one resolved state-table entry without changing its view's controller */
+export interface ViewStateTableUpdate {
+  id: number
+  state: string
+  props: Record<string, unknown>
+}
+
+/** Debug/test snapshot of a linked view's engine tables (getViewState). */
+export interface ViewStateSnapshot {
+  scopeId: string
+  activeState: string
+  base: Record<string, unknown> | null
+  states: Record<string, Record<string, unknown>> | null
+  /** the family's sticky nativeProps_DEPRECATED merge, null when unset */
+  nativeProps: Record<string, unknown> | null
+}

package/types/index.d.ts

@@ -0,0 +1,20 @@
+/**
+* Web/no-native fallback. The registry is a native-only optimization; on web
+* (or when the native module is absent) the mirror still tracks scope state
+* so shared code can resolve slots, but nothing links and nothing commits.
+*/
+import type { LinkHandle, RegistryStats, ViewSlots, ViewStateSnapshot, ViewStateTableUpdate, ViewStateUpdate } from "./types";
+export type { LinkHandle, RegistryStats, Unlink, ViewSlots, ViewStateSnapshot, ViewStateTableUpdate, ViewStateUpdate } from "./types";
+export { ROOT_SCOPE, getMirroredStateName } from "./mirror";
+export declare function isAvailable(): boolean;
+export declare function link(_ref: unknown, _slots: ViewSlots, _scopeId?: string): LinkHandle | null;
+export declare function applyViewStates(_entries: ViewStateUpdate[]): void;
+export declare function updateViewStateTables(_entries: ViewStateTableUpdate[]): void;
+export declare function getViewState(_id: number): ViewStateSnapshot | null;
+export declare function setStateName(stateName: string, scopeId?: string): void;
+export declare function removeScope(scopeId: string): void;
+export declare function resolveSlots(slots: ViewSlots, scopeId?: string): Record<string, unknown>;
+export declare function getStats(): RegistryStats;
+export declare function processStyleColors(props: Record<string, unknown>): Record<string, unknown>;
+
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": ";;;;;AAKA,cACE,YACA,eACA,WACA,mBACA,sBACA,uBACK;AAQP,cACE,YACA,eACA,QACA,WACA,mBACA,sBACA,uBACK;AACP,SAAS,YAAY,4BAA4B;AAEjD,OAAO,iBAAS;AAIhB,OAAO,iBAAS,KACd,eACA,QAAQ,WACR,oBACC;AAIH,OAAO,iBAAS,gBAAgB,UAAU;AAE1C,OAAO,iBAAS,sBAAsB,UAAU;AAEhD,OAAO,iBAAS,aAAa,cAAc;AAI3C,OAAO,iBAAS,aAAa,mBAAmB;AAIhD,OAAO,iBAAS,YAAY;AAI5B,OAAO,iBAAS,aACd,OAAO,WACP,mBACC;AAQH,OAAO,iBAAS,YAAY;AAI5B,OAAO,iBAAS,mBACd,OAAO,0BACN",
+  "names": [],
+  "sources": [
+    "src/index.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * Web/no-native fallback. The registry is a native-only optimization; on web\n * (or when the native module is absent) the mirror still tracks scope state\n * so shared code can resolve slots, but nothing links and nothing commits.\n */\nimport type {\n  LinkHandle,\n  RegistryStats,\n  ViewSlots,\n  ViewStateSnapshot,\n  ViewStateTableUpdate,\n  ViewStateUpdate,\n} from './types'\nimport {\n  ROOT_SCOPE,\n  getMirroredStateName,\n  removeMirroredScope,\n  setMirroredStateName,\n} from './mirror'\n\nexport type {\n  LinkHandle,\n  RegistryStats,\n  Unlink,\n  ViewSlots,\n  ViewStateSnapshot,\n  ViewStateTableUpdate,\n  ViewStateUpdate,\n} from './types'\nexport { ROOT_SCOPE, getMirroredStateName } from './mirror'\n\nexport function isAvailable(): boolean {\n  return false\n}\n\nexport function link(\n  _ref: unknown,\n  _slots: ViewSlots,\n  _scopeId?: string\n): LinkHandle | null {\n  return null\n}\n\nexport function applyViewStates(_entries: ViewStateUpdate[]): void {}\n\nexport function updateViewStateTables(_entries: ViewStateTableUpdate[]): void {}\n\nexport function getViewState(_id: number): ViewStateSnapshot | null {\n  return null\n}\n\nexport function setStateName(stateName: string, scopeId: string = ROOT_SCOPE): void {\n  setMirroredStateName(scopeId, stateName)\n}\n\nexport function removeScope(scopeId: string): void {\n  removeMirroredScope(scopeId)\n}\n\nexport function resolveSlots(\n  slots: ViewSlots,\n  scopeId: string = ROOT_SCOPE\n): Record<string, unknown> {\n  const name = getMirroredStateName(scopeId)\n  return {\n    ...slots.base,\n    ...(name ? slots.state?.[name] : undefined),\n  }\n}\n\nexport function getStats(): RegistryStats {\n  return { viewCount: 0, commitCount: 0, missCount: 0 }\n}\n\nexport function processStyleColors(\n  props: Record<string, unknown>\n): Record<string, unknown> {\n  return props\n}\n"
+  ]
+}

package/types/index.native.d.ts

@@ -0,0 +1,37 @@
+import type { LinkHandle, RegistryStats, ViewSlots, ViewStateSnapshot, ViewStateTableUpdate, ViewStateUpdate } from "./types";
+export type { LinkHandle, RegistryStats, Unlink, ViewSlots, ViewStateSnapshot, ViewStateTableUpdate, ViewStateUpdate } from "./types";
+export { ROOT_SCOPE, getMirroredStateName } from "./mirror";
+export { processStyleColors } from "./processStyleColors";
+export declare function isAvailable(): boolean;
+/**
+* Link a mounted view to the engine. Captures the ShadowNode once, returns
+* a handle keyed by the engine-issued id: unlink never re-derives anything
+* from the ref, so a torn-down ref cannot leave a stale entry behind.
+*/
+export declare function link(ref: unknown, slots: ViewSlots, scopeId?: string): LinkHandle | null;
+/**
+* Batched per-view state selection: cold entries carry `props` (computed by
+* the caller, colors already processed via processStyleColors), warm entries
+* just name the state. One native commit for the whole batch.
+*/
+export declare function applyViewStates(entries: ViewStateUpdate[]): void;
+/**
+* Fill lazily resolved state-table entries without switching a view to the
+* per-view runtime controller. The native engine commits an entry immediately
+* only when that state is already active for the view's scope.
+*/
+export declare function updateViewStateTables(entries: ViewStateTableUpdate[]): void;
+/**
+* Set the active state name (e.g. theme name) for a scope and commit the
+* update natively. The JS mirror updates first so any concurrent React
+* render paints the same styles the engine commits.
+*/
+export declare function setStateName(stateName: string, scopeId?: string): void;
+export declare function removeScope(scopeId: string): void;
+/** Resolve the props a view should render right now, mirror-consistent. */
+export declare function resolveSlots(slots: ViewSlots, scopeId?: string): Record<string, unknown>;
+/** Debug/test introspection of a linked view's engine tables. Not a hot path. */
+export declare function getViewState(id: number): ViewStateSnapshot | null;
+export declare function getStats(): RegistryStats;
+
+//# sourceMappingURL=index.native.d.ts.map

package/types/index.native.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAOA,cACE,YACA,eAEA,WACA,mBACA,sBACA,uBACK;AASP,cACE,YACA,eACA,QACA,WACA,mBACA,sBACA,uBACK;AACP,SAAS,YAAY,4BAA4B;AACjD,SAAS,0BAA0B;AAkBnC,OAAO,iBAAS;;;;;;AA4BhB,OAAO,iBAAS,KACd,cACA,OAAO,WACP,mBACC;;;;;;AAgCH,OAAO,iBAAS,gBAAgB,SAAS;;;;;;AAUzC,OAAO,iBAAS,sBAAsB,SAAS;;;;;;AAY/C,OAAO,iBAAS,aAAa,mBAAmB;AAKhD,OAAO,iBAAS,YAAY;;AAM5B,OAAO,iBAAS,aACd,OAAO,WACP,mBACC;;AASH,OAAO,iBAAS,aAAa,aAAa;AAK1C,OAAO,iBAAS,YAAY",
+  "names": [],
+  "sources": [
+    "src/index.native.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * Native implementation backed by the TamaguiRegistry Nitro HybridObject.\n * The C++ engine commits style updates directly to Fabric's ShadowTree via\n * UIManager::updateShadowTree (RN >= 0.81), with zero React re-renders.\n */\nimport { NitroModules } from 'react-native-nitro-modules'\nimport type { TamaguiRegistry } from './specs/TamaguiRegistry.nitro'\nimport type {\n  LinkHandle,\n  RegistryStats,\n  Unlink,\n  ViewSlots,\n  ViewStateSnapshot,\n  ViewStateTableUpdate,\n  ViewStateUpdate,\n} from './types'\nimport {\n  ROOT_SCOPE,\n  getMirroredStateName,\n  removeMirroredScope,\n  setMirroredStateName,\n} from './mirror'\nimport { processStyleColors } from './processStyleColors'\n\nexport type {\n  LinkHandle,\n  RegistryStats,\n  Unlink,\n  ViewSlots,\n  ViewStateSnapshot,\n  ViewStateTableUpdate,\n  ViewStateUpdate,\n} from './types'\nexport { ROOT_SCOPE, getMirroredStateName } from './mirror'\nexport { processStyleColors } from './processStyleColors'\n\n/** Full engine surface: typed Nitro methods plus the raw-JSI methods. */\ninterface Engine extends TamaguiRegistry {\n  link(shadowNode: unknown, slots: object, scopeId: string): number\n  applyViewStates(entries: ViewStateUpdate[]): void\n  updateViewStateTables(entries: ViewStateTableUpdate[]): void\n  getViewState(id: number): ViewStateSnapshot | null\n}\n\nlet engine: Engine | null = null\nlet initError: unknown = null\ntry {\n  engine = NitroModules.createHybridObject<TamaguiRegistry>('TamaguiRegistry') as Engine\n} catch (error) {\n  initError = error\n}\n\nexport function isAvailable(): boolean {\n  return engine !== null\n}\n\nfunction getEngine(): Engine {\n  if (engine) return engine\n  const detail = initError instanceof Error ? ` ${initError.message}` : ''\n  throw new Error(\n    `[@tamagui/native-registry] TamaguiRegistry failed to initialize; is react-native-nitro-modules installed and the app rebuilt?${detail}`\n  )\n}\n\n/**\n * Extract the opaque ShadowNode JSI wrapper from a Fabric host component ref.\n * Same internals access as Unistyles; verified against RN 0.86.\n */\nfunction getShadowNode(ref: unknown): unknown | null {\n  const handle = (ref as Record<string, unknown>)?.__internalInstanceHandle as\n    | { stateNode?: { node?: unknown } }\n    | undefined\n  return handle?.stateNode?.node ?? null\n}\n\n/**\n * Link a mounted view to the engine. Captures the ShadowNode once, returns\n * a handle keyed by the engine-issued id: unlink never re-derives anything\n * from the ref, so a torn-down ref cannot leave a stale entry behind.\n */\nexport function link(\n  ref: unknown,\n  slots: ViewSlots,\n  scopeId: string = ROOT_SCOPE\n): LinkHandle | null {\n  const node = getShadowNode(ref)\n  if (!node) return null\n\n  const e = getEngine()\n  const prepared: Record<string, unknown> = {}\n  if (slots.base) prepared.base = processStyleColors(slots.base)\n  if (slots.state) {\n    const state: Record<string, unknown> = {}\n    for (const name in slots.state) {\n      state[name] = processStyleColors(slots.state[name])\n    }\n    prepared.state = state\n  }\n\n  const id = e.link(node, prepared, scopeId)\n  let unlinked = false\n  return {\n    id,\n    unlink: () => {\n      if (unlinked) return\n      unlinked = true\n      e.unlink(id)\n    },\n  }\n}\n\n/**\n * Batched per-view state selection: cold entries carry `props` (computed by\n * the caller, colors already processed via processStyleColors), warm entries\n * just name the state. One native commit for the whole batch.\n */\nexport function applyViewStates(entries: ViewStateUpdate[]): void {\n  if (entries.length === 0) return\n  getEngine().applyViewStates(entries)\n}\n\n/**\n * Fill lazily resolved state-table entries without switching a view to the\n * per-view runtime controller. The native engine commits an entry immediately\n * only when that state is already active for the view's scope.\n */\nexport function updateViewStateTables(entries: ViewStateTableUpdate[]): void {\n  if (entries.length === 0) return\n  getEngine().updateViewStateTables(\n    entries.map((entry) => ({ ...entry, props: processStyleColors(entry.props) }))\n  )\n}\n\n/**\n * Set the active state name (e.g. theme name) for a scope and commit the\n * update natively. The JS mirror updates first so any concurrent React\n * render paints the same styles the engine commits.\n */\nexport function setStateName(stateName: string, scopeId: string = ROOT_SCOPE): void {\n  setMirroredStateName(scopeId, stateName)\n  getEngine().setStateName(scopeId, stateName)\n}\n\nexport function removeScope(scopeId: string): void {\n  removeMirroredScope(scopeId)\n  getEngine().removeScope(scopeId)\n}\n\n/** Resolve the props a view should render right now, mirror-consistent. */\nexport function resolveSlots(\n  slots: ViewSlots,\n  scopeId: string = ROOT_SCOPE\n): Record<string, unknown> {\n  const name = getMirroredStateName(scopeId)\n  return {\n    ...slots.base,\n    ...(name ? slots.state?.[name] : undefined),\n  }\n}\n\n/** Debug/test introspection of a linked view's engine tables. Not a hot path. */\nexport function getViewState(id: number): ViewStateSnapshot | null {\n  if (!engine) return null\n  return engine.getViewState(id)\n}\n\nexport function getStats(): RegistryStats {\n  if (!engine) return { viewCount: 0, commitCount: 0, missCount: 0 }\n  return {\n    viewCount: engine.getViewCount(),\n    commitCount: engine.getCommitCount(),\n    missCount: engine.getMissCount(),\n  }\n}\n"
+  ]
+}

package/types/mirror.d.ts

@@ -0,0 +1,7 @@
+export declare const ROOT_SCOPE = "";
+export declare function getMirroredStateName(scopeId?: string): string | undefined;
+export declare function setMirroredStateName(scopeId: string, stateName: string): void;
+export declare function removeMirroredScope(scopeId: string): void;
+export declare function resetMirror(): void;
+
+//# sourceMappingURL=mirror.d.ts.map

package/types/mirror.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAWA,OAAO,cAAM,aAAa;AAE1B,OAAO,iBAAS,qBAAqB;AAOrC,OAAO,iBAAS,qBAAqB,iBAAiB;AAItD,OAAO,iBAAS,oBAAoB;AAIpC,OAAO,iBAAS",
+  "names": [],
+  "sources": [
+    "src/mirror.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * JS mirror of the engine's scope state.\n *\n * React re-renders of a linked component must never revert a native commit,\n * so components read their current state name from this mirror at render\n * time (without subscribing) and always paint styles that match what the\n * engine last committed. The mirror is updated synchronously before the\n * native call in setStateName, so render and engine can never disagree.\n */\nconst scopeStates = new Map<string, string>()\n\nexport const ROOT_SCOPE = ''\n\nexport function getMirroredStateName(scopeId: string = ROOT_SCOPE): string | undefined {\n  return (\n    scopeStates.get(scopeId) ??\n    (scopeId === ROOT_SCOPE ? undefined : scopeStates.get(ROOT_SCOPE))\n  )\n}\n\nexport function setMirroredStateName(scopeId: string, stateName: string): void {\n  scopeStates.set(scopeId, stateName)\n}\n\nexport function removeMirroredScope(scopeId: string): void {\n  scopeStates.delete(scopeId)\n}\n\nexport function resetMirror(): void {\n  scopeStates.clear()\n}\n"
+  ]
+}

package/types/processStyleColors.d.ts

@@ -0,0 +1,3 @@
+export declare function processStyleColors(props: Record<string, unknown>): Record<string, unknown>;
+
+//# sourceMappingURL=processStyleColors.d.ts.map

package/types/processStyleColors.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AA4BA,OAAO,iBAAS,mBACd,OAAO,0BACN",
+  "names": [],
+  "sources": [
+    "src/processStyleColors.ts"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "/**\n * Fabric's C++ prop parser takes colors as ARGB ints, not CSS strings, so\n * every color prop must be converted before props reach the engine. The\n * compiler mappings and runtime-mode pushes both use this exact runtime\n * processor before props cross into the engine.\n */\nimport { processColor } from 'react-native'\n\nconst COLOR_PROPS = new Set([\n  'color',\n  'backgroundColor',\n  'borderColor',\n  'borderTopColor',\n  'borderBottomColor',\n  'borderLeftColor',\n  'borderRightColor',\n  'borderStartColor',\n  'borderEndColor',\n  'borderBlockColor',\n  'borderBlockStartColor',\n  'borderBlockEndColor',\n  'shadowColor',\n  'textShadowColor',\n  'textDecorationColor',\n  'tintColor',\n  'overlayColor',\n])\n\nexport function processStyleColors(\n  props: Record<string, unknown>\n): Record<string, unknown> {\n  let out: Record<string, unknown> | null = null\n  for (const key in props) {\n    const value = props[key]\n    if (COLOR_PROPS.has(key) && typeof value === 'string') {\n      out ??= { ...props }\n      const processed = processColor(value)\n      if (processed != null) out[key] = processed\n    }\n  }\n  return out ?? props\n}\n"
+  ]
+}