@pyreon/rocketstyle 0.13.1 → 0.15.0

package/src/__tests__/rocketstyle.browser.test.tsx

@@ -167,4 +167,40 @@ describe('@pyreon/rocketstyle in real browser', () => {
     light.unmount()
     dark.unmount()
   })
+
+  it('multiple instances share definition-scoped caches (no per-mount rebuild)', () => {
+    // Verifies the perf optimization: getDimensionsMap, reservedPropNames keys,
+    // and omit Sets are cached at definition time (WeakMap), not rebuilt per mount.
+    // 10 instances of the same component with different state props must all render
+    // correctly — proving the caches handle varied prop combinations.
+    const Box: any = rocketstyle()({ name: 'CacheBox', component: Base })
+      .styles(
+        (css: any) => css`
+          color: ${({ $rocketstyle }: any) => $rocketstyle.color};
+        `,
+      )
+      .theme({ color: 'rgb(100, 100, 100)' })
+      .states({
+        primary: { color: 'rgb(0, 100, 200)' },
+        danger: { color: 'rgb(200, 50, 50)' },
+      })
+
+    const instances = Array.from({ length: 10 }, (_, i) => {
+      const state = i % 3 === 0 ? 'primary' : i % 3 === 1 ? 'danger' : undefined
+      return mountInBrowser(h(Box, { id: `c${i}`, ...(state ? { state } : {}) }))
+    })
+
+    // Check a subset — primary, danger, and default all resolve correctly
+    expect(
+      getComputedStyle(instances[0]!.container.querySelector('#c0')!).color,
+    ).toBe('rgb(0, 100, 200)') // primary
+    expect(
+      getComputedStyle(instances[1]!.container.querySelector('#c1')!).color,
+    ).toBe('rgb(200, 50, 50)') // danger
+    expect(
+      getComputedStyle(instances[2]!.container.querySelector('#c2')!).color,
+    ).toBe('rgb(100, 100, 100)') // default
+
+    for (const inst of instances) inst.unmount()
+  })
 })

package/src/constants/index.ts

@@ -1,3 +1,10 @@
+// `import.meta.env.DEV` is provided by Vite/Rolldown at build time and
+// literal-replaced so prod bundles tree-shake the dev branch to zero bytes.
+// Typed through a narrowing interface so downstream packages don't need
+// `vite/client` in their tsconfigs to type-check this file transitively.
+/** Tree-shakeable dev-mode flag. `true` in dev, `false` (dead code eliminated) in prod. */
+export const __DEV__: boolean = process.env.NODE_ENV !== 'production'
+
 /** Default theme mode used when no mode is provided via context. */
 export const MODE_DEFAULT = 'light'
 

package/src/context/context.ts

@@ -1,5 +1,5 @@
 import type { VNodeChild } from '@pyreon/core'
-import { useContext } from '@pyreon/core'
+import { nativeCompat, useContext } from '@pyreon/core'
 import { Provider as CoreProvider, context } from '@pyreon/ui-core'
 import { MODE_DEFAULT, THEME_MODES_INVERSED } from '../constants'
 
@@ -49,6 +49,10 @@ const Provider = ({ provider = CoreProvider, inversed, ...props }: TProvider): V
   return result ?? null
 }
 
+// Mark as native — reads useContext() and delegates to CoreProvider, both
+// of which need Pyreon's setup frame.
+nativeCompat(Provider)
+
 export { context }
 
 export default Provider

package/src/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal process type — just enough for `process.env.NODE_ENV` checks.
+ * Avoids requiring @types/node in consumers that import pyreon source
+ * via the `"bun"` export condition.
+ */
+declare var process: { env: { NODE_ENV?: string } }

package/src/init.ts

@@ -1,5 +1,5 @@
 import { isEmpty } from '@pyreon/ui-core'
-import { ALL_RESERVED_KEYS } from './constants'
+import { ALL_RESERVED_KEYS, __DEV__ } from './constants'
 import defaultDimensions from './constants/defaultDimensions'
 import rocketComponent from './rocketstyle'
 import type { DefaultDimensions, Dimensions } from './types/dimensions'
@@ -73,7 +73,7 @@ const validateInit = (name: string, component: unknown, dimensions: Dimensions)
 
 const rocketstyle = (({ dimensions = defaultDimensions, useBooleans = false } = {}) =>
   ({ name, component }: { name: string; component: any }) => {
-    if (process.env.NODE_ENV !== 'production') {
+    if (__DEV__) {
       validateInit(name, component, dimensions)
     }
 

package/src/rocketstyle.ts

@@ -1,6 +1,6 @@
 import { compose, config, hoistNonReactStatics, omit, pick, render } from '@pyreon/ui-core'
 import { LocalThemeManager } from './cache'
-import { CONFIG_KEYS, PSEUDO_KEYS, PSEUDO_META_KEYS, STYLING_KEYS } from './constants'
+import { CONFIG_KEYS, PSEUDO_KEYS, PSEUDO_META_KEYS, STYLING_KEYS, __DEV__ } from './constants'
 import createLocalProvider from './context/createLocalProvider'
 import { useLocalContext } from './context/localContext'
 import { rocketstyleAttrsHoc } from './hoc'
@@ -17,6 +17,9 @@ import { createStaticsChainingEnhancers, createStaticsEnhancers } from './utils/
 import { calculateStyles } from './utils/styles'
 import { getDimensionThemes, getTheme, getThemeByMode, getThemeFromChain } from './utils/theme'
 
+// Dev-time counter sink — see packages/internals/perf-harness for contract.
+const _countSink = globalThis as { __pyreon_count__?: (name: string, n?: number) => void }
+
 /**
  * Core rocketstyle component factory. Creates a fully-featured Pyreon component
  * that integrates theme management (with light/dark mode support), multi-tier
@@ -87,6 +90,49 @@ const rocketComponent: RocketComponent = (options) => {
   // --------------------------------------------------------
   const ThemeManager = new LocalThemeManager()
 
+  // ── Per-definition caches (shared across all instances) ──────────────
+  // getDimensionsMap + Object.keys(reservedPropNames) are theme-independent
+  // (dimension structure comes from .sizes()/.states()/.variants() chain,
+  // not from runtime theme values). Cache them so 50 instances of the same
+  // component definition skip the rebuild entirely.
+  const _dimensionsCache = new WeakMap<
+    object,
+    { keysMap: Record<string, unknown>; keywords: Record<string, true | undefined> }
+  >()
+  const _reservedKeysCache = new WeakMap<object, string[]>()
+
+  // Pre-compute merged key arrays once per definition (not per mount)
+  const ALL_PSEUDO_KEYS = [...PSEUDO_KEYS, ...PSEUDO_META_KEYS]
+  // Static portion of omit keys — PSEUDO_KEYS + filterAttrs + 'pseudo' are definition-scoped.
+  // RESERVED_STYLING_PROPS_KEYS is dimension-dependent but also cached per definition.
+  // 'pseudo' is included here so we can skip the destructuring spread of mergeProps.
+  const STATIC_OMIT_KEYS = ['pseudo', ...PSEUDO_KEYS, ...(options.filterAttrs ?? [])]
+  // Pre-built Set for omit() — avoids per-call Set allocation. Built once the
+  // dimension-dependent reserved keys are known (first mount), then reused.
+  const _omitSetCache = new WeakMap<string[], Set<string>>()
+
+  // ── Dimension-prop memo (per-definition) ─────────────────────────────
+  // Keyed on theme identity → Map<keyString, { rocketstyle, rocketstate }>.
+  // The accessors below build a key from (mode, dimension prop tuple,
+  // pseudo state tuple) and look up here. On hit they return the SAME
+  // object identities for both `$rocketstyle` and `$rocketstate`, which
+  // lets the styler's existing `classCache` (keyed on those identities)
+  // skip the entire CSS resolve pipeline. On miss they compute fresh
+  // and store the result.
+  //
+  // Why this matters: B-FINDING.md (PR #342) showed every Button mount
+  // fires 22 styler.resolve calls even when the styler-sheet cache hits
+  // — the cache catches at the LAST step (insert dedup), but the resolve
+  // pipeline still runs to compute the hash. Stable accessor identities
+  // mean the styler's classCache hits earlier and the resolves don't run.
+  //
+  // LRU bound prevents unbounded growth from prop-tuple churn (e.g. a
+  // table where every cell has a unique state). 32 entries per theme
+  // covers ~99% of unique combos in real apps.
+  type RsMemoEntry = { readonly rocketstyle: object; readonly rocketstate: object }
+  const _rsMemo = new WeakMap<object, Map<string, RsMemoEntry>>()
+  const RS_MEMO_CAP = 32
+
   // --------------------------------------------------------
   // COMPOSE - high-order components
   // --------------------------------------------------------
@@ -140,131 +186,218 @@ const rocketComponent: RocketComponent = (options) => {
       return helper.get(initialTheme)
     })()
 
-    const { keysMap: dimensions, keywords: reservedPropNames } = getDimensionsMap({
-      themes: initialDimensionThemes,
-      useBooleans: options.useBooleans,
-    })
+    // Cache getDimensionsMap per dimension-themes identity — all instances
+    // of the same component definition share the same dimension structure.
+    let dimResult = _dimensionsCache.get(initialDimensionThemes as object)
+    if (dimResult) {
+      if (process.env.NODE_ENV !== 'production')
+        _countSink.__pyreon_count__?.('rocketstyle.dimensionsMap.hit')
+    } else {
+      dimResult = getDimensionsMap({
+        themes: initialDimensionThemes,
+        useBooleans: options.useBooleans,
+      })
+      _dimensionsCache.set(initialDimensionThemes as object, dimResult)
+    }
+    const { keysMap: dimensions, keywords: reservedPropNames } = dimResult
 
-    const RESERVED_STYLING_PROPS_KEYS = Object.keys(reservedPropNames)
+    // Cache Object.keys() result — same dimension structure = same keys
+    let RESERVED_STYLING_PROPS_KEYS = _reservedKeysCache.get(reservedPropNames as object)
+    if (!RESERVED_STYLING_PROPS_KEYS) {
+      RESERVED_STYLING_PROPS_KEYS = Object.keys(reservedPropNames)
+      _reservedKeysCache.set(reservedPropNames as object, RESERVED_STYLING_PROPS_KEYS)
+    }
+
+    // Silence "unused" warnings for initialBaseTheme / initialDimensionThemes —
+    // they're eagerly populated into ThemeManager caches so the first accessor
+    // call hits cache, but not referenced directly.
+    void initialBaseTheme
+    void initialDimensionThemes
+
+    // Capture pseudo from localCtx once at setup — pseudo properties are
+    // getters (from createLocalProvider) that read signals lazily.
+    // Passing them through preserves reactivity without subscribing here.
+    const localPseudo = localCtx?.pseudo
 
     // --------------------------------------------------
-    // $rocketstyle as a FUNCTION ACCESSOR — fully reactive.
-    // Re-evaluates when THEME, MODE, or dimension props change.
-    // Props are resolved fresh each call so reactive prop accessors
-    // (signals, getters) produce updated dimension values.
+    // Shared accessor resolver.
+    //
+    // Both `$rocketstyleAccessor` and `$rocketstateAccessor` derive from the
+    // same input set (theme, mode, dimension props, pseudo state). Folding
+    // them into one resolver lets the dimension-prop memo return the SAME
+    // object identities for both — which is what the styler's `classCache`
+    // (keyed on `(rocketstyle, rocketstate)` identity) needs to skip the
+    // resolve pipeline on cache hit.
+    //
+    // Reactive contract: this runs inside the styler's `computed()` (one per
+    // mounted instance). All signal reads — theme, mode, dimension props,
+    // pseudo getters from localCtx — are TRACKED, so any change re-runs the
+    // computed which re-resolves the entry. Same key → cached entry; new key
+    // → fresh computation, stored under LRU cap.
     // --------------------------------------------------
-    const $rocketstyleAccessor = () => {
-      // Read theme + mode LAZILY via the getter-backed themeAttrs object.
-      // Both reads are tracked when this accessor runs inside a reactive
-      // scope (styler's effect), so theme swap / mode toggle re-runs the
-      // surrounding resolver and swaps the generated class.
-      const theme = themeAttrs.theme // reactive: tracks theme signal
-      const mode = themeAttrs.mode // reactive: tracks mode signal
+    const _resolveRsEntry = (): RsMemoEntry => {
+      // Read reactive inputs (tracks theme + mode signals)
+      const theme = themeAttrs.theme
+      const mode = themeAttrs.mode
+
+      // Build key: mode | dimensionProps | pseudoState. Reading dimension
+      // props + pseudo signals here tracks them in the surrounding computed
+      // so any change re-runs us with a different key.
+      let key = mode as string
+      const propsRec = props as Record<string, unknown>
+      for (const dimName in dimensions) {
+        const v = propsRec[dimName]
+        // String/number/boolean serialize directly. Anything else (including
+        // undefined / objects) gets a typeof tag so we don't collide.
+        key +=
+          '|' +
+          (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean'
+            ? String(v)
+            : v === undefined
+              ? ''
+              : '~' + typeof v)
+      }
+      for (const k of ALL_PSEUDO_KEYS) {
+        const propV = propsRec[k]
+        const localV = localPseudo?.[k as keyof typeof localPseudo]
+        const v = propV !== undefined ? propV : localV
+        key += '|' + (v === undefined ? '' : v ? '1' : '0')
+      }
+
+      // Cache lookup
+      let themeMemo = _rsMemo.get(theme as object)
+      if (!themeMemo) {
+        themeMemo = new Map()
+        _rsMemo.set(theme as object, themeMemo)
+      }
+
+      const cached = themeMemo.get(key)
+      if (cached) {
+        if (process.env.NODE_ENV !== 'production')
+          _countSink.__pyreon_count__?.('rocketstyle.dimensionMemo.hit')
+        // LRU touch: move to end so eviction targets oldest unused entry
+        themeMemo.delete(key)
+        themeMemo.set(key, cached)
+        return cached
+      }
+
+      // Miss: compute fresh. Counter measures actual theme resolutions
+      // (not accessor invocations) — see COUNTERS.md.
+      if (process.env.NODE_ENV !== 'production')
+        _countSink.__pyreon_count__?.('rocketstyle.getTheme')
 
       // Resolve base + dimension themes for the CURRENT theme. WeakMap
       // keyed on theme identity — stable-theme renders hit cache in O(1),
       // theme swaps fall through to recompute (once per new theme).
       const baseThemeHelper = ThemeManager.baseTheme
-      if (!baseThemeHelper.has(theme)) {
+      if (baseThemeHelper.has(theme)) {
+        if (process.env.NODE_ENV !== 'production')
+          _countSink.__pyreon_count__?.('rocketstyle.localThemeManager.hit')
+      } else {
         baseThemeHelper.set(theme, getThemeFromChain(options.theme, theme))
       }
       const baseTheme = baseThemeHelper.get(theme)
 
       const dimHelper = ThemeManager.dimensionsThemes
-      if (!dimHelper.has(theme)) {
+      if (dimHelper.has(theme)) {
+        if (process.env.NODE_ENV !== 'production')
+          _countSink.__pyreon_count__?.('rocketstyle.localThemeManager.hit')
+      } else {
         dimHelper.set(theme, getDimensionThemes(theme, options))
       }
       const themes = dimHelper.get(theme)
 
       // Resolve active dimensions from props (not localCtx which has pseudo getters)
-      const rocketstate = _calculateStylingAttrs({
-        props: pickStyledAttrs(props as Record<string, unknown>, reservedPropNames),
+      const rocketstateRaw = _calculateStylingAttrs({
+        props: pickStyledAttrs(propsRec, reservedPropNames),
         dimensions,
       })
 
       // Resolve mode-specific theme
       const modeBaseHelper = ThemeManager.modeBaseTheme[mode]
-      if (!modeBaseHelper.has(baseTheme)) {
+      if (modeBaseHelper.has(baseTheme)) {
+        if (process.env.NODE_ENV !== 'production')
+          _countSink.__pyreon_count__?.('rocketstyle.localThemeManager.hit')
+      } else {
         modeBaseHelper.set(baseTheme, getThemeByMode(baseTheme, mode))
       }
       const currentModeBaseTheme = modeBaseHelper.get(baseTheme)
 
       const modeDimHelper = ThemeManager.modeDimensionTheme[mode]
-      if (!modeDimHelper.has(themes)) {
+      if (modeDimHelper.has(themes)) {
+        if (process.env.NODE_ENV !== 'production')
+          _countSink.__pyreon_count__?.('rocketstyle.localThemeManager.hit')
+      } else {
         modeDimHelper.set(themes, getThemeByMode(themes, mode))
       }
       const currentModeThemes = modeDimHelper.get(themes)
 
-      return getTheme({
-        rocketstate,
+      const rocketstyle = getTheme({
+        rocketstate: rocketstateRaw,
         themes: currentModeThemes,
         baseTheme: currentModeBaseTheme,
         transformKeys: options.transformKeys,
         appTheme: theme,
       })
-    }
 
-    // Silence "unused" warnings for initialBaseTheme / initialDimensionThemes —
-    // they're eagerly populated into ThemeManager caches so the first accessor
-    // call hits cache, but not referenced directly.
-    void initialBaseTheme
-    void initialDimensionThemes
-
-    // --------------------------------------------------
-    // $rocketstate as a FUNCTION ACCESSOR — reactive on prop changes.
-    // Re-evaluates active dimensions + pseudo state from current props.
-    // --------------------------------------------------
-    // Capture pseudo from localCtx once at setup — pseudo properties are
-    // getters (from createLocalProvider) that read signals lazily.
-    // Passing them through preserves reactivity without subscribing here.
-    const localPseudo = localCtx?.pseudo
-
-    const $rocketstateAccessor = () => {
-      const rocketstate = _calculateStylingAttrs({
-        props: pickStyledAttrs(props as Record<string, unknown>, reservedPropNames),
-        dimensions,
-      })
-
-      // Read pseudo props fresh each call — props may have reactive getters
-      // from _rp() wrapping. Reading inside the accessor (which runs in an
-      // effect) ensures changes to pseudo props like active={isDark()} are tracked.
-      const propPseudo = pick(props, [...PSEUDO_KEYS, ...PSEUDO_META_KEYS])
-
-      return {
-        ...rocketstate,
+      // $rocketstate carries dimension state + pseudo flags so the styler
+      // emits matching pseudo selectors (`:hover`, `:focus`, etc.).
+      const propPseudo = pick(propsRec, ALL_PSEUDO_KEYS)
+      const rocketstate = {
+        ...rocketstateRaw,
         pseudo: { ...localPseudo, ...propPseudo },
       }
-    }
 
-    // --------------------------------------------------
-    // Static mergeProps for final prop filtering (non-dimension props)
-    // --------------------------------------------------
-    const { pseudo: _pseudo, ...mergeProps } = {
-      ...localCtx,
-      ...props,
+      // LRU eviction at cap — drop the oldest (first-inserted) entry.
+      if (themeMemo.size >= RS_MEMO_CAP) {
+        const oldestKey = themeMemo.keys().next().value
+        if (oldestKey !== undefined) themeMemo.delete(oldestKey)
+      }
+      const entry: RsMemoEntry = { rocketstyle, rocketstate }
+      themeMemo.set(key, entry)
+      return entry
     }
 
+    const $rocketstyleAccessor = () => _resolveRsEntry().rocketstyle
+    const $rocketstateAccessor = () => _resolveRsEntry().rocketstate
+
     // --------------------------------------------------
     // final props passed to WrappedComponent
     // --------------------------------------------------
-    const finalProps: Record<string, any> = {
-      ...omit(mergeProps, [
-        ...RESERVED_STYLING_PROPS_KEYS,
-        ...PSEUDO_KEYS,
-        ...options.filterAttrs,
-      ]),
-      ...(options.passProps ? pick(mergeProps, options.passProps) : {}),
-      ref: props.ref,
-      // Function accessors — DynamicStyled wraps them in a computed() so
-      // mode/dimension changes produce a new CSS class reactively. The
-      // computed tracks only these two accessors; the resolve itself runs
-      // untracked to prevent exponential cascade from theme deep-reads.
-      $rocketstyle: $rocketstyleAccessor,
-      $rocketstate: $rocketstateAccessor,
+    // Cache a pre-built Set for omit() — avoids building a new Set from
+    // the key array on every mount. Same dimension structure = same Set.
+    let omitSet = _omitSetCache.get(RESERVED_STYLING_PROPS_KEYS)
+    if (omitSet) {
+      if (process.env.NODE_ENV !== 'production')
+        _countSink.__pyreon_count__?.('rocketstyle.omitSet.hit')
+    } else {
+      omitSet = new Set([...RESERVED_STYLING_PROPS_KEYS, ...STATIC_OMIT_KEYS])
+      _omitSetCache.set(RESERVED_STYLING_PROPS_KEYS, omitSet)
     }
 
-    // development debugging
-    if (process.env.NODE_ENV !== 'production') {
+    // Merge localCtx + props without an intermediate spread object.
+    // omit() handles 'pseudo' removal (included in STATIC_OMIT_KEYS).
+    const mergeProps = localCtx ? { ...localCtx, ...props } : props
+
+    // omit() already returns a fresh object — assign directly onto it
+    // instead of spreading into another {} (saves one object allocation).
+    const finalProps = omit(mergeProps as Record<string, unknown>, omitSet) as Record<string, any>
+
+    if (options.passProps) {
+      const passed = pick(mergeProps, options.passProps)
+      for (const k in passed) finalProps[k] = passed[k]
+    }
+
+    finalProps.ref = props.ref
+    // Function accessors — DynamicStyled wraps them in a computed() so
+    // mode/dimension changes produce a new CSS class reactively. The
+    // computed tracks only these two accessors; the resolve itself runs
+    // untracked to prevent exponential cascade from theme deep-reads.
+    finalProps.$rocketstyle = $rocketstyleAccessor
+    finalProps.$rocketstate = $rocketstateAccessor
+
+    // development debugging — tree-shaken in production via import.meta.env.DEV
+    if (__DEV__) {
       finalProps['data-rocketstyle'] = componentName
 
       if (options.DEBUG) {
@@ -326,6 +459,26 @@ const rocketComponent: RocketComponent = (options) => {
     options: options.statics,
   })
 
+  // ─── Hoisted attrs chain (T3.1) ──────────────────────────────────────
+  //
+  // Expose the accumulated `.attrs()` callback chain on the component so
+  // external inspectors (notably `extractDocumentTree` from
+  // `@pyreon/connector-document`) can compute the post-attrs props
+  // without invoking the full component. The previous Path B workaround
+  // had to run the entire styled wrapper — JSX tree creation, dimension
+  // resolution, the lot — just to read `_documentProps` off the result.
+  //
+  // Typed surface: `RocketStyleComponent.__rs_attrs` is a `readonly
+  // ReadonlyArray<(props) => Record<string, unknown>>`. Empty when
+  // no `.attrs()` was ever called. `chain.reduce(Object.assign, {})`
+  // produces the post-attrs result for a given props bag.
+  //
+  // The `readonly` modifier guards external CONSUMERS — internal
+  // assignment from the factory itself is the only legitimate write,
+  // hence the cast. Do not drop the readonly on the type.
+  ;(FinalComponent as unknown as { __rs_attrs: typeof options.attrs }).__rs_attrs =
+    options.attrs ?? []
+
   Object.assign(FinalComponent, {
     attrs: (attrs: any, { priority, filter }: any = {}) => {
       const result: Record<string, any> = {}

package/src/types/rocketstyle.ts

@@ -153,4 +153,19 @@ export interface IRocketStyleComponent<
 
   IS_ROCKETSTYLE: true
   displayName: string
+
+  /**
+   * The accumulated `.attrs()` callback chain — hoisted at component-creation
+   * time so external inspectors (notably `extractDocumentTree` from
+   * `@pyreon/connector-document`) can compute post-attrs props without
+   * invoking the full styled wrapper. Each callback maps user props to a
+   * partial props object; `chain.reduce(Object.assign, {})` produces the
+   * post-attrs result.
+   *
+   * Stable contract — consumers can rely on this property being present on
+   * every rocketstyle-wrapped component. Empty array when no `.attrs()`
+   * was ever called on the chain. Treat as read-only; mutating breaks
+   * `extractDocumentTree` and any other inspector consuming the hoist.
+   */
+  readonly __rs_attrs: ReadonlyArray<(props: Record<string, unknown>) => Record<string, unknown>>
 }

package/src/utils/attrs.ts

@@ -80,53 +80,49 @@ export const calculateStylingAttrs: CalculateStylingAttrs =
     const result: Record<string, any> = {}
 
     // (1) find dimension keys values & initialize
-    // object with possible options
-    Object.keys(dimensions).forEach((item) => {
+    for (const item in dimensions) {
       const pickedProp = props[item]
       const t = typeof pickedProp
 
-      // if the property is multi key, allow assign array as well
       if (multiKeys?.[item] && Array.isArray(pickedProp)) {
         result[item] = pickedProp
-      }
-      // assign when it's only a string or number otherwise it's considered
-      // as invalid param
-      else if (t === 'string' || t === 'number') {
+      } else if (t === 'string' || t === 'number') {
         result[item] = pickedProp
       } else {
         result[item] = undefined
       }
-    })
+    }
 
     // (2) if booleans are being used let's find the rest
+    // Use `in` operator on the dimension map instead of allocating
+    // a new Set per dimension — the map is already an object with
+    // the keywords as keys.
     if (useBooleans) {
-      const propsKeys = Object.keys(props)
+      for (const key in result) {
+        if (result[key]) continue // already assigned
 
-      Object.entries(result).forEach(([key, value]) => {
+        const dimensionMap = dimensions[key] as Record<string, unknown>
         const isMultiKey = multiKeys?.[key]
+        let newDimensionValue: string | string[] | undefined
 
-        // when value in result is not assigned yet
-        if (!value) {
-          let newDimensionValue: string | string[] | undefined
-          const keywordSet = new Set(Object.keys(dimensions[key] as Record<string, unknown>))
-
-          if (isMultiKey) {
-            newDimensionValue = propsKeys.filter((propKey) => keywordSet.has(propKey))
-          } else {
-            // iterate backwards to guarantee the last one will have
-            // a priority over previous ones
-            for (let i = propsKeys.length - 1; i >= 0; i--) {
-              const k = propsKeys[i] as string
-              if (keywordSet.has(k) && props[k]) {
-                newDimensionValue = k
-                break
-              }
+        if (isMultiKey) {
+          const matches: string[] = []
+          for (const propKey in props) {
+            if (propKey in dimensionMap) matches.push(propKey)
+          }
+          newDimensionValue = matches.length > 0 ? matches : undefined
+        } else {
+          // Iterate props to find last matching keyword
+          // (last wins for priority)
+          for (const k in props) {
+            if (k in dimensionMap && props[k]) {
+              newDimensionValue = k
             }
           }
-
-          result[key] = newDimensionValue
         }
-      })
+
+        result[key] = newDimensionValue
+      }
     }
 
     return result