@tamagui/static 3.0.0-beta.831.1 → 3.0.0-beta.889.1

package/src/compilerHost.ts

@@ -21,6 +21,7 @@ import {
   StyleObjectRules,
   StyleObjectValue,
   stylePropsAll,
+  stylePropsInput,
   stylePropsText,
   validStyles as validStylesView,
 } from '@tamagui/helpers'
@@ -55,11 +56,38 @@ export interface CompilerComponentModule {
   resolvedId: string
 }
 
+/**
+ * The components lowering can resolve, keyed the way element provenance names
+ * them. The frontend owns one per compile and grows it as it discovers component
+ * modules outside the configured `components` list.
+ */
+export interface CompilerComponentRegistry {
+  /** host-resolved module id -> the module name its components register under */
+  modulesById: Map<string, string>
+  componentsByModule: Map<string, LoadedComponents>
+}
+
+export function createComponentRegistry(
+  components: readonly LoadedComponents[],
+  componentModules: readonly CompilerComponentModule[]
+): CompilerComponentRegistry {
+  return {
+    modulesById: new Map(
+      componentModules.map((module) => [module.resolvedId, module.moduleName])
+    ),
+    componentsByModule: new Map(
+      components.map((component) => [component.moduleName, component])
+    ),
+  }
+}
+
 export interface TamaguiCompilerHostOptions {
   target: CompilerTarget
   tamaguiConfig: TamaguiInternalConfig
   components: LoadedComponents[]
   componentModules: CompilerComponentModule[]
+  /** shared with the frontend so discovery during `prepare` is visible to this host */
+  registry?: CompilerComponentRegistry
   /** Keep elements with dynamic style props fully on the runtime path. */
   disablePartialExtraction?: boolean
   /** emit native theme-token mappings for the native style engine */
@@ -390,6 +418,11 @@ const runtimeAnimationProps = new Set([
   'animatedBy',
 ])
 
+// createComponent reads these and never forwards them to the host element, so a
+// flattened element has to drop them instead of emitting an unknown attribute.
+// only the inert values reach the emit: an active one already bailed.
+const componentOnlyProps = new Set(['asChild', 'disableOptimization', 'themeInverse'])
+
 const cssShorthandConflicts: Record<string, readonly string[]> = {
   background: [
     'backgroundAttachment',
@@ -548,6 +581,12 @@ const cssShorthandConflicts: Record<string, readonly string[]> = {
 }
 
 const cssConflictFamilies = [
+  new Set(['width', 'inlineSize']),
+  new Set(['minWidth', 'minInlineSize']),
+  new Set(['maxWidth', 'maxInlineSize']),
+  new Set(['height', 'blockSize']),
+  new Set(['minHeight', 'minBlockSize']),
+  new Set(['maxHeight', 'maxBlockSize']),
   new Set([
     'marginInline',
     'marginInlineEnd',
@@ -943,6 +982,8 @@ export function createTamaguiCompilerHost(
 ): CompilerLoweringHost {
   const platform = options.target === 'native' ? 'native' : 'web'
   const core = requireTamaguiCore(platform) as any
+  const compilerVariantStyleResolver = core.styled(core.View, {}).staticConfig
+    .variantStyleResolver
   const firstThemeName = Object.keys(options.tamaguiConfig.themes ?? {})[0] ?? ''
   const firstTheme = options.tamaguiConfig.themes?.[firstThemeName] ?? {}
   const theme = firstTheme
@@ -968,6 +1009,39 @@ export function createTamaguiCompilerHost(
     }
     return false
   }
+  // A native bundle knows one thing about its platform: it is not web. So a
+  // `web:` clause can never match there and a bare `native:` clause always
+  // does, which makes a value built only from those two resolvable at compile
+  // time. Every other modifier is live at render: media and container queries
+  // measure, theme and group clauses read context, state and lifecycle clauses
+  // track the component, and the device platforms (ios, android, tv) are not
+  // known until the bundle runs. One of those anywhere in the value keeps the
+  // whole element on the runtime path.
+  const platformModifiersRegistered =
+    modifierRegistry.get('web') === 'platform' &&
+    modifierRegistry.get('native') === 'platform'
+  const nativeClauseValue = (
+    value: unknown
+  ): 'live' | { payload: unknown; matched: boolean } | null => {
+    if (typeof value !== 'string' || !flatClausePattern.test(value)) {
+      return isClauseObjectValue(value) ? 'live' : null
+    }
+    if (!platformModifiersRegistered) return 'live'
+    const parsed = parseValue(value, modifierRegistry)
+    if (!parsed.ok || parsed.value.clauses.length === 0) return 'live'
+    let payload: unknown = parsed.value.base
+    let matched = parsed.value.base !== null
+    for (const clause of parsed.value.clauses) {
+      // a chain containing `web` is dead here whatever else it names
+      if (clause.modifiers.includes('web')) continue
+      if (clause.modifiers.length !== 1 || clause.modifiers[0] !== 'native') return 'live'
+      // platform clauses all rank the same, so a later one wins and any of them
+      // beats the unconditional base
+      payload = clause.payload
+      matched = true
+    }
+    return { payload, matched }
+  }
   const configuredAnimationDriver = options.tamaguiConfig.animations as
     | AnimationDriver
     | undefined
@@ -1031,12 +1105,9 @@ export function createTamaguiCompilerHost(
     }
     return resolved.join(' ')
   }
-  const modulesById = new Map(
-    options.componentModules.map((module) => [module.resolvedId, module.moduleName])
-  )
-  const componentsByModule = new Map(
-    options.components.map((component) => [component.moduleName, component])
-  )
+  const { modulesById, componentsByModule } =
+    options.registry ??
+    createComponentRegistry(options.components, options.componentModules)
 
   // A component's import provenance chose its authoring syntax, and the frontend
   // descriptor frozen onto its static config is the only thing that knows how to
@@ -1122,7 +1193,10 @@ export function createTamaguiCompilerHost(
         isInput: row.backing === 'textinput',
         // CSS text properties may be authored on any element and inherited by
         // descendant text, including from a View-backed tag on native.
-        validStyles: { ...validStylesView, ...stylePropsText },
+        validStyles: {
+          ...validStylesView,
+          ...(row.backing === 'textinput' ? stylePropsInput : stylePropsText),
+        },
         defaultProps: {
           ...base.defaultProps,
           ...platformDefaults,
@@ -1135,6 +1209,13 @@ export function createTamaguiCompilerHost(
     definition: MaterializedStyledDefinition | null
   ): { key: string; staticConfig: StaticConfig; displayName?: string } | null => {
     if (!definition || definition.options.kind !== 'static') return null
+    const staticConfig = definition.staticConfig
+    if (
+      staticConfig &&
+      (staticConfig.kind !== 'static' || !staticObject(staticConfig.value))
+    ) {
+      return null
+    }
     const base = directStaticConfig({
       kind: 'element',
       form: 'jsx',
@@ -1160,29 +1241,32 @@ export function createTamaguiCompilerHost(
       typeof definition.baseClassName.value === 'string'
         ? definition.baseClassName.value
         : undefined
+    const localStaticConfig = {
+      ...base.staticConfig,
+      ...(staticConfig?.value as Record<string, unknown> | undefined),
+      variants: {
+        ...base.staticConfig.variants,
+        ...(variants as object | undefined),
+      },
+      defaultProps: {
+        ...base.staticConfig.defaultProps,
+        ...defaultProps,
+        ...(defaultVariants as object | undefined),
+      },
+      defaultVariants,
+      baseClassName: [base.staticConfig.baseClassName, baseClassName]
+        .filter(Boolean)
+        .join(' '),
+      context: context ?? base.staticConfig.context,
+      contextProps: context
+        ? contextProps
+        : (contextProps ?? base.staticConfig.contextProps),
+    }
+    ;(localStaticConfig as any).variantStyleResolver = compilerVariantStyleResolver
     return {
       key: componentKey(definition.id, definition.name),
       displayName: displayName || base.displayName,
-      staticConfig: normalizeStaticConfig({
-        ...base.staticConfig,
-        variants: {
-          ...base.staticConfig.variants,
-          ...(variants as object | undefined),
-        },
-        defaultProps: {
-          ...base.staticConfig.defaultProps,
-          ...defaultProps,
-          ...(defaultVariants as object | undefined),
-        },
-        defaultVariants,
-        baseClassName: [base.staticConfig.baseClassName, baseClassName]
-          .filter(Boolean)
-          .join(' '),
-        context: context ?? base.staticConfig.context,
-        contextProps: context
-          ? contextProps
-          : (contextProps ?? base.staticConfig.contextProps),
-      }),
+      staticConfig: normalizeStaticConfig(localStaticConfig),
     }
   }
 
@@ -1191,8 +1275,11 @@ export function createTamaguiCompilerHost(
     styledDefinition: MaterializedStyledDefinition | null
   ): TamaguiLoweringComponent | null => {
     const dom = domStaticConfig(element)
+    // a config the host evaluated is the component's real static config. The
+    // one derived from a visible `styled()` literal only stands in for
+    // definitions nothing evaluated, such as the app's own
     const resolved =
-      dom ?? styledStaticConfig(styledDefinition) ?? directStaticConfig(element)
+      dom ?? directStaticConfig(element) ?? styledStaticConfig(styledDefinition)
     if (!resolved) return null
     const defaultProps = resolved.staticConfig.defaultProps ?? {}
     return {
@@ -1254,10 +1341,12 @@ export function createTamaguiCompilerHost(
     const staticConfig = component.staticConfig as StaticConfig
     const validStyles =
       staticConfig.validStyles ||
-      (staticConfig.isText || staticConfig.isInput ? stylePropsText : validStylesView)
-    return (
-      name in stylePropsAll && !isValidStyleKey(name, validStyles, staticConfig.accept)
-    )
+      (staticConfig.isInput
+        ? stylePropsInput
+        : staticConfig.isText
+          ? stylePropsText
+          : validStylesView)
+    return name in stylePropsAll && !isValidStyleKey(name, validStyles)
   }
 
   const directStyleName = (name: string, component: LoweringComponent): string | null => {
@@ -1292,6 +1381,7 @@ export function createTamaguiCompilerHost(
         firstThemeName,
         componentState,
         {
+          isStatic: true,
           resolveValues: platform === 'native' ? 'except-theme' : 'variable',
           noClass: platform === 'native',
           isAnimated: false,
@@ -1501,6 +1591,12 @@ export function createTamaguiCompilerHost(
       ) {
         return true
       }
+      // A component resolver receives the complete props object. Without a
+      // compiler-derived read set, resolving an opaque dynamic callsite would
+      // execute the real resolver with an incomplete props snapshot.
+      if ((component.staticConfig as StaticConfig).resolvers?.length) {
+        return false
+      }
       return (
         !options.disablePartialExtraction &&
         ((platform === 'web' && !!directStyleName(name, component)) ||
@@ -1556,15 +1652,56 @@ export function createTamaguiCompilerHost(
           props[entry.name] = entry.value.value
         }
       }
-      const disableOptimizationEntry = input.element.entries.find(
-        (entry) => entry.kind === 'prop' && entry.name === 'disableOptimization'
-      )
-      if (disableOptimizationEntry || 'disableOptimization' in props) {
+      if (component.staticConfig.resolvers?.length) {
+        const unresolvedProps = input.element.entries.filter(
+          (entry) => entry.kind === 'prop' && entry.value.kind !== 'static'
+        )
+        // One conditional with static leaves is still a complete prop set:
+        // lowerCandidate evaluates the full resolver chain once per branch.
+        // Multiple unknown props would require a cross-product/read set, so
+        // they remain on the runtime path.
+        const onlyStaticBranchConditional =
+          unresolvedProps.length === 1 &&
+          unresolvedProps[0]?.kind === 'prop' &&
+          unresolvedProps[0].value.kind === 'conditional' &&
+          canLowerConditionalStyleProp(unresolvedProps[0].name, component)
+        const unresolvedProp = onlyStaticBranchConditional
+          ? undefined
+          : unresolvedProps[0]
+        if (unresolvedProp?.kind === 'prop') {
+          return bailout(
+            input,
+            'local/dynamic-style-value',
+            `Component resolver prop ${unresolvedProp.name} could not be evaluated`,
+            unresolvedProp.span,
+            undefined,
+            unresolvedProp.name
+          )
+        }
+      }
+      // asChild, disableOptimization and themeInverse each asked only whether the
+      // prop was PRESENT, so a false value retained a component that requested
+      // none of the runtime behavior the branch exists for. read the materialized
+      // value instead, and treat a prop the compiler could not evaluate as active.
+      // a later duplicate wins, so the last entry decides and any unevaluated
+      // entry for that name makes the answer unknown.
+      const componentOnlyProp = (name: string) => {
+        let span: MaterializedElement['entries'][number]['span'] | undefined
+        let unknown = false
+        for (const entry of input.element.entries) {
+          if (entry.kind !== 'prop' || entry.name !== name) continue
+          span = entry.span
+          if (entry.value.kind !== 'static') unknown = true
+        }
+        return { unknown, span }
+      }
+      const disableOptimization = componentOnlyProp('disableOptimization')
+      if (disableOptimization.unknown || props.disableOptimization) {
         return bailout(
           input,
           'local/unsupported-target',
           'disableOptimization keeps the component on the runtime path',
-          disableOptimizationEntry?.span
+          disableOptimization.span
         )
       }
       if (component.domTag && props.hidden) props.display = 'none'
@@ -1761,11 +1898,7 @@ export function createTamaguiCompilerHost(
               name === 'opacity'
                 ? `opacity: (${expression})`
                 : `transform: "scale(" + (${expression}) + ")"`
-          } else if (
-            entry.value.kind === 'bailout' &&
-            owners.size === 1 &&
-            owners.has(name)
-          ) {
+          } else if (entry.value.kind === 'bailout' && owners.has(name)) {
             const dynamic = entry.value.dynamic
             if (dynamic?.type === 'number') {
               property = `${JSON.stringify(name)}: (${expression})`
@@ -1831,8 +1964,13 @@ export function createTamaguiCompilerHost(
             entry.value.kind === 'conditional' &&
             canLowerConditionalStyleProp(entry.name, component)
         )
-      if ('theme' in props || 'themeInverse' in props) {
-        const themeProp = 'theme' in props ? 'theme' : 'themeInverse'
+      // a theme name of any value selects a theme, while themeInverse only opens a
+      // boundary when it is on
+      const themeEntry = componentOnlyProp('theme')
+      const themeInverseEntry = componentOnlyProp('themeInverse')
+      const themeBoundary = themeEntry.unknown || 'theme' in props
+      if (themeBoundary || themeInverseEntry.unknown || props.themeInverse) {
+        const themeProp = themeBoundary ? 'theme' : 'themeInverse'
         return bailout(
           input,
           'local/unsupported-target',
@@ -1848,15 +1986,13 @@ export function createTamaguiCompilerHost(
       // the single child and emits no element of its own. a flattened host view
       // would add a wrapper the runtime never renders, and the child would
       // never receive the merged props. both platforms.
-      const asChildEntry = input.element.entries.find(
-        (entry) => entry.kind === 'prop' && entry.name === 'asChild'
-      )
-      if (asChildEntry || 'asChild' in props) {
+      const asChild = componentOnlyProp('asChild')
+      if (asChild.unknown || props.asChild) {
         return bailout(
           input,
           'local/unsupported-target',
           'asChild renders a Slot, not a host view',
-          asChildEntry?.span
+          asChild.span
         )
       }
       // group and container props publish separate keys in the same context:
@@ -2047,7 +2183,11 @@ export function createTamaguiCompilerHost(
           entry.span
         )
       }
-      const staticDefaultProps = component.staticConfig.defaultProps ?? {}
+      const resolvedStyleStaticConfig = core.getStyleStaticConfig(
+        component.staticConfig,
+        core.getConfig()
+      )
+      const staticDefaultProps = resolvedStyleStaticConfig.defaultProps ?? {}
       const defaultProps =
         platform === 'web' &&
         !component.staticConfig.isText &&
@@ -2062,6 +2202,19 @@ export function createTamaguiCompilerHost(
           props
         )
       }
+      const domStyleProgram = input.element.entries.find(
+        (entry) =>
+          entry.kind === 'prop' &&
+          entry.name === 'style' &&
+          entry.value.kind === 'dom-style'
+      )
+      if (platform === 'native' && !component.domTag && domStyleProgram) {
+        return bailout(
+          input,
+          'local/unsupported-target',
+          'Native style() pieces remain on the runtime path'
+        )
+      }
       const propsForConditional = (
         target: Extract<MaterializedElement['entries'][number], { kind: 'prop' }>,
         value: unknown
@@ -2099,22 +2252,35 @@ export function createTamaguiCompilerHost(
                 branchProps
               )
             : core.mergeProps(defaultProps, branchProps)
+        // the same platform-clause reduction the unconditional props get: a
+        // branch resolves through the full pipeline, so a clause left standing
+        // here would be decided by the build machine instead of the bundle
+        if (platform === 'native') {
+          for (const [name, value] of Object.entries(branchCompleteProps)) {
+            const clause = isStyleProp(name, component) ? nativeClauseValue(value) : null
+            if (clause === null || clause === 'live') continue
+            if (clause.matched) branchCompleteProps[name] = clause.payload
+            else delete branchCompleteProps[name]
+          }
+        }
         return { branchProps, branchCompleteProps }
       }
-      // Against completeProps, not props: clauses also arrive from styled()
-      // defaults. Native resolution evaluates them against the build machine's
-      // current state, so folding would freeze that state into the bundle.
+      // native resolution evaluates clauses against the build machine's current
+      // state, so folding a call-site, styled base, or variant clause would freeze
+      // that state into the bundle.
       if (platform === 'native') {
         const isClauseValue = (name: string, value: unknown) =>
           isStyleProp(name, component) &&
           ((typeof value === 'string' && flatClausePattern.test(value)) ||
             isClauseObjectValue(value))
         // a clause can also sit inside a variant definition, where it never
-        // appears as a prop: variants: { big: { true: { width: 'gt-lg:999px' } } }
+        // appears as a prop: variants: { big: { true: { width: 'gt-lg:999px' } } }.
+        // those live in the styled definition, which this element cannot rewrite,
+        // so a clause there retains whatever kind it is.
         const defaultVariants = component.staticConfig.defaultVariants ?? {}
-        const carriesClause =
-          Object.entries(completeProps).some(([name, value]) =>
-            isClauseValue(name, value)
+        const definitionCarriesClause =
+          Object.entries(resolvedStyleStaticConfig.baseStyle ?? {}).some(
+            ([name, value]) => isClauseValue(name, value)
           ) ||
           Object.entries(component.staticConfig.variants ?? {}).some(
             ([variantName, definitions]) =>
@@ -2129,13 +2295,43 @@ export function createTamaguiCompilerHost(
                   )
               )
           )
-        if (carriesClause) {
+        if (definitionCarriesClause) {
           return bailout(
             input,
             'local/unsupported-target',
             'Native conditional value programs remain on the runtime path'
           )
         }
+        const reducedProps: Record<string, unknown> = {}
+        for (const [name, value] of Object.entries(completeProps)) {
+          const clause = isStyleProp(name, component) ? nativeClauseValue(value) : null
+          if (clause === 'live') {
+            return bailout(
+              input,
+              'local/unsupported-target',
+              'Native conditional value programs remain on the runtime path'
+            )
+          }
+          if (clause === null) {
+            reducedProps[name] = value
+            continue
+          }
+          if (clause.matched) reducedProps[name] = clause.payload
+        }
+        completeProps = reducedProps
+        // a conditional leaf is a clause program the same way a direct prop is,
+        // and propsForConditional reduces the ones that fold
+        for (const entry of dynamicStyleEntries) {
+          if (entry.value.kind !== 'conditional') continue
+          for (const leaf of collectLeaves(entry.value.tree)) {
+            if (nativeClauseValue(leaf.value) !== 'live') continue
+            return bailout(
+              input,
+              'local/unsupported-target',
+              'Native conditional value programs remain on the runtime path'
+            )
+          }
+        }
       }
       const split = resolveSplitStyles(
         completeProps,
@@ -2167,13 +2363,6 @@ export function createTamaguiCompilerHost(
           }
         )
       }
-      const domStyleProgram = input.element.entries.find(
-        (entry) =>
-          entry.kind === 'prop' &&
-          entry.name === 'style' &&
-          entry.value.kind === 'dom-style'
-      )
-
       const flatTag =
         component.domTag ??
         (typeof props.render === 'string'
@@ -2193,7 +2382,9 @@ export function createTamaguiCompilerHost(
         }))
 
       const isPropIgnored = (name: string) =>
-        isStyleProp(name, component) || isInvalidHostStyleProp(name, component)
+        isStyleProp(name, component) ||
+        isInvalidHostStyleProp(name, component) ||
+        componentOnlyProps.has(name)
       const spreadReplacement = (
         form: MaterializedElement['form'],
         entry: MaterializedElement['entries'][number]
@@ -2210,16 +2401,11 @@ export function createTamaguiCompilerHost(
 
       let styleEntries = input.element.entries.filter(
         (entry) =>
-          (entry.kind === 'prop' &&
-            (isStyleProp(entry.name, component) ||
-              isInvalidHostStyleProp(entry.name, component))) ||
+          (entry.kind === 'prop' && isPropIgnored(entry.name)) ||
           (entry.kind === 'spread' &&
             entry.value.kind === 'static' &&
             staticObject(entry.value.value) &&
-            Object.keys(entry.value.value).some(
-              (name) =>
-                isStyleProp(name, component) || isInvalidHostStyleProp(name, component)
-            ))
+            Object.keys(entry.value.value).some(isPropIgnored))
       )
       let invalidHostStyle:
         | { entry: MaterializedElement['entries'][number]; name: string }
@@ -3361,7 +3547,8 @@ function bailout(
     | 'local/unsupported-child',
   message: string,
   span = input.element.span,
-  zero?: { rule: ZeroRule; message?: string }
+  zero?: { rule: ZeroRule; message?: string },
+  prop?: string
 ): LoweringCandidateResult {
   return {
     ok: false,
@@ -3371,6 +3558,7 @@ function bailout(
       message,
       span,
       component: input.element.component.name,
+      ...(prop && { prop }),
       ...(zero && { zeroRule: zero.rule, zeroMessage: zero.message }),
     },
   }

package/src/componentDiscovery.ts

@@ -0,0 +1,105 @@
+import type { MaterializedModule } from '@tamagui/compiler-core'
+import path from 'node:path'
+
+import type { CompilerComponentRegistry } from './compilerHost'
+import {
+  getComponentStaticConfigByName,
+  type LoadedComponents,
+} from './extractor/bundleConfig'
+
+/**
+ * Evaluate a host-resolved module and return its exports, or null when the
+ * host cannot run it. Frontends supply this from their bundler's module runner
+ * (Vite) or the static-evaluation require hooks (`evaluateComponentModule`).
+ */
+export type ComponentModuleEvaluator = (module: {
+  id: string
+  specifier: string
+}) => Promise<Record<string, unknown> | null>
+
+// `pkg`, `@scope/pkg`, and their subpaths. `@/x` and `~/x` are path aliases
+const packageSpecifier = /^(?:@[^/@\s]+\/)?[^./~@\s][^/\s]*(?:\/|$)/
+
+function isPackageSpecifier(specifier: string): boolean {
+  return packageSpecifier.test(specifier)
+}
+
+/**
+ * Finds the component modules a file uses that the configured `components`
+ * list does not cover, evaluates each once, and registers what it exports so
+ * lowering resolves them like configured ones. Owned by a frontend for the
+ * life of a project generation; `prepare` runs between materialize and lower.
+ */
+export class ComponentDiscovery {
+  /** null records a module that had no components or could not evaluate */
+  readonly #discovered = new Map<string, LoadedComponents | null>()
+
+  clear(): void {
+    this.#discovered.clear()
+  }
+
+  /** host-resolved ids of every module discovery found components in */
+  ids(): string[] {
+    return [...this.#discovered]
+      .filter(([, loaded]) => loaded !== null)
+      .map(([id]) => id)
+      .sort()
+  }
+
+  /** re-register everything found so far into a freshly built registry */
+  seed(registry: CompilerComponentRegistry): void {
+    for (const [id, loaded] of this.#discovered) {
+      if (!loaded) continue
+      registry.modulesById.set(id, id)
+      registry.componentsByModule.set(id, loaded)
+    }
+  }
+
+  async prepare(
+    module: MaterializedModule,
+    registry: CompilerComponentRegistry,
+    evaluate: ComponentModuleEvaluator | undefined
+  ): Promise<void> {
+    if (!evaluate) return
+    const seen = new Set<string>()
+    const provenances = [
+      ...module.elements.map((element) => element.component.provenance),
+      ...module.styledDefinitions.map((definition) => definition.base.provenance),
+    ]
+    for (const provenance of provenances) {
+      // a relative or aliased import is the app's own module: the graph
+      // already models its styled definitions, and evaluating app code at
+      // build time runs its side effects
+      if (!provenance || !isPackageSpecifier(provenance.specifier)) continue
+      const id = provenance.resolvedId.split(/[?#]/, 1)[0]
+      if (seen.has(id) || registry.modulesById.has(id) || this.#discovered.has(id)) {
+        continue
+      }
+      seen.add(id)
+      if (!path.isAbsolute(id)) {
+        this.#discovered.set(id, null)
+        continue
+      }
+      let loaded: LoadedComponents | null = null
+      try {
+        const exports = await evaluate({ id, specifier: provenance.specifier })
+        if (exports) {
+          const nameToInfo = getComponentStaticConfigByName(
+            id,
+            (exports as { default?: unknown }).default ?? exports
+          )
+          if (Object.keys(nameToInfo).length) loaded = { moduleName: id, nameToInfo }
+        }
+      } catch (error) {
+        if (process.env.DEBUG === 'tamagui') {
+          console.info(`[tamagui] component discovery skipped ${id}:`, error)
+        }
+      }
+      this.#discovered.set(id, loaded)
+      if (loaded) {
+        registry.modulesById.set(id, id)
+        registry.componentsByModule.set(id, loaded)
+      }
+    }
+  }
+}