[sammoore]

Supersedes #434, carrying its commit (by @YevheniiKotyrlo) and replacing its exact string key with a numeric hash.

Problem

The resolved-style cache is keyed by generateStateHash, built from the identities of an element's config and matched rules, so elements share an entry exactly when those are the same objects. Two defects on main break that:

1. The config is created per instance. useCssElement derives a config from a module-level mapping on every mount, so identical elements never share a key: 50 identical elements hold 50 cache entries, each with its own sorted rule array and observable.
2. The hash collides. It folds the key ids with XOR and a product and prints the result in base 36. Small sequential ids collide structurally, about 1 in 3 for a config plus one rule. family returns whatever entry it holds for a key, so on a collision an element renders another element's styles (seen in practice: a vertical-align: top element rendered object-fit: contain).

Fixing 1 makes 2 worse: once identical elements share one config, they all land on the same key, so one collision mis-styles every one of them instead of a single element.

Solution

• The config is derived once per mapping through weakFamily. A mapping that is not an object is refused by name, rather than failing inside the WeakMap with a message that names neither styled() nor the argument.
• The key becomes a 53-bit integer: each id goes through Murmur3's 32-bit finalizer into two values, each summed across the set. Summing is order-independent, so there is no sort, and no string is built per lookup.
  • fix(native): one resolved-style cache key per distinct input set #434 originally used an exact key (ids sorted and joined into a string). This hash is not exact, but at 53 well-mixed bits a collision is negligible: about n² / 2^54 for n live entries (≈ 6e-11 at 1,000). Over ~5M test sets it had 0 collisions, against ~26k for the current hash.
  • Cost on Hermes is on par with the exact join for 1–8 rules (3.31 µs vs 3.21 µs per lookup) and about 2× faster at 45 rules (44.6 µs vs 85.7 µs), since a joined string grows with rule count and id size.
• family gains size(), so the one-entry-per-input-set invariant is assertable.

Tests

• config-identity.test.ts: one mapping gives one config, differing mappings keep different keys, a mapping that is not an object is refused by name, and a mutated or per-call mapping behaves correctly.
• state-hash.test.ts: distinct key sets never share a hash, order does not matter, a key outside WeakKey is refused, the hash is a safe integer, ~180k realistic key sets (a config plus every pair from 600 keys, and 46-key sets) never collide, and the config is always part of the key.
• style-cache.test.tsx: identical elements share one entry, differing elements keep distinct entries, and elements sharing an entry and its config each see the value nativeStyleMapping took.
• style-cache-collisions.test.tsx: a 40×40 grid of distinct class combinations, all mounted at once, each rendering its own styles.

Checked by breaking rules.ts on purpose: swapping the current hash back in fails state-hash and the grid test; hashing only the first rule fails only the grid test; truncating the hash to 32 bits fails state-hash.

Verification

On macOS with Node 24: yarn lint, yarn typecheck and yarn test (86 suites, 1356 tests) pass.

Merge order

#436 builds on #434's commit, which this PR carries, and merges cleanly on top, so this lands first.