@tamagui/static 2.7.7 → 3.0.0-beta.1097.1

package/src/zero/transform.ts

@@ -0,0 +1,329 @@
+import {
+  applyLoweredModule,
+  childNode,
+  childNodes,
+  parseModuleAst,
+  planZeroErasure,
+  resolvedModuleId,
+  walkAst,
+  zeroIslandThemeMessage,
+  zeroViolationsFromPlan,
+  type AppliedLoweredModule,
+  type AstNode,
+  type LoweredModulePlan,
+  type SourceEdit,
+  type ZeroViolation,
+} from '@tamagui/compiler-core'
+import { type TamaguiInternalConfig } from '@tamagui/web'
+
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+
+import type { IslandThemeBridge, IslandThemeBridgeLayer } from './islands'
+import {
+  foldBranches,
+  lowerStaticTheme,
+  readStaticTheme,
+  resolveThemeChain,
+  type StaticThemeNode,
+} from './theme'
+
+/**
+ * The zero-mode source transform.
+ *
+ * It runs after lowering has committed its edits and before the bundler records
+ * this module's dependencies. It lowers static `<Theme>` into host markup plus
+ * classes, assigns each island mount its theme bridge, and erases the Tamagui
+ * references lowering consumed.
+ */
+
+export interface ZeroModuleTransformInput {
+  /**
+   * `report` runs every analysis and returns the source unchanged, so a project
+   * can see its violations without moving off the full runtime.
+   */
+  mode: 'report' | 'enforce'
+  id: string
+  /** Project root, so bridge ids are stable and unique across modules. */
+  root: string
+  source: string
+  /** The module's lowering plan. Erasure only runs on a plan with no violations. */
+  plan: LoweredModulePlan
+  config: TamaguiInternalConfig
+  /** Specifier prefixes that name the Tamagui surface, e.g. `tamagui`. */
+  isTamaguiSpecifier(specifier: string): boolean
+  /** Island id when a specifier resolves to a generated island loader. */
+  resolveIslandLoader(specifier: string): { islandId: string } | null
+  /** Island id when a specifier resolves to a declared island root module. */
+  resolveIslandModule(specifier: string): string | null
+}
+
+export interface ZeroModuleTransformResult {
+  output: AppliedLoweredModule
+  edits: SourceEdit[]
+  /** Deterministic bridge descriptors this module produced, by island id. */
+  bridges: Map<string, IslandThemeBridge[]>
+  /** Inline-value CSS rules keyed by their generated class name. */
+  bridgeCSS: Map<string, string>
+  violations: ZeroViolation[]
+  erased: {
+    modules: string[]
+    bindings: string[]
+    styledDefinitions: string[]
+    /** Erased declarators this module also exported. */
+    exports: string[]
+  }
+  /** Animated-number hooks rewritten from the public barrel to the leaf. */
+  rewrittenAnimatedNumberHooks: string[]
+}
+
+function identifierNameOf(node: AstNode | null): string | null {
+  return node && node.type === 'Identifier' && typeof node.name === 'string'
+    ? node.name
+    : null
+}
+
+function jsxNameOf(element: AstNode): string | null {
+  const opening = childNode(element, 'openingElement')
+  if (!opening) return null
+  const name = childNode(opening, 'name')
+  return name && name.type === 'JSXIdentifier' && typeof name.name === 'string'
+    ? name.name
+    : null
+}
+
+export function transformZeroModule(
+  input: ZeroModuleTransformInput
+): ZeroModuleTransformResult {
+  const { id, source, config } = input
+  const moduleId = resolvedModuleId(id)
+  const program = parseModuleAst(source, id)
+
+  // The lowering plan's own blocking diagnostics are the rule 1-6 sites. A
+  // candidate that did not lower left a runtime behind, which is the violation.
+  const violations: ZeroViolation[] = zeroViolationsFromPlan(input.plan)
+  const edits: SourceEdit[] = []
+  const bridges = new Map<string, IslandThemeBridge[]>()
+  const bridgeCSS = new Map<string, string>()
+
+  // module-level bindings we care about
+  let themeLocal: string | null = null
+  let themeUpdateLocal: string | null = null
+  const islandLocals = new Map<string, string>()
+  for (const statement of childNodes(program, 'body')) {
+    if (statement.type !== 'ImportDeclaration') continue
+    const sourceNode = childNode(statement, 'source')
+    const specifier =
+      sourceNode && typeof sourceNode.value === 'string' ? sourceNode.value : null
+    if (!specifier) continue
+    const island = input.resolveIslandLoader(specifier)
+    for (const importSpecifier of childNodes(statement, 'specifiers')) {
+      const local = identifierNameOf(childNode(importSpecifier, 'local'))
+      if (!local) continue
+      if (island) {
+        islandLocals.set(local, island.islandId)
+        continue
+      }
+      if (!input.isTamaguiSpecifier(specifier)) continue
+      const imported = childNode(importSpecifier, 'imported')
+      if (imported && imported.name === 'Theme') themeLocal = local
+      if (imported && imported.name === 'ThemeUpdate') themeUpdateLocal = local
+    }
+  }
+
+  // parent chain, built in one walk
+  const parents = new Map<AstNode, AstNode>()
+  const elements: AstNode[] = []
+  walkAst(program, (node, parent) => {
+    if (parent) parents.set(node, parent)
+    if (node.type === 'JSXElement') elements.push(node)
+  })
+
+  const themeElements = elements.filter((element) => {
+    const name = jsxNameOf(element)
+    return name === themeLocal || name === themeUpdateLocal
+  })
+
+  // Each <Theme> is read once, then lowered against its own ancestry, so a
+  // nested node resolves against whatever its parent resolved to.
+  const themeNodes = new Map<AstNode, StaticThemeNode>()
+  for (const element of themeElements) {
+    const read = readStaticTheme(
+      element,
+      id,
+      source,
+      config,
+      jsxNameOf(element) === themeUpdateLocal ? 'ThemeUpdate' : 'Theme'
+    )
+    for (const [identifier, rules] of read.css) bridgeCSS.set(identifier, rules)
+    violations.push(...read.violations)
+    if (read.node) themeNodes.set(element, read.node)
+  }
+
+  const themeChainOf = (element: AstNode): StaticThemeNode[] => {
+    const chain: StaticThemeNode[] = []
+    let cursor: AstNode | undefined = element
+    while (cursor) {
+      const node = themeNodes.get(cursor)
+      if (node) chain.unshift(node)
+      cursor = parents.get(cursor)
+    }
+    return chain
+  }
+
+  // With no provider in the zero graph, the document's theme is the config's
+  // first theme: that is the one the generated artifact writes to `:root`.
+  const rootThemeName = Object.keys(config.themes)[0] ?? 'light'
+
+  for (const element of themeElements) {
+    const node = themeNodes.get(element)
+    if (!node) continue
+    const lowered = lowerStaticTheme(
+      node,
+      themeChainOf(element),
+      rootThemeName,
+      config,
+      id
+    )
+    violations.push(...lowered.violations)
+    edits.push(...lowered.edits)
+  }
+
+  // island mounts: assign each site a stable bridge from its static Theme chain
+  const mounts = elements
+    .filter((element) => {
+      const name = jsxNameOf(element)
+      return !!name && islandLocals.has(name)
+    })
+    .sort((left, right) => left.start - right.start)
+
+  const moduleBridgePrefix = createHash('sha256')
+    .update(path.relative(input.root, id).replace(/\\/g, '/'))
+    .digest('hex')
+    .slice(0, 8)
+
+  // Lowering rewrites the component name of every element it turned into a host
+  // element, so an uppercase JSX name that no edit covers is an opaque component
+  // call: what it renders around its children is not visible from this module.
+  const loweredRanges = input.plan.edits.filter((edit) => edit.end > edit.start)
+  const isOpaqueAncestor = (element: AstNode): boolean => {
+    if (themeNodes.has(element)) return false
+    const name = jsxNameOf(element)
+    if (!name || islandLocals.has(name)) return false
+    if (name[0] !== name[0].toUpperCase()) return false
+    const nameNode = childNode(childNode(element, 'openingElement')!, 'name')!
+    return !loweredRanges.some(
+      (edit) => edit.start <= nameNode.start && edit.end >= nameNode.end
+    )
+  }
+
+  mounts.forEach((element, index) => {
+    const islandId = islandLocals.get(jsxNameOf(element)!)!
+
+    let opaque: AstNode | null = null
+    for (let cursor = parents.get(element); cursor; cursor = parents.get(cursor)) {
+      if (cursor.type === 'JSXElement' && isOpaqueAncestor(cursor)) opaque = cursor
+    }
+    if (opaque) {
+      violations.push({
+        rule: 4,
+        code: 'local/unsupported-target',
+        span: { id: moduleId, start: element.start, end: element.end },
+        component: islandId,
+        message: zeroIslandThemeMessage(islandId),
+      })
+      return
+    }
+
+    const chain = themeChainOf(element)
+    const layers = chain
+      .map((node) => node.layer)
+      .filter((layer): layer is IslandThemeBridgeLayer => !!layer)
+    const branches = resolveThemeChain(chain, rootThemeName, config)
+
+    // One descriptor per enumerated theme name, and the mount selects its id
+    // with the same condition the compiled classes use.
+    const descriptors = branches.map((branch, branchIndex) => ({
+      test: branch.test,
+      bridge: {
+        // unique across modules and stable across the server and client
+        // compilations of the same entry, because both see the same module path
+        id:
+          branches.length === 1
+            ? `b${moduleBridgePrefix}_${index}`
+            : `b${moduleBridgePrefix}_${index}_${branchIndex}`,
+        name: branch.name,
+        layers,
+      } satisfies IslandThemeBridge,
+    }))
+
+    const list = bridges.get(islandId) ?? []
+    for (const descriptor of descriptors) list.push(descriptor.bridge)
+    bridges.set(islandId, list)
+
+    // The descriptor travels inline as data, so nothing in the zero graph has to
+    // import a manifest module and no build ordering can desynchronize them.
+    const fold = (value: (bridge: IslandThemeBridge) => string) =>
+      foldBranches(
+        descriptors.map((descriptor) => ({
+          test: descriptor.test,
+          value: value(descriptor.bridge),
+        }))
+      )
+    const opening = childNode(element, 'openingElement')!
+    const nameNode = childNode(opening, 'name')!
+    edits.push({
+      start: nameNode.end,
+      end: nameNode.end,
+      content: ` data-tamagui-bridge={${fold((bridge) =>
+        JSON.stringify(bridge.id)
+      )}} __tamaguiBridge={${fold((bridge) => JSON.stringify(bridge))}}`,
+      origin: { id: moduleId, start: nameNode.start, end: nameNode.end },
+    })
+  })
+
+  // Reference erasure runs last, so it sees the Theme edits as consumed ranges,
+  // and only on a plan that already has nothing to report: erasure's whole
+  // licence is that every use in this module lowered.
+  const erasure = violations.length
+    ? null
+    : planZeroErasure({
+        id: moduleId,
+        source,
+        loweredEdits: [...input.plan.edits, ...edits],
+        isTamaguiSpecifier: input.isTamaguiSpecifier,
+        islandIdFor: input.resolveIslandModule,
+      })
+  if (erasure) {
+    edits.push(...erasure.edits)
+    violations.push(...erasure.violations)
+  }
+
+  // `report` leaves the source alone by contract, so its output is whatever
+  // ordinary lowering produced.
+  const output =
+    input.mode === 'report'
+      ? applyLoweredModule(source, moduleId, input.plan)
+      : violations.length
+        ? { changed: false, code: source, map: null }
+        : applyLoweredModule(source, moduleId, {
+            id: moduleId,
+            sourceHash: input.plan.sourceHash,
+            edits: [...input.plan.edits, ...edits],
+          })
+
+  return {
+    output,
+    edits: input.mode === 'report' ? [] : edits,
+    bridges: input.mode === 'report' ? new Map() : bridges,
+    bridgeCSS: input.mode === 'report' ? new Map() : bridgeCSS,
+    violations,
+    erased: {
+      modules: erasure?.removedModules ?? [],
+      bindings: erasure?.removedBindings ?? [],
+      styledDefinitions: erasure?.erasedStyledDefinitions ?? [],
+      exports: erasure?.erasedExports ?? [],
+    },
+    rewrittenAnimatedNumberHooks: erasure?.rewrittenAnimatedNumberHooks ?? [],
+  }
+}

package/types/check-dep-versions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-dep-versions.d.ts","sourceRoot":"","sources":["../src/check-dep-versions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8oBH,+CAA+C;AAC/C,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,SAAS;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC9C,EAAE,CAAA;CACJ,CAAA;AAED,qBAAa,IAAI;IACf,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;;;;;OAUG;gBACS,IAAI,EAAE,MAAM;IAKjB,iBAAiB,IAAI,MAAM;IAI3B,eAAe,IAAI,SAAS,UAAU,EAAE;IAMxC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAc9C,IAAW,0BAA0B,IAAI,OAAO,CAE/C;CACF"}
+{"version":3,"file":"check-dep-versions.d.ts","sourceRoot":"","sources":["../src/check-dep-versions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8oBH,+CAA+C;AAC/C,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,OAAO,CAAA;IACtB,QAAQ,EAAE,SAAS;QACjB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,SAAS;YAAE,YAAY,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAC9C,EAAE,CAAA;CACJ,CAAA;AAED,qBAAa,IAAI;IACf,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C;;;;;;;;;;OAUG;IACH,YAAY,IAAI,EAAE,MAAM,EAGvB;IAEM,iBAAiB,IAAI,MAAM,CAEjC;IAEM,eAAe,IAAI,SAAS,UAAU,EAAE,CAI9C;IAEM,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAY7C;IAED,IAAW,0BAA0B,IAAI,OAAO,CAE/C;CACF"}

package/types/checkDeps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkDeps.d.ts","sourceRoot":"","sources":["../src/checkDeps.ts"],"names":[],"mappings":"AAIA,oBAAY,eAAe;IACzB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,EAAE,CAAA;IACzC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AA+TD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,iBA8B3C"}
+{"version":3,"file":"checkDeps.d.ts","sourceRoot":"","sources":["../src/checkDeps.ts"],"names":[],"mappings":"AAIA,oBAAY,eAAe;IACzB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,WAAW,gBAAgB;CAC5B;AAED,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,SAAS,GAAG,eAAe,EAAE,EAAE,CAAA;IACzC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACjC,oBAAoB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC9B,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC,CAAA;AA+TD,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,iBA+B3C"}

package/types/compiler.d.ts

@@ -0,0 +1,134 @@
+import { type AppliedLoweredModule, type CompilerTarget, type LoweredModulePlan, type ResolvedModuleId } from '@tamagui/compiler-core';
+import type { TamaguiOptions } from '@tamagui/types';
+import { type ComponentModuleEvaluator } from './componentDiscovery';
+import type { TamaguiProjectInfo } from './extractor/bundleConfig';
+export interface CompilerProjectComponentModule {
+    moduleName: string;
+    id: string;
+}
+export interface CompilerProject {
+    projectInfo: TamaguiProjectInfo;
+    componentModules: CompilerProjectComponentModule[];
+    generation: string;
+    /** Keep elements with dynamic style props fully on the runtime path. */
+    disablePartialExtraction?: boolean;
+    /** emit native theme-token mappings for the native style engine */
+    experimentalNativeFastPath?: boolean;
+    /** Zero-runtime mode, which makes the host's diagnostics mode-aware. */
+    zeroRuntime?: boolean;
+    /**
+     * Content identity of everything a lowering plan depends on that is not a
+     * module: the compiler build, the evaluated config and component registry,
+     * the platform, and the modes. Null when the project could not name the files
+     * that determine it, in which case nothing is cached to disk.
+     */
+    cacheStamp: string | null;
+}
+export interface LoadCompilerProjectInput {
+    root: string;
+    target: CompilerTarget;
+    options: Partial<TamaguiOptions>;
+    generation: string | ((projectInfo: TamaguiProjectInfo, componentModules: CompilerProjectComponentModule[], options: TamaguiOptions) => string);
+    rebuild?: boolean;
+    /**
+     * `name@version` for the host integration package, folded into the cache
+     * stamp so a plugin upgrade cannot reuse plans built by the previous one.
+     */
+    hostVersions?: readonly string[];
+    missingProjectMessage?: string;
+    load?: (options: TamaguiOptions, rebuild: boolean) => Promise<TamaguiProjectInfo | null>;
+    resolveComponents?: (moduleNames: readonly string[], projectInfo: TamaguiProjectInfo, options: TamaguiOptions) => Promise<CompilerProjectComponentModule[]>;
+}
+/**
+ * normalize and load the compiler-owned project contract. module resolution and
+ * evaluation stay with the adapter through the two callbacks.
+ */
+export declare function loadCompilerProject({ root, target, options: optionsIn, generation, rebuild, hostVersions, missingProjectMessage, load, resolveComponents, }: LoadCompilerProjectInput): Promise<CompilerProject>;
+/**
+ * The non-module half of every plan cache key. Null when the project named no
+ * stamp sources: a stamp that cannot see a config change is worse than no
+ * cache, so that project simply does not cache.
+ */
+export declare function compilerProjectStamp(input: {
+    stampSources: readonly string[];
+    hostVersions: readonly string[];
+    target: CompilerTarget;
+    componentModules: readonly CompilerProjectComponentModule[];
+    disablePartialExtraction: boolean;
+    experimentalNativeFastPath: boolean;
+    zeroRuntime: boolean;
+    /**
+     * `process.env.NODE_ENV === 'development'` in the process that builds plans.
+     * The host emits debug-receipt edits into `plan.edits` only in development
+     * (compilerHost.ts's developmentDebugInstrumentation), so a development plan
+     * is not a plan a production build may reuse. This is the ONLY ambient input
+     * to a plan, and it lives in the stamp so every host inherits it rather than
+     * each one remembering to add it to its own key.
+     */
+    development: boolean;
+}): string | null;
+export interface CompilerResolution {
+    id: string;
+    external?: boolean;
+}
+export interface CompilerInput {
+    id: string;
+    source: string;
+    root: string;
+    target: CompilerTarget;
+    /** Host environment whose resolver produced this module graph. */
+    environment?: string;
+    project: CompilerProject;
+    resolve(specifier: string, importer: string): Promise<CompilerResolution | null>;
+    load(id: string): Promise<string | null>;
+    /**
+     * Evaluate a host-resolved module and return its exports. The frontend asks
+     * for every package a JSX element or styled() base imports from that is not
+     * in the configured `components` list, once per module per project, and
+     * lowers against the static configs it finds. Return null (or throw) when
+     * the host cannot evaluate the module; those elements stay on the runtime
+     * path exactly as before.
+     */
+    evaluate?: ComponentModuleEvaluator;
+}
+export type CompilerUpdateInput = CompilerInput;
+export interface CompilerResult {
+    plan: LoweredModulePlan;
+    output: AppliedLoweredModule;
+    invalidatedIds: ResolvedModuleId[];
+}
+/**
+ * Long-lived host-resolved graph frontend. The adapter supplies every identity and
+ * load result; compiler-core never guesses package, alias, or workspace resolution.
+ */
+export declare class CompilerFrontend {
+    private readonly session;
+    private queue;
+    private readonly planCaches;
+    private readonly moduleRecords;
+    private moduleContext;
+    private readonly discovery;
+    /**
+     * One cache per project root and platform. Absent when the project produced
+     * no content stamp, in which case plans are never persisted rather than
+     * persisted under an identity that cannot see a config change.
+     */
+    private planCacheFor;
+    /** Hits, misses and writes across every plan cache this frontend has used. */
+    get planCacheStats(): {
+        hits: number;
+        misses: number;
+        writes: number;
+    };
+    compile(input: CompilerInput): Promise<CompilerResult>;
+    update(input: CompilerUpdateInput): Promise<ResolvedModuleId[]>;
+    has(id: string): boolean;
+    dependentsOf(id: string): ResolvedModuleId[];
+    remove(id: string): Promise<import("@tamagui/compiler-core").GraphInvalidation>;
+    parseCount(id: string): number;
+    private compileNow;
+    /** host-resolved ids of every module discovery found components in */
+    discoveredModuleIds(): string[];
+    private buildTree;
+}
+//# sourceMappingURL=compiler.d.ts.map

package/types/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"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"}

package/types/compilerHost.d.ts

@@ -0,0 +1,38 @@
+import type { CompilerLoweringHost, CompilerTarget } from '@tamagui/compiler-core';
+import type { TamaguiInternalConfig } from '@tamagui/web';
+import type { LoadedComponents } from './extractor/bundleConfig';
+export interface CompilerComponentModule {
+    moduleName: string;
+    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 declare function createComponentRegistry(components: readonly LoadedComponents[], componentModules: readonly CompilerComponentModule[]): CompilerComponentRegistry;
+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 */
+    experimentalNativeFastPath?: boolean;
+    /**
+     * Zero-runtime mode. The diagnostics stay the same shape; what changes is that
+     * a spread the compiler cannot prove style-free is rejected instead of merged,
+     * and the sites whose rule differs from their code's default say so.
+     */
+    zeroRuntime?: boolean;
+}
+export declare function createTamaguiCompilerHost(options: TamaguiCompilerHostOptions): CompilerLoweringHost;
+//# sourceMappingURL=compilerHost.d.ts.map

package/types/compilerHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compilerHost.d.ts","sourceRoot":"","sources":["../src/compilerHost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,oBAAoB,EACpB,cAAc,EAQf,MAAM,wBAAwB,CAAA;AAqC/B,OAAO,KAAK,EAAiC,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAExF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAIhE,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,+EAA+E;IAC/E,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;CAClD;AAED,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,gBAAgB,EAAE,SAAS,uBAAuB,EAAE,GACnD,yBAAyB,CAS3B;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,cAAc,CAAA;IACtB,aAAa,EAAE,qBAAqB,CAAA;IACpC,UAAU,EAAE,gBAAgB,EAAE,CAAA;IAC9B,gBAAgB,EAAE,uBAAuB,EAAE,CAAA;IAC3C,qFAAqF;IACrF,QAAQ,CAAC,EAAE,yBAAyB,CAAA;IACpC,wEAAwE;IACxE,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC,mEAAmE;IACnE,0BAA0B,CAAC,EAAE,OAAO,CAAA;IACpC;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;AAg2BD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,oBAAoB,CAwrFtB"}

package/types/componentDiscovery.d.ts

@@ -0,0 +1,27 @@
+import type { MaterializedModule } from '@tamagui/compiler-core';
+import type { CompilerComponentRegistry } from './compilerHost';
+/**
+ * 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>;
+/**
+ * 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 declare class ComponentDiscovery {
+    #private;
+    clear(): void;
+    /** host-resolved ids of every module discovery found components in */
+    ids(): string[];
+    /** re-register everything found so far into a freshly built registry */
+    seed(registry: CompilerComponentRegistry): void;
+    prepare(module: MaterializedModule, registry: CompilerComponentRegistry, evaluate: ComponentModuleEvaluator | undefined): Promise<void>;
+}
+//# sourceMappingURL=componentDiscovery.d.ts.map

package/types/componentDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentDiscovery.d.ts","sourceRoot":"","sources":["../src/componentDiscovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAGhE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAM/D;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,MAAM,EAAE;IAC9C,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;CAClB,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAA;AAS7C;;;;;GAKG;AACH,qBAAa,kBAAkB;;IAI7B,KAAK,IAAI,IAAI,CAEZ;IAED,sEAAsE;IACtE,GAAG,IAAI,MAAM,EAAE,CAKd;IAED,wEAAwE;IACxE,IAAI,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI,CAM9C;IAEK,OAAO,CACX,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,yBAAyB,EACnC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,GAC7C,OAAO,CAAC,IAAI,CAAC,CA0Cf;CACF"}

package/types/constants.d.ts

@@ -1,6 +1,5 @@
 export declare const CSS_FILE_NAME = "__snack.css";
 export declare const MEDIA_SEP = "_";
-export declare const cacheDir: any;
 export declare const FAILED_EVAL: unique symbol;
 export declare const SHOULD_DEBUG: boolean | undefined;
 //# sourceMappingURL=constants.d.ts.map

package/types/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAG1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAG5B,eAAO,MAAM,QAAQ,KAAkD,CAAA;AAEvE,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC8C,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,gBAAgB,CAAA;AAG1C,eAAO,MAAM,SAAS,MAAM,CAAA;AAE5B,eAAO,MAAM,WAAW,eAA8B,CAAA;AAEtD,eAAO,MAAM,YAAY,qBAC8C,CAAA"}

package/types/domStructuralPass.d.ts

@@ -0,0 +1,3 @@
+import { type StructuralModulePass } from '@tamagui/compiler-core';
+export declare const domStructuralPass: StructuralModulePass;
+//# sourceMappingURL=domStructuralPass.d.ts.map

package/types/domStructuralPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domStructuralPass.d.ts","sourceRoot":"","sources":["../src/domStructuralPass.ts"],"names":[],"mappings":"AAQA,OAAO,EAML,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAA;AAgC/B,eAAO,MAAM,iBAAiB,EAAE,oBA8I/B,CAAA"}

package/types/exports.d.ts

@@ -1,17 +1,16 @@
 export * from './checkDeps';
+export * from './compilerHost';
+export * from './compiler';
 export * from './types';
-export { createExtractor } from './extractor/createExtractor';
-export { literalToAst } from './extractor/literalToAst';
 export * from './constants';
-export * from './extractor/extractToClassNames';
 export * from './extractor/concatClassName';
-export * from './extractor/extractToNative';
-export * from './extractor/extractHelpers';
 export * from './extractor/loadTamagui';
+export { evaluateComponentModule } from './extractor/bundleConfig';
+export * from './componentDiscovery';
 export * from './extractor/watchTamaguiConfig';
-export * from './extractor/createLogger';
 export * from './registerRequire';
 export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat';
 export { esbundleTamaguiConfig } from './extractor/bundle';
 export * from './getPragmaOptions';
+export * from './zero';
 //# sourceMappingURL=exports.d.ts.map

package/types/exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,cAAc,iCAAiC,CAAA;AAC/C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,6BAA6B,CAAA;AAC3C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AACvC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"exports.d.ts","sourceRoot":"","sources":["../src/exports.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,yBAAyB,CAAA;AACvC,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAClE,cAAc,sBAAsB,CAAA;AACpC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,mBAAmB,CAAA;AACjC,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACrF,OAAO,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAC1D,cAAc,oBAAoB,CAAA;AAClC,cAAc,QAAQ,CAAA"}

package/types/extractor/addLocalExports.d.ts

@@ -0,0 +1,3 @@
+/** Adds exports used only while evaluating local component modules. */
+export declare function addLocalExports(source: string, id?: string): string;
+//# sourceMappingURL=addLocalExports.d.ts.map

package/types/extractor/addLocalExports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addLocalExports.d.ts","sourceRoot":"","sources":["../../src/extractor/addLocalExports.ts"],"names":[],"mappings":"AAWA,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAoCnE"}