fix(types): align types/ dirs with upstream + skip-types where hanzogui-build emits wrong

several packages had committed types/ files that drifted from source over previous syncs. replaced our types/ contents with upstream v2.0.0's (rename-translated) so they match current source. @hanzogui/floating: hanzogui-build incorrectly drops '| null' from the inferred type of FloatingOverrideContext on regeneration. set its build script to --skip-types so the (now-correct) committed type is preserved instead. real fix would be in hanzogui-build itself; this unblocks the publish. build status: 163/163 packages build successfully. restored scripts/rename-from-tamagui.sh (was missing from earlier commits).
2026-05-24 14:52:04 -10:00
parent 93cc675377
commit 4c97ce7bb7
2835 changed files with 158106 additions and 1664 deletions
@@ -0,0 +1,5 @@
+import type babel from "@babel/core";
+declare const _default: babel.PluginObj;
+export default _default;
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,25 @@
+import type { HanzoguiOptions } from '@hanzogui/types';
+import type { Compiler, RuleSetRule } from 'webpack';
+export type PluginOptions = HanzoguiOptions & {
+    isServer?: boolean;
+    exclude?: RuleSetRule['exclude'];
+    test?: RuleSetRule['test'];
+    jsLoader?: any;
+    disableEsbuildLoader?: boolean;
+    disableModuleJSXEntry?: boolean;
+    disableWatchConfig?: boolean;
+    disableAliases?: boolean;
+    useHanzoguiSVG?: boolean;
+};
+export declare class HanzoguiPlugin {
+    options: PluginOptions;
+    pluginName: string;
+    constructor(options?: PluginOptions);
+    safeResolves: (resolves: [string, string][], multiple?: boolean) => string[][];
+    get componentsFullPaths(): string[][];
+    get componentsBaseDirs(): string[];
+    isInComponentModule: (fullPath: string) => boolean;
+    get defaultAliases(): any;
+    apply(compiler: Compiler): void;
+}
+//# sourceMappingURL=HanzoguiPlugin.d.ts.map
@@ -0,0 +1,4 @@
+import type { HanzoguiOptions } from '@hanzogui/static';
+import type { LoaderContext } from 'webpack';
+export default function loader(this: LoaderContext<HanzoguiOptions>): void;
+//# sourceMappingURL=css.d.ts.map
@@ -0,0 +1,6 @@
+import './polyfills';
+import { loader } from './loader';
+export default loader;
+export * from './HanzoguiPlugin';
+export * from './shouldExclude';
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,4 @@
+import type { HanzoguiOptions } from '@hanzogui/types';
+import type { LoaderContext } from 'webpack';
+export declare const loader: (this: LoaderContext<HanzoguiOptions>, sourceIn: Buffer | string) => Promise<void>;
+//# sourceMappingURL=loader.d.ts.map
@@ -0,0 +1 @@
+//# sourceMappingURL=polyfills.d.ts.map
@@ -0,0 +1,2 @@
+export declare const requireResolve: NodeJS.RequireResolve;
+//# sourceMappingURL=requireResolve.d.ts.map
@@ -0,0 +1,2 @@
+export declare const shouldExclude: (filePath: string, projectRoot?: string) => boolean;
+//# sourceMappingURL=shouldExclude.d.ts.map
@@ -0,0 +1,2 @@
+export default function loader(this: any, sourceIn: Buffer | string): Promise<any>;
+//# sourceMappingURL=test.d.ts.map
@@ -0,0 +1,39 @@
+import { type HanzoguiOptions } from '@hanzogui/static';
+export type MetroHanzoguiOptions = HanzoguiOptions & {
+    /**
+     * @deprecated CSS interop is no longer supported. Use `hanzogui generate` instead.
+     */
+    cssInterop?: boolean;
+};
+type MetroConfigInput = {
+    resolver?: any;
+    transformer?: any;
+    transformerPath?: string;
+    [key: string]: any;
+};
+/**
+ * Configure Metro for Hanzogui.
+ *
+ * This is now a simplified wrapper that just ensures CSS is enabled and
+ * loads your Hanzogui config. For CSS generation, use the CLI:
+ *
+ * 1. Create a `hanzogui.build.ts` with `outputCSS` option
+ * 2. Run `hanzogui generate` before your build
+ * 3. Import the generated CSS in your app's layout
+ *
+ * @example
+ * ```js
+ * // metro.config.js
+ * const { getDefaultConfig } = require('expo/metro-config')
+ * const { withHanzogui } = require('@hanzogui/metro-plugin')
+ *
+ * const config = getDefaultConfig(__dirname, { isCSSEnabled: true })
+ * module.exports = withHanzogui(config, {
+ *   components: ['hanzogui'],
+ *   config: './hanzogui.config.ts',
+ * })
+ * ```
+ */
+export declare function withHanzogui(metroConfig: MetroConfigInput, optionsIn?: MetroHanzoguiOptions): MetroConfigInput;
+export {};
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,2 @@
+export * from './withHanzogui';
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,24 @@
+import type { PluginOptions as LoaderPluginOptions } from 'hanzogui-loader';
+export type WithHanzoguiProps = LoaderPluginOptions & {
+    appDir?: boolean;
+    enableLegacyFontSupport?: boolean;
+    includeCSSTest?: RegExp | ((path: string) => boolean);
+    /**
+     * By default, we configure webpack to pass anything inside your root or design system
+     * to the Hanzogui loader. If you are importing files from an external package, use this
+     **/
+    shouldExtract?: (path: string, projectRoot: string) => boolean | undefined;
+    /**
+     * *Advaned* Config to avoid resolving files on the server.
+     */
+    shouldExcludeFromServer?: (props: {
+        context: string;
+        request: string;
+        fullPath: string;
+    }) => boolean | string | undefined;
+    disableThemesBundleOptimize?: boolean;
+    /** By default we add a Next.js modularizeImports option to tree shake @hanzogui/lucide-icons-2, this disables it */
+    disableOptimizeLucideIcons?: boolean;
+};
+export declare const withHanzogui: (hanzoguiOptionsIn?: WithHanzoguiProps) => (nextConfig?: any) => any;
+//# sourceMappingURL=withHanzogui.d.ts.map
@@ -0,0 +1,35 @@
+/**
+ * @hanzogui/static-sync
+ *
+ * Synchronous API for Hanzogui static extraction using synckit.
+ * Wraps @hanzogui/static's worker implementation to provide sync APIs
+ * required by Babel plugins which cannot use async functions.
+ *
+ * This package uses synckit to convert async worker calls into synchronous ones.
+ */
+import type { BabelFileResult } from '@babel/core';
+import type { HanzoguiOptions } from '@hanzogui/types';
+export type { ExtractedResponse, HanzoguiProjectInfo } from '@hanzogui/static';
+export type { HanzoguiOptions } from '@hanzogui/types';
+export declare const getPragmaOptions: (props: {
+    source: string;
+    path: string;
+}) => any;
+/**
+ * Extract Hanzogui components to className-based CSS for web (synchronous)
+ */
+export declare function extractToClassNamesSync(params: {
+    source: string | Buffer;
+    sourcePath?: string;
+    options: HanzoguiOptions;
+    shouldPrintDebug?: boolean | 'verbose';
+}): any;
+/**
+ * Extract Hanzogui components to React Native StyleSheet format (synchronous)
+ */
+export declare function extractToNativeSync(sourceFileName: string, sourceCode: string, options: HanzoguiOptions): BabelFileResult;
+/**
+ * Get babel plugin that uses synchronous extraction
+ */
+export declare function getBabelPlugin(): any;
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,70 @@
+/**
+ * @hanzogui/static-worker
+ *
+ * Pure worker-based API for Hanzogui static extraction.
+ * All operations run in a worker thread for better performance and isolation.
+ *
+ * This package provides a clean async API that wraps @hanzogui/static's worker
+ * implementation without exposing any sync/legacy APIs.
+ */
+import type { HanzoguiOptions } from '@hanzogui/types';
+export type { ExtractedResponse, HanzoguiProjectInfo } from '@hanzogui/static';
+export type { HanzoguiOptions } from '@hanzogui/types';
+export declare const getPragmaOptions: (props: {
+    source: string;
+    path: string;
+}) => Promise<{
+    shouldPrintDebug: boolean | "verbose";
+    shouldDisable: boolean;
+}>;
+/**
+ * Load Hanzogui configuration in worker
+ * Sends a warmup task to trigger config loading
+ * bundleConfig auto-detects if files exist and skips rebuild
+ */
+export declare function loadHanzogui(options: Partial<HanzoguiOptions>): Promise<any>;
+/**
+ * Load Hanzogui build configuration asynchronously
+ * Uses esbuild-wasm to avoid EPIPE errors from native esbuild service lifecycle
+ */
+export declare function loadHanzoguiBuildConfig(hanzoguiOptions: Partial<HanzoguiOptions> | undefined): Promise<HanzoguiOptions>;
+/**
+ * Extract Hanzogui components to className-based CSS for web
+ */
+export declare function extractToClassNames(params: {
+    source: string | Buffer;
+    sourcePath?: string;
+    options: HanzoguiOptions;
+    shouldPrintDebug?: boolean | 'verbose';
+}): Promise<any>;
+/**
+ * Extract Hanzogui components to React Native StyleSheet format
+ */
+export declare function extractToNative(sourceFileName: string, sourceCode: string, options: HanzoguiOptions): Promise<any>;
+/**
+ * Watch Hanzogui config for changes and reload when it changes
+ */
+export declare function watchHanzoguiConfig(options: HanzoguiOptions): Promise<{
+    dispose: () => void;
+} | undefined>;
+/**
+ * Clear the worker's config cache
+ * Call this when config files change
+ */
+export declare function clearWorkerCache(): Promise<void>;
+/**
+ * Clean up the worker pool on exit
+ * Should be called when the build process completes
+ */
+export declare function destroyPool(): Promise<void>;
+/**
+ * Get pool statistics for debugging
+ */
+export declare function getPoolStats(): {
+    threads: number;
+    queueSize: number;
+    completed: number;
+    duration: number;
+    utilization: number;
+} | null;
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,37 @@
+/**
+ * "license": "MIT",
+  "author": "Bryan Mishkin",
+ */
+/** Relevant public data about a dependency. */
+type Dependency = {
+    name: string;
+    isMismatching: boolean;
+    versions: readonly {
+        version: string;
+        packages: readonly {
+            pathRelative: string;
+        }[];
+    }[];
+};
+export declare class CDVC {
+    /** An object mapping each dependency in the workspace to information including the versions found of it. */
+    private readonly dependencies;
+    /**
+     * @param path - path to the workspace root
+     * @param options
+     * @param options.fix - Whether to autofix inconsistencies (using latest version present)
+     * @param options.ignoreDep - Dependency(s) to ignore mismatches for
+     * @param options.includeDepPattern - RegExp(s) of dependency names to ignore mismatches for
+     * @param options.ignorePackage - Workspace package(s) to ignore mismatches for
+     * @param options.ignorePackagePattern - RegExp(s) of package names to ignore mismatches for
+     * @param options.ignorePath - Workspace-relative path(s) of packages to ignore mismatches for
+     * @param options.ignorePathPattern - RegExp(s) of workspace-relative path of packages to ignore mismatches for
+     */
+    constructor(path: string);
+    toMismatchSummary(): string;
+    getDependencies(): readonly Dependency[];
+    getDependency(name: string): Dependency;
+    get hasMismatchingDependencies(): boolean;
+}
+export {};
+//# sourceMappingURL=check-dep-versions.d.ts.map
@@ -0,0 +1,19 @@
+export declare enum DEPENDENCY_TYPE {
+    dependencies = "dependencies",
+    devDependencies = "devDependencies",
+    optionalDependencies = "optionalDependencies",
+    peerDependencies = "peerDependencies",
+    resolutions = "resolutions"
+}
+export type Options = {
+    depType?: readonly `${DEPENDENCY_TYPE}`[];
+    fix?: boolean;
+    ignoreDep?: readonly string[];
+    ignoreDepPattern?: readonly string[];
+    ignorePackage?: readonly string[];
+    ignorePackagePattern?: readonly string[];
+    ignorePath?: readonly string[];
+    ignorePathPattern?: readonly string[];
+};
+export declare function checkDeps(root: string): Promise<void>;
+//# sourceMappingURL=checkDeps.d.ts.map
@@ -0,0 +1,6 @@
+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
@@ -0,0 +1,16 @@
+export * from './checkDeps';
+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/loadHanzogui';
+export * from './extractor/watchHanzoguiConfig';
+export * from './extractor/createLogger';
+export * from './registerRequire';
+export { detectModuleFormat, clearFormatCache } from './extractor/detectModuleFormat';
+export * from './getPragmaOptions';
+//# sourceMappingURL=exports.d.ts.map
@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function accessSafe(obj: t.Expression, member: string): t.LogicalExpression;
+//# sourceMappingURL=accessSafe.d.ts.map
@@ -0,0 +1,5 @@
+import * as babelParser from '@babel/parser';
+import type * as t from '@babel/types';
+export declare const parserOptions: babelParser.ParserOptions;
+export declare function babelParse(code: string | Buffer, fileName?: string): t.File;
+//# sourceMappingURL=babelParse.d.ts.map
@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+import type { ClassNameObject } from '../types';
+type Builder = (objects: ClassNameObject[], extras?: string) => t.Expression | t.StringLiteral | null;
+export declare const buildClassName: Builder;
+export declare const buildClassNameLogic: Builder;
+export {};
+//# sourceMappingURL=buildClassName.d.ts.map
@@ -0,0 +1,121 @@
+import esbuild from 'esbuild';
+import type { HanzoguiPlatform } from '../types';
+export declare const esbuildLoaderConfig: {
+    readonly '.js': "jsx";
+    readonly '.png': "dataurl";
+    readonly '.jpg': "dataurl";
+    readonly '.jpeg': "dataurl";
+    readonly '.svg': "dataurl";
+    readonly '.gif': "dataurl";
+    readonly '.webp': "dataurl";
+    readonly '.woff2': "dataurl";
+    readonly '.woff': "dataurl";
+    readonly '.eot': "dataurl";
+    readonly '.otf': "dataurl";
+    readonly '.ttf': "dataurl";
+    readonly '.mp4': "file";
+    readonly '.mpeg4': "file";
+    readonly '.mov': "file";
+    readonly '.avif': "file";
+    readonly '.wmv': "file";
+    readonly '.webm': "file";
+    readonly '.wav': "file";
+    readonly '.aac': "file";
+    readonly '.ogg': "file";
+    readonly '.flac': "file";
+    readonly '.node': "empty";
+};
+export declare const esbuildIgnoreFilesRegex: RegExp;
+/**
+ * For internal loading of new files
+ */
+type Props = Omit<Partial<esbuild.BuildOptions>, 'entryPoints'> & {
+    outfile: string;
+    entryPoints: string[];
+    resolvePlatformSpecificEntries?: boolean;
+};
+export declare function esbundleHanzoguiConfig(props: Props, platform: HanzoguiPlatform, aliases?: Record<string, string>): Promise<esbuild.BuildResult<{
+    outfile: string;
+    bundle?: boolean;
+    splitting?: boolean;
+    preserveSymlinks?: boolean;
+    metafile?: boolean;
+    outdir?: string;
+    outbase?: string;
+    external?: string[];
+    packages?: "bundle" | "external";
+    alias?: Record<string, string>;
+    loader?: {
+        [ext: string]: esbuild.Loader;
+    };
+    resolveExtensions?: string[];
+    mainFields?: string[];
+    conditions?: string[];
+    write?: boolean;
+    allowOverwrite?: boolean;
+    tsconfig?: string;
+    outExtension?: {
+        [ext: string]: string;
+    };
+    publicPath?: string;
+    entryNames?: string;
+    chunkNames?: string;
+    assetNames?: string;
+    inject?: string[];
+    banner?: {
+        [type: string]: string;
+    };
+    footer?: {
+        [type: string]: string;
+    };
+    entryPoints?: (string | {
+        in: string;
+        out: string;
+    })[] | Record<string, string>;
+    stdin?: esbuild.StdinOptions;
+    plugins?: esbuild.Plugin[];
+    absWorkingDir?: string;
+    nodePaths?: string[];
+    sourcemap?: boolean | "linked" | "inline" | "external" | "both";
+    legalComments?: "none" | "inline" | "eof" | "linked" | "external";
+    sourceRoot?: string;
+    sourcesContent?: boolean;
+    format?: esbuild.Format;
+    globalName?: string;
+    target?: string | string[];
+    supported?: Record<string, boolean>;
+    platform?: esbuild.Platform;
+    mangleProps?: RegExp;
+    reserveProps?: RegExp;
+    mangleQuoted?: boolean;
+    mangleCache?: Record<string, string | false>;
+    drop?: esbuild.Drop[];
+    dropLabels?: string[];
+    minify?: boolean;
+    minifyWhitespace?: boolean;
+    minifyIdentifiers?: boolean;
+    minifySyntax?: boolean;
+    lineLimit?: number;
+    charset?: esbuild.Charset;
+    treeShaking?: boolean;
+    ignoreAnnotations?: boolean;
+    jsx?: "transform" | "preserve" | "automatic";
+    jsxFactory?: string;
+    jsxFragment?: string;
+    jsxImportSource?: string;
+    jsxDev?: boolean;
+    jsxSideEffects?: boolean;
+    define?: {
+        [key: string]: string;
+    };
+    pure?: string[];
+    keepNames?: boolean;
+    absPaths?: esbuild.AbsPaths[];
+    color?: boolean;
+    logLevel?: esbuild.LogLevel;
+    logLimit?: number;
+    logOverride?: Record<string, esbuild.LogLevel>;
+    tsconfigRaw?: string | esbuild.TsconfigRaw;
+}>>;
+export {};
+//# sourceMappingURL=bundle.d.ts.map
@@ -0,0 +1,49 @@
+import { type StaticConfig, type HanzoguiInternalConfig } from '@hanzogui/web';
+import esbuild from 'esbuild';
+import type { HanzoguiOptions } from '../types';
+type NameToPaths = {
+    [key: string]: Set<string>;
+};
+export type LoadedComponents = {
+    moduleName: string;
+    nameToInfo: Record<string, {
+        staticConfig: StaticConfig;
+    }>;
+};
+export type HanzoguiProjectInfo = {
+    components?: LoadedComponents[];
+    hanzoguiConfig?: HanzoguiInternalConfig | null;
+    nameToPaths?: NameToPaths;
+    cached?: boolean;
+};
+export declare const esbuildOptions: {
+    define: {
+        __DEV__: string;
+    };
+    target: string;
+    format: "cjs";
+    jsx: "automatic";
+    platform: "node";
+};
+export declare const esbuildOptionsWithPlugins: {
+    plugins: esbuild.Plugin[];
+    define: {
+        __DEV__: string;
+    };
+    target: string;
+    format: "cjs";
+    jsx: "automatic";
+    platform: "node";
+};
+export type BundledConfig = Exclude<Awaited<ReturnType<typeof bundleConfig>>, undefined>;
+export declare function hasBundledConfigChanged(): boolean;
+export declare const getLoadedConfig: () => HanzoguiInternalConfig | null;
+export declare function getBundledConfig(props: HanzoguiOptions, rebuild?: boolean): Promise<any>;
+export declare function bundleConfig(props: HanzoguiOptions): Promise<any>;
+export declare function writeHanzoguiCSS(outputCSS: string, config: HanzoguiInternalConfig): Promise<void>;
+export declare function loadComponents(props: HanzoguiOptions, forceExports?: boolean): Promise<LoadedComponents[]>;
+export declare function loadComponentsSync(props: HanzoguiOptions, forceExports?: boolean): LoadedComponents[];
+export declare function loadComponentsInner(props: HanzoguiOptions, forceExports?: boolean): Promise<null | LoadedComponents[]>;
+export declare function loadComponentsInnerSync(props: HanzoguiOptions, forceExports?: boolean): null | LoadedComponents[];
+export {};
+//# sourceMappingURL=bundleConfig.d.ts.map
@@ -0,0 +1,8 @@
+/**
+ * next - take objects:
+ *
+ * { _shorthand: 'postfix' }
+ *
+ */
+export declare function concatClassName(...args: any[]): any;
+//# sourceMappingURL=concatClassName.d.ts.map
@@ -0,0 +1,12 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { HanzoguiOptionsWithFileInfo } from '../types';
+export declare function createEvaluator({ props, staticNamespace, sourcePath, traversePath, shouldPrintDebug, }: {
+    props: HanzoguiOptionsWithFileInfo;
+    staticNamespace: Record<string, any>;
+    sourcePath?: string;
+    traversePath?: NodePath<t.JSXElement>;
+    shouldPrintDebug: boolean | 'verbose';
+}): (n: t.Node) => any;
+export declare function createSafeEvaluator(attemptEval: (n: t.Node) => any): (n: t.Node) => any;
+//# sourceMappingURL=createEvaluator.d.ts.map
@@ -0,0 +1,32 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { ExtractorOptions, ExtractorParseProps, HanzoguiOptions } from '../types';
+import type { HanzoguiProjectInfo } from './bundleConfig';
+import { cleanupBeforeExit } from './getStaticBindingsForScope';
+export type Extractor = ReturnType<typeof createExtractor>;
+type FileOrPath = NodePath<t.Program> | t.File;
+export declare function createExtractor({ logger, platform }?: ExtractorOptions): {
+    options: {
+        logger: import("../types").Logger;
+    };
+    cleanupBeforeExit: typeof cleanupBeforeExit;
+    loadHanzogui: (props: HanzoguiOptions) => Promise<HanzoguiProjectInfo | null>;
+    loadHanzoguiSync: (props: HanzoguiOptions) => HanzoguiProjectInfo | null;
+    getHanzogui(): import("@hanzogui/web").HanzoguiInternalConfig | null | undefined;
+    parseSync: (f: FileOrPath, props: ExtractorParseProps) => {
+        styled: number;
+        flattened: number;
+        optimized: number;
+        modified: number;
+        found: number;
+    } | null;
+    parse: (f: FileOrPath, props: ExtractorParseProps) => Promise<{
+        styled: number;
+        flattened: number;
+        optimized: number;
+        modified: number;
+        found: number;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=createExtractor.d.ts.map
@@ -0,0 +1,3 @@
+import type { HanzoguiOptions } from '../types';
+export declare function createLogger(sourcePath: string, options: HanzoguiOptions): (res: any) => void;
+//# sourceMappingURL=createLogger.d.ts.map
@@ -0,0 +1,5 @@
+type ModuleFormat = 'cjs' | 'esm';
+export declare function detectModuleFormat(filePath: string): ModuleFormat;
+export declare function clearFormatCache(): void;
+export {};
+//# sourceMappingURL=detectModuleFormat.d.ts.map
@@ -0,0 +1,4 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function ensureImportingConcat(path: NodePath<t.Program>): void;
+//# sourceMappingURL=ensureImportingConcat.d.ts.map
@@ -0,0 +1,3 @@
+export declare class BailOptimizationError extends Error {
+}
+//# sourceMappingURL=errors.d.ts.map
@@ -0,0 +1,18 @@
+/**
+ * alias plugin
+ * @description
+ * config example:
+ * ```
+ * {
+ *   '@lib': '/some/absolute/path'
+ * }
+ * ```
+ * then `import { something } from '@hanzogui/core'` will be transformed to
+ * `import { something } from '/some/absolute/path/xxx'`
+ * @param {object} config
+ */
+export declare const esbuildAliasPlugin: (config: any) => {
+    name: string;
+    setup(build: any): void;
+};
+//# sourceMappingURL=esbuildAliasPlugin.d.ts.map
@@ -0,0 +1,11 @@
+import type { Plugin } from 'esbuild';
+interface Tsconfig {
+    compilerOptions?: {
+        baseUrl?: string;
+        paths?: Record<string, string[]>;
+    };
+}
+export declare function TsconfigPathsPlugin(): Plugin;
+export declare function loadCompilerOptionsFromTsconfig(tsconfig?: Tsconfig | string): import("typescript").CompilerOptions;
+export {};
+//# sourceMappingURL=esbuildTsconfigPaths.d.ts.map
@@ -0,0 +1,3 @@
+import * as t from '@babel/types';
+export declare function evaluateAstNode(exprNode: t.Node | undefined | null, evalFn?: (node: t.Node) => any, shouldPrintDebug?: boolean | 'verbose'): any;
+//# sourceMappingURL=evaluateAstNode.d.ts.map
@@ -0,0 +1,28 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { ExtractedAttr, HanzoguiOptionsWithFileInfo, Ternary } from '../types';
+export declare function isPresent<T extends object>(input: null | void | undefined | T): input is T;
+export declare function isSimpleSpread(node: t.JSXSpreadAttribute): boolean;
+export declare const attrStr: (attr?: ExtractedAttr) => string | t.JSXIdentifier;
+export declare const objToStr: (obj: any, spacer?: string) => any;
+export declare const ternaryStr: (x: Ternary) => string;
+export declare function findComponentName(scope: any): string | undefined;
+export declare function isValidThemeHook(props: HanzoguiOptionsWithFileInfo, jsxPath: NodePath<t.JSXElement>, n: t.MemberExpression, sourcePath?: string): boolean;
+export declare const isInsideComponentPackage: (props: HanzoguiOptionsWithFileInfo, moduleName: string) => any;
+export declare const isComponentPackage: (props: HanzoguiOptionsWithFileInfo, srcName: string) => any;
+export declare function getValidComponent(props: HanzoguiOptionsWithFileInfo, moduleName: string, componentName: string): false | {
+    staticConfig: import("@hanzogui/web").StaticConfig;
+} | null;
+export declare const isValidModule: (props: HanzoguiOptionsWithFileInfo, moduleName: string) => {
+    isLocal: boolean;
+    isValid: any;
+};
+export declare const getValidImport: (props: HanzoguiOptionsWithFileInfo, moduleName: string, componentName?: string) => {
+    staticConfig: import("@hanzogui/web").StaticConfig;
+} | null;
+export declare const isValidImport: (props: HanzoguiOptionsWithFileInfo, moduleName: string, componentName?: string) => any;
+export declare const getValidComponentsPaths: {
+    (...args: any[]): any;
+    cache: Map<any, any>;
+};
+//# sourceMappingURL=extractHelpers.d.ts.map
@@ -0,0 +1,11 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { HanzoguiInternalConfig } from '@hanzogui/core';
+import * as core from '@hanzogui/core';
+import type { HanzoguiOptionsWithFileInfo, Ternary } from '../types';
+export declare function extractMediaStyle(props: HanzoguiOptionsWithFileInfo, ternary: Ternary, jsxPath: NodePath<t.JSXElement>, hanzoguiConfig: HanzoguiInternalConfig, sourcePath: string, importance?: number, shouldPrintDebug?: boolean | 'verbose'): {
+    mediaStyles: core.StyleObject[];
+    ternaryWithoutMedia: Ternary | null;
+} | null;
+export declare function isValidMediaCall(props: HanzoguiOptionsWithFileInfo, jsxPath: NodePath<t.JSXElement>, init: t.Expression, sourcePath: string): boolean;
+//# sourceMappingURL=extractMediaStyle.d.ts.map
@@ -0,0 +1,25 @@
+import * as t from '@babel/types';
+import type { HanzoguiOptions } from '../types';
+import type { Extractor } from './createExtractor';
+export type ExtractedResponse = {
+    js: string | Buffer;
+    styles: string;
+    stylesPath?: string;
+    ast: t.File;
+    map: any;
+    stats: {
+        styled: number;
+        flattened: number;
+        optimized: number;
+        found: number;
+    };
+};
+export type ExtractToClassNamesProps = {
+    extractor: Extractor;
+    source: string | Buffer;
+    sourcePath?: string;
+    options: HanzoguiOptions;
+    shouldPrintDebug: boolean | 'verbose';
+};
+export declare function extractToClassNames({ extractor, source, sourcePath, options, shouldPrintDebug, }: ExtractToClassNamesProps): Promise<ExtractedResponse | null>;
+//# sourceMappingURL=extractToClassNames.d.ts.map
@@ -0,0 +1,13 @@
+import { type BabelFileResult } from '@babel/core';
+import type { HanzoguiOptions } from '../types';
+export declare function extractToNative(sourceFileName: string, sourceCode: string, options: HanzoguiOptions): BabelFileResult;
+export declare function getBabelPlugin(): any;
+export declare function getBabelParseDefinition(options: HanzoguiOptions): {
+    name: string;
+    visitor: {
+        Program: {
+            enter(this: any, root: any): void;
+        };
+    };
+};
+//# sourceMappingURL=extractToNative.d.ts.map
@@ -0,0 +1,4 @@
+import type { NodePath } from '@babel/traverse';
+import type * as t from '@babel/types';
+export declare function findTopmostFunction(jsxPath: NodePath<t.JSXElement>): NodePath<any> | null;
+//# sourceMappingURL=findTopmostFunction.d.ts.map
@@ -0,0 +1,5 @@
+declare module '@babel/types' {
+    function toIdentifier(input: string): string;
+}
+export declare function generateUid(scope: any, name: string): string;
+//# sourceMappingURL=generatedUid.d.ts.map
@@ -0,0 +1,3 @@
+import type { HanzoguiOptions } from '../types';
+export declare function getHanzoguiConfigPathFromOptionsConfig(config: NonNullable<HanzoguiOptions['config']>): string;
+//# sourceMappingURL=getHanzoguiConfigPathFromOptionsConfig.d.ts.map
@@ -0,0 +1,3 @@
+import type { HanzoguiOptions } from '../types';
+export declare function getPrefixLogs(options?: HanzoguiOptions): string;
+//# sourceMappingURL=getPrefixLogs.d.ts.map
@@ -0,0 +1,19 @@
+import * as t from '@babel/types';
+/**
+ * getPropValueFromAttributes gets a prop by name from a list of attributes and accounts for potential spread operators.
+ * Here's an example. Given this component:
+ * ```
+ * <Block coolProp="wow" {...spread1} neatProp="ok" {...spread2} />```
+ * getPropValueFromAttributes will return the following:
+ * - for propName `coolProp`:
+ *   ```
+ * accessSafe(spread1, 'coolProp') || accessSafe(spread2, 'coolProp') || 'wow'```
+ * - for propName `neatProp`:
+ *   ```
+ * accessSafe(spread2, 'neatProp') || 'ok'```
+ * - for propName `notPresent`: `null`
+ *
+ * The returned value should (obviously) be placed after spread operators.
+ */
+export declare function getPropValueFromAttributes(propName: string, attrs: (t.JSXAttribute | t.JSXSpreadAttribute)[]): t.Expression | null;
+//# sourceMappingURL=getPropValueFromAttributes.d.ts.map
@@ -0,0 +1,16 @@
+import * as t from '@babel/types';
+export interface SourceModule {
+    sourceModule?: string;
+    imported?: string;
+    local?: string;
+    destructured?: boolean;
+    usesImportSyntax: boolean;
+}
+export declare function getSourceModule(itemName: string, itemBinding: {
+    constant?: boolean;
+    path: {
+        node: t.Node;
+        parent: any;
+    };
+}): SourceModule | null;
+//# sourceMappingURL=getSourceModule.d.ts.map
@@ -0,0 +1,5 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function cleanupBeforeExit(): void;
+export declare function getStaticBindingsForScope(scope: NodePath<t.JSXElement>['scope'], whitelist: string[] | undefined, sourcePath: string, bindingCache: Record<string, string | null>, shouldPrintDebug: boolean | 'verbose'): Promise<Record<string, any>>;
+//# sourceMappingURL=getStaticBindingsForScope.d.ts.map
@@ -0,0 +1,2 @@
+export declare function hasTopLevelAwait(contents: string, fileName?: string): boolean;
+//# sourceMappingURL=hasTopLevelAwait.d.ts.map
@@ -0,0 +1,6 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare function hoistClassNames(path: NodePath<t.JSXElement>, existing: {
+    [key: string]: t.Identifier;
+}, expr: t.Expression): any;
+//# sourceMappingURL=hoistClassNames.d.ts.map
@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+export declare function literalToAst(literal: any): t.Expression;
+export declare function astToLiteral(node: any): any;
+//# sourceMappingURL=literalToAst.d.ts.map
@@ -0,0 +1 @@
+//# sourceMappingURL=loadFile.d.ts.map
@@ -0,0 +1,22 @@
+import type { CLIResolvedOptions, CLIUserOptions, HanzoguiOptions } from '@hanzogui/types';
+import { type HanzoguiProjectInfo } from './bundleConfig';
+export declare function loadHanzogui(propsIn: Partial<HanzoguiOptions>): Promise<HanzoguiProjectInfo | null>;
+export declare const generateThemesAndLog: (options: HanzoguiOptions, force?: boolean) => Promise<void>;
+/**
+ * Load hanzogui.build.ts config using esbuild-wasm transform
+ * Uses WASM to avoid native esbuild service lifecycle issues (EPIPE errors)
+ */
+export declare function loadHanzoguiBuildConfigAsync(hanzoguiOptions: Partial<HanzoguiOptions> | undefined): Promise<HanzoguiOptions>;
+/**
+ * @deprecated Use loadHanzoguiBuildConfigAsync instead to avoid EPIPE errors
+ */
+export declare function loadHanzoguiBuildConfigSync(hanzoguiOptions: Partial<HanzoguiOptions> | undefined): HanzoguiOptions;
+export declare function loadHanzoguiSync({ forceExports, cacheKey, ...propsIn }: Partial<HanzoguiOptions> & {
+    forceExports?: boolean;
+    cacheKey?: string;
+}): HanzoguiProjectInfo;
+export declare function getOptions({ root, tsconfigPath, hanzoguiOptions, host, debug, }?: Partial<CLIUserOptions>): Promise<CLIResolvedOptions>;
+export declare function resolveWebOrNativeSpecificEntry(entry: string): string;
+export type { HanzoguiProjectInfo };
+export declare function esbuildWatchFiles(entry: string, onChanged: () => void): Promise<() => void>;
+//# sourceMappingURL=loadHanzogui.d.ts.map
@@ -0,0 +1,2 @@
+export declare const logLines: (str: string, singleLine?: boolean) => string;
+//# sourceMappingURL=logLines.d.ts.map
@@ -0,0 +1,3 @@
+import type { Ternary } from '../types';
+export declare function normalizeTernaries(ternaries: Ternary[]): Ternary[];
+//# sourceMappingURL=normalizeTernaries.d.ts.map
@@ -0,0 +1,4 @@
+export declare function setPropsToFontFamily(props: any, ff: string): void;
+export declare function getFontFamilyNameFromProps(props: any): string | undefined;
+export declare function forwardFontFamilyName(prev: any, next: any, fallback?: string): void;
+//# sourceMappingURL=propsToFontFamilyCache.d.ts.map
@@ -0,0 +1,9 @@
+import type { HanzoguiOptions } from '@hanzogui/types';
+import type { BundledConfig } from './bundleConfig';
+/**
+ * Sort of a super-set of bundleConfig(), this code needs some refactoring ideally
+ */
+export declare function regenerateConfig(hanzoguiOptions: HanzoguiOptions, configIn?: BundledConfig | null, rebuild?: boolean): Promise<void>;
+export declare function regenerateConfigSync(_hanzoguiOptions: HanzoguiOptions, config: BundledConfig): void;
+export declare function generateHanzoguiThemes(hanzoguiOptions: HanzoguiOptions, force?: boolean): Promise<boolean | undefined>;
+//# sourceMappingURL=regenerateConfig.d.ts.map
@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/traverse';
+export declare function removeUnusedHooks(compFn: NodePath<any>, shouldPrintDebug: boolean | 'verbose'): void;
+//# sourceMappingURL=removeUnusedHooks.d.ts.map
@@ -0,0 +1,5 @@
+export declare const timer: () => {
+    mark: (name: string, print?: boolean) => void;
+    done: (print?: boolean) => void;
+};
+//# sourceMappingURL=timer.d.ts.map
@@ -0,0 +1,52 @@
+export declare const validHTMLAttributes: {
+    fill: boolean;
+    stroke: boolean;
+    autocomplete: boolean;
+    style: boolean;
+    tabIndex: boolean;
+    contenteditable: boolean;
+    crossorigin: boolean;
+    dir: boolean;
+    draggable: boolean;
+    enctype: boolean;
+    formenctype: boolean;
+    formmethod: boolean;
+    formtarget: boolean;
+    inputmode: boolean;
+    kind: boolean;
+    link: boolean;
+    method: boolean;
+    preload: boolean;
+    referrerpolicy: boolean;
+    rel: boolean;
+    rev: boolean;
+    role: boolean;
+    sandbox: boolean;
+    shape: boolean;
+    spellcheck: boolean;
+    target: boolean;
+    translate: boolean;
+    type: boolean;
+    wrap: boolean;
+    'aria-autocomplete': boolean;
+    'aria-busy': boolean;
+    'aria-checked': boolean;
+    'aria-current': boolean;
+    'aria-disabled': boolean;
+    'aria-expanded': boolean;
+    'aria-haspopup': boolean;
+    'aria-hidden': boolean;
+    'aria-invalid': boolean;
+    'aria-polite': boolean;
+    'aria-modal': boolean;
+    'aria-multiline': boolean;
+    'aria-multiselectable': boolean;
+    'aria-orientation': boolean;
+    'aria-pressed': boolean;
+    'aria-readonly': boolean;
+    'aria-relevant': boolean;
+    'aria-required': boolean;
+    'aria-selected': boolean;
+    'aria-sort': boolean;
+};
+//# sourceMappingURL=validHTMLAttributes.d.ts.map
@@ -0,0 +1,5 @@
+import type { HanzoguiOptions } from '@hanzogui/types';
+export declare function watchHanzoguiConfig(hanzoguiOptions: HanzoguiOptions): Promise<{
+    dispose(): void;
+} | undefined>;
+//# sourceMappingURL=watchHanzoguiConfig.d.ts.map
@@ -0,0 +1,8 @@
+export declare function getPragmaOptions({ source, path }: {
+    source: string;
+    path: string;
+}): {
+    shouldPrintDebug: boolean | "verbose";
+    shouldDisable: boolean;
+};
+//# sourceMappingURL=getPragmaOptions.d.ts.map
@@ -0,0 +1,8 @@
+export declare function memoize(func?: Function, resolver?: any): {
+    (...args: any[]): any;
+    cache: Map<any, any>;
+};
+export declare namespace memoize {
+    var Cache: MapConstructor;
+}
+//# sourceMappingURL=memoize.d.ts.map
@@ -0,0 +1,3 @@
+import type { HanzoguiPlatform } from '../types';
+export declare function requireHanzoguiCore(platform: HanzoguiPlatform, ogRequire?: Function): typeof import('@hanzogui/core');
+//# sourceMappingURL=requireHanzoguiCore.d.ts.map
@@ -0,0 +1,4 @@
+import * as Static1 from './exports';
+export * from './exports';
+export default Static1;
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,10 @@
+import type { HanzoguiPlatform } from './types';
+export declare const getNameToPaths: () => {};
+export declare function setRequireResult(name: string, result: any): void;
+export declare function registerRequire(platform: HanzoguiPlatform, { proxyWormImports }?: {
+    proxyWormImports: boolean;
+}): {
+    hanzoguiRequire: (this: any, path: string) => any;
+    unregister: () => void;
+};
+//# sourceMappingURL=registerRequire.d.ts.map
@@ -0,0 +1,3 @@
+import type { HanzoguiOptions } from './types';
+export declare function startServer(options: HanzoguiOptions): Promise<void>;
+//# sourceMappingURL=server.d.ts.map
@@ -0,0 +1 @@
+//# sourceMappingURL=setup.d.ts.map
@@ -0,0 +1,92 @@
+import type { NodePath } from '@babel/traverse';
+import type * as t from '@babel/types';
+import type { PseudoStyles, StaticConfig, HanzoguiConfig } from '@hanzogui/core';
+import type { StyleObject } from '@hanzogui/helpers';
+import type { HanzoguiOptions } from '@hanzogui/types';
+import type { ViewStyle } from 'react-native';
+import type { LoadedComponents } from './extractor/bundleConfig';
+export type HanzoguiPlatform = 'native' | 'web';
+export type { HanzoguiOptions, HanzoguiBuildOptions } from '@hanzogui/types';
+export type { StyleObject } from '@hanzogui/helpers';
+export type ClassNameObject = t.StringLiteral | t.Expression;
+export interface CacheObject {
+    [key: string]: any;
+}
+export interface LogOptions {
+    clear?: boolean;
+    timestamp?: boolean;
+    error?: Error | null;
+}
+export interface Logger {
+    info(msg: string, options?: LogOptions): void;
+    warn(msg: string, options?: LogOptions): void;
+    error(msg: string, options?: LogOptions): void;
+}
+export type ExtractorOptions = {
+    logger?: Logger;
+    platform?: HanzoguiPlatform;
+};
+export type ExtractedAttrAttr = {
+    type: 'attr';
+    value: t.JSXAttribute | t.JSXSpreadAttribute;
+    extraClassNames?: string;
+};
+export type ExtractedAttrStyle = {
+    type: 'style';
+    value: ViewStyle & PseudoStyles;
+    attr?: t.JSXAttribute | t.JSXSpreadAttribute;
+    name?: string;
+    extraClassNames?: string;
+};
+export type ExtractedTernaryAttr = {
+    type: 'ternary';
+    value: Ternary;
+};
+export type ExtractedAttr = ExtractedAttrAttr | ExtractedTernaryAttr | ExtractedAttrStyle;
+export type ExtractTagProps = {
+    parserProps: HanzoguiOptionsWithFileInfo;
+    attrs: ExtractedAttr[];
+    node: t.JSXOpeningElement;
+    attemptEval: (exprNode: t.Node, evalFn?: ((node: t.Node) => any) | undefined) => any;
+    flatNodeName?: string;
+    jsxPath: NodePath<t.JSXElement>;
+    programPath: NodePath<t.Program>;
+    originalNodeName: string;
+    lineNumbers: string;
+    filePath: string;
+    completeProps: Record<string, any>;
+    staticConfig: StaticConfig;
+    config: HanzoguiConfig;
+};
+export type HanzoguiOptionsWithFileInfo = HanzoguiOptions & {
+    sourcePath?: string;
+    allLoadedComponents: LoadedComponents[];
+};
+export type ExtractorParseProps = Omit<HanzoguiOptionsWithFileInfo, 'allLoadedComponents'> & {
+    platform: HanzoguiPlatform;
+    shouldPrintDebug?: boolean | 'verbose';
+    onExtractTag: (props: ExtractTagProps) => void;
+    getFlattenedNode?: (props: {
+        isTextView: boolean;
+        tag: string;
+    }) => string;
+    extractStyledDefinitions?: boolean;
+    onStyledDefinitionRule?: (identifier: string, rules: string[]) => void;
+};
+export interface Ternary {
+    test: t.Expression;
+    remove: Function;
+    consequent: object | null;
+    alternate: object | null;
+    fontFamily?: string;
+    inlineMediaQuery?: string;
+}
+export type ClassNameToStyleObj = {
+    [key: string]: StyleObject;
+};
+export interface PluginContext {
+    write: (path: string, rules: {
+        [key: string]: string;
+    }) => any;
+}
+//# sourceMappingURL=types.d.ts.map
@@ -0,0 +1,46 @@
+/**
+ * Worker thread implementation for Hanzogui extraction
+ * Used by both piscina (async) and synckit (sync for babel)
+ */
+import type { BabelFileResult } from '@babel/core';
+import type { ExtractedResponse } from './extractor/extractToClassNames';
+import type { HanzoguiOptions } from './types';
+export interface ExtractToClassNamesTask {
+    type: 'extractToClassNames';
+    source: string;
+    sourcePath: string;
+    options: HanzoguiOptions;
+    shouldPrintDebug: boolean | 'verbose';
+}
+export interface ExtractToNativeTask {
+    type: 'extractToNative';
+    sourceFileName: string;
+    sourceCode: string;
+    options: HanzoguiOptions;
+}
+export interface ClearCacheTask {
+    type: 'clearCache';
+}
+export type WorkerTask = ExtractToClassNamesTask | ExtractToNativeTask | ClearCacheTask;
+export type WorkerResult = {
+    success: true;
+    data: ExtractedResponse | null;
+} | {
+    success: true;
+    data: BabelFileResult;
+} | {
+    success: false;
+    error: string;
+    stack?: string;
+};
+/**
+ * Main worker function that handles both extraction types
+ * This is called by piscina for async usage
+ */
+export declare function runTask(task: WorkerTask): Promise<WorkerResult>;
+/**
+ * For synckit compatibility - exports the runTask as default
+ * Synckit will call this function synchronously using worker threads
+ */
+export default runTask;
+//# sourceMappingURL=worker.d.ts.map
@@ -0,0 +1,2 @@
+export declare const extensions: string[];
+//# sourceMappingURL=extensions.d.ts.map
@@ -0,0 +1,2 @@
+export * from './plugin';
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,15 @@
+import type { HanzoguiOptions } from '@hanzogui/types';
+export declare function getHanzoguiOptions(): HanzoguiOptions | null;
+export declare function getLoadPromise(): Promise<HanzoguiOptions> | null;
+/**
+ * Load just the hanzogui.build.ts config (lightweight)
+ * This doesn't bundle the full hanzogui config - call ensureFullConfigLoaded() for that
+ */
+export declare function loadHanzoguiBuildConfig(optionsIn?: Partial<HanzoguiOptions>): Promise<HanzoguiOptions>;
+/**
+ * Ensure the full hanzogui config is loaded (heavy - bundles config + components)
+ * Call this lazily when transform/extraction is actually needed
+ */
+export declare function ensureFullConfigLoaded(): Promise<void>;
+export declare function cleanup(): Promise<void>;
+//# sourceMappingURL=loadHanzogui.d.ts.map
@@ -0,0 +1,22 @@
+import type { HanzoguiOptions } from '@hanzogui/static-worker';
+import type { PluginOption } from 'vite';
+type AliasOptions = {
+    /** use @hanzogui/react-native-web-lite, 'without-animated' for smaller bundle */
+    rnwLite?: boolean | 'without-animated';
+    /** alias react-native-svg to @hanzogui/react-native-svg */
+    svg?: boolean;
+};
+type AliasEntry = {
+    find: string | RegExp;
+    replacement: string;
+};
+/**
+ * returns vite-compatible aliases for hanzogui
+ * use this when you need control over alias ordering in your config
+ */
+export declare function hanzoguiAliases(options?: AliasOptions): AliasEntry[];
+export declare function hanzoguiPlugin({ disableResolveConfig, ...hanzoguiOptionsIn }?: HanzoguiOptions & {
+    disableResolveConfig?: boolean;
+}): PluginOption;
+export {};
+//# sourceMappingURL=plugin.d.ts.map
@@ -0,0 +1,4 @@
+export { normalizeTransition, getAnimationForProperty, hasAnimation, getAnimatedProperties, getEffectiveAnimation, getAnimationConfigsForKeys } from "./normalizeTransition";
+export type { AnimationConfig, NormalizedTransition, TransitionPropInput } from "./types";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,54 @@
+import type { AnimationConfig, NormalizedTransition, TransitionPropInput } from "./types";
+/**
+* Normalizes the various transition prop formats into a consistent structure.
+*
+* Supported input formats:
+* - String: "bouncy" -> { default: "bouncy", enter: null, exit: null, properties: {} }
+* - Object: { x: 'quick', default: 'slow' } -> { default: "slow", enter: null, exit: null, properties: { x: "quick" } }
+* - Object with enter/exit: { enter: 'bouncy', exit: 'quick' } -> { default: null, enter: "bouncy", exit: "quick", properties: {} }
+* - Array: ['bouncy', { delay: 100, x: 'quick' }] -> { default: "bouncy", enter: null, exit: null, delay: 100, properties: { x: "quick" } }
+*
+* @param transition - The transition prop value in any supported format
+* @returns Normalized transition object with consistent structure
+*/
+export declare function normalizeTransition(transition: TransitionPropInput): NormalizedTransition;
+/**
+* Gets the animation key for a specific property from a normalized transition.
+* Falls back to the default animation if no property-specific one is defined.
+*
+* @param normalized - The normalized transition object
+* @param property - The property name to get animation for (e.g., 'x', 'opacity')
+* @returns The animation key/config or null if none defined
+*/
+export declare function getAnimationForProperty(normalized: NormalizedTransition, property: string): string | AnimationConfig | null;
+/**
+* Checks if the normalized transition has any animations defined.
+*/
+export declare function hasAnimation(normalized: NormalizedTransition): boolean;
+/**
+* Gets all property names that have specific animations defined.
+* Does not include 'default' in the list.
+*/
+export declare function getAnimatedProperties(normalized: NormalizedTransition): string[];
+/**
+* Gets the effective animation key based on the current animation state.
+* Priority: enter/exit specific > default > null
+*
+* @param normalized - The normalized transition object
+* @param state - The animation state: 'enter', 'exit', or 'default'
+* @returns The effective animation key or null
+*/
+export declare function getEffectiveAnimation(normalized: NormalizedTransition, state: "enter" | "exit" | "default"): string | null;
+/**
+* Gets the resolved animation config for each key, looking up in animations config.
+* Useful for calculating max duration across all animated properties.
+*
+* @param normalized - The normalized transition object
+* @param animations - The animations config object (driver-specific format)
+* @param keys - Property keys to get animations for
+* @param defaultAnimation - The default animation value to fall back to
+* @returns Map of key -> resolved animation config (or null if not found)
+*/
+export declare function getAnimationConfigsForKeys<T>(normalized: NormalizedTransition, animations: Record<string, T>, keys: string[], defaultAnimation: T | null): Map<string, T | null>;
+
+//# sourceMappingURL=normalizeTransition.d.ts.map
@@ -0,0 +1,56 @@
+/**
+* Animation configuration that can include additional properties
+* like delay, duration, stiffness, damping, etc.
+*/
+export type AnimationConfig = {
+	type?: string;
+	[key: string]: any;
+};
+/**
+* Input format for the transition prop - supports multiple syntaxes:
+*
+* 1. String: "bouncy"
+* 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }
+* 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]
+* 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }
+*
+* Note: Uses `any` to be compatible with the TransitionProp type from @hanzogui/web
+* which has more complex union types.
+*/
+export type TransitionPropInput = any;
+/**
+* Spring configuration parameters that can override preset defaults.
+* These are the common parameters across animation drivers.
+*/
+export type SpringConfig = {
+	stiffness?: number;
+	damping?: number;
+	mass?: number;
+	tension?: number;
+	friction?: number;
+	velocity?: number;
+	overshootClamping?: boolean;
+	duration?: number;
+	bounciness?: number;
+	speed?: number;
+};
+/**
+* Normalized output format that all animation drivers consume.
+* Provides a consistent structure regardless of input format.
+*/
+export type NormalizedTransition = {
+	/** Default animation key for properties not explicitly listed */
+	default: string | null;
+	/** Animation key to use during enter transitions (mount) */
+	enter: string | null;
+	/** Animation key to use during exit transitions (unmount) */
+	exit: string | null;
+	/** Global delay in ms */
+	delay: number | undefined;
+	/** Per-property animation configs: propertyName -> animationKey or config */
+	properties: Record<string, string | AnimationConfig>;
+	/** Global spring config overrides that merge with the preset defaults */
+	config?: SpringConfig;
+};
+
+//# sourceMappingURL=types.d.ts.map
@@ -0,0 +1,4 @@
+import type { AnimationDriver } from "@hanzogui/web";
+export declare function createAnimations<A extends object>(animations: A): AnimationDriver<A>;
+
+//# sourceMappingURL=createAnimations.d.ts.map
@@ -0,0 +1,3 @@
+export * from "./createAnimations";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,5 @@
+import { type AnimationDriver } from "@hanzogui/core";
+import type { TransitionConfig } from "moti";
+export declare function createAnimations<A extends Record<string, TransitionConfig>>(animations: A): AnimationDriver<A>;
+
+//# sourceMappingURL=createAnimations.d.ts.map
@@ -0,0 +1,4 @@
+import "./polyfill";
+export * from "./createAnimations";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=polyfill.d.ts.map
@@ -0,0 +1,8 @@
+import { type AnimationDriver } from "@hanzogui/web";
+import { type ValueTransition } from "motion/react";
+type AnimationConfig = ValueTransition;
+export declare function createAnimations<A extends Record<string, AnimationConfig>>(animations: A): AnimationDriver<A>;
+export declare const disableAnimationProps: Set<string>;
+export {};
+
+//# sourceMappingURL=createAnimations.d.ts.map
@@ -0,0 +1,4 @@
+import "./polyfill";
+export * from "./createAnimations";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,4 @@
+import type { AnimationDriver } from "@hanzogui/web";
+export declare function createAnimations<A extends Record<string, any>>(_animations: A): AnimationDriver<A>;
+
+//# sourceMappingURL=index.native.d.ts.map
@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=polyfill.d.ts.map
@@ -0,0 +1,24 @@
+import type { AnimationDriver, UniversalAnimatedNumber, UseAnimatedNumberReaction, UseAnimatedNumberStyle } from "@hanzogui/web";
+import { Animated, type Text, type View } from "react-native";
+type AnimationsConfig<A extends object = any> = { [Key in keyof A] : AnimationConfig };
+type SpringConfig = {
+	type?: "spring";
+} & Partial<Pick<Animated.SpringAnimationConfig, "delay" | "bounciness" | "damping" | "friction" | "mass" | "overshootClamping" | "speed" | "stiffness" | "tension" | "velocity">>;
+type TimingConfig = {
+	type: "timing";
+} & Partial<Animated.TimingAnimationConfig>;
+type AnimationConfig = SpringConfig | TimingConfig;
+type CreateAnimationsOptions = {
+	useNativeDriver?: boolean;
+};
+export declare const AnimatedView: Animated.AnimatedComponent<typeof View>;
+export declare const AnimatedText: Animated.AnimatedComponent<typeof Text>;
+export declare function useAnimatedNumber(initial: number): UniversalAnimatedNumber<Animated.Value>;
+type RNAnimatedNum = UniversalAnimatedNumber<Animated.Value>;
+export declare const useAnimatedNumberReaction: UseAnimatedNumberReaction<RNAnimatedNum>;
+export declare const useAnimatedNumberStyle: UseAnimatedNumberStyle<RNAnimatedNum>;
+export declare const useAnimatedNumbersStyle: (vals: RNAnimatedNum[], getStyle: (...currentValues: any[]) => any) => any;
+export declare function createAnimations<A extends AnimationsConfig>(animations: A, options?: CreateAnimationsOptions): AnimationDriver<A>;
+export {};
+
+//# sourceMappingURL=createAnimations.d.ts.map
@@ -0,0 +1,4 @@
+import "./polyfill";
+export * from "./createAnimations";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=polyfill.d.ts.map
@@ -0,0 +1,40 @@
+import { type AnimationDriver } from "@hanzogui/core";
+import { type WithSpringConfig, type WithTimingConfig } from "react-native-reanimated";
+/** Spring animation configuration */
+type SpringConfig = {
+	type?: "spring";
+	delay?: number;
+} & Partial<WithSpringConfig>;
+/** Timing animation configuration */
+type TimingConfig = {
+	type: "timing";
+	delay?: number;
+} & Partial<WithTimingConfig>;
+/** Combined animation configuration type */
+export type TransitionConfig = SpringConfig | TimingConfig;
+/** Options for createAnimations (reserved for future use) */
+export type CreateAnimationsOptions = {};
+/**
+* Create a Reanimated-based animation driver for Hanzogui.
+*
+* This is a native Reanimated implementation without Moti dependency.
+* It provides smooth spring and timing animations with full support for:
+* - Per-property animation configurations
+* - Exit animations with proper completion callbacks
+* - Dynamic theme value resolution
+* - Transform property animations
+* - avoidReRenders optimization for hover/press/focus states
+*
+* @example
+* ```tsx
+* const animations = createAnimations({
+*   fast: { type: 'spring', damping: 20, stiffness: 250 },
+*   slow: { type: 'timing', duration: 500 },
+* })
+*
+* ```
+*/
+export declare function createAnimations<A extends Record<string, TransitionConfig>>(animationsConfig: A): AnimationDriver<A>;
+export {};
+
+//# sourceMappingURL=createAnimations.d.ts.map
@@ -0,0 +1,3 @@
+export * from "./createAnimations";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,3 @@
+export declare function assertIsError(error: unknown): asserts error is Error;
+
+//# sourceMappingURL=assertions.d.ts.map
@@ -0,0 +1,3 @@
+export * from "./assertions";
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,18 @@
+import type { FontLineHeightTokens, FontSizeTokens, SizeTokens, SpaceTokens } from "@hanzogui/core";
+/**
+* Simple calc() that handles native + web
+*   on web: outputs a calc() string
+*   on native: outputs a plain number
+*/
+export type CalcVal = string | number | SizeTokens | SpaceTokens | FontSizeTokens | FontLineHeightTokens;
+declare const operators: {
+	"+": (a: number, b: number) => number;
+	"-": (a: number, b: number) => number;
+	"/": (a: number, b: number) => number;
+	"*": (a: number, b: number) => number;
+};
+type Operator = keyof typeof operators;
+export declare const calc: (...valuesAndOperators: (CalcVal | Operator)[]) => string | number;
+export {};
+
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,3 @@
+export declare const generatedPackageTypes: readonly ["font", "icon"];
+export declare const installGeneratedPackage: (type: string, packagesPath?: string) => Promise<void>;
+//# sourceMappingURL=add.d.ts.map
@@ -0,0 +1,34 @@
+import type { CLIResolvedOptions } from '@hanzogui/types';
+export type BuildStats = {
+    filesProcessed: number;
+    optimized: number;
+    flattened: number;
+    styled: number;
+    found: number;
+};
+export type TrackedFile = {
+    path: string;
+    hardlinkPath: string;
+    mtimeAfterWrite: number;
+};
+export type BuildResult = {
+    stats: BuildStats;
+    trackedFiles: TrackedFile[];
+};
+/**
+ * Inserts a CSS import statement into JS code, placing it after any
+ * 'use client' or 'use server' directives at the top of the file.
+ */
+export declare function insertCssImport(jsContent: string, cssImport: string): string;
+export declare const build: (options: CLIResolvedOptions & {
+    target?: "web" | "native" | "both";
+    dir?: string;
+    include?: string;
+    exclude?: string;
+    output?: string;
+    outputAround?: boolean;
+    expectOptimizations?: number;
+    runCommand?: string[];
+    dryRun?: boolean;
+}) => Promise<BuildResult>;
+//# sourceMappingURL=build.d.ts.map
@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map
@@ -0,0 +1,7 @@
+import type { CLIResolvedOptions } from '@hanzogui/types';
+interface GeneratePromptOptions extends CLIResolvedOptions {
+    output?: string;
+}
+export declare function generatePrompt(options: GeneratePromptOptions): Promise<void>;
+export {};
+//# sourceMappingURL=generate-prompt.d.ts.map
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import type { CLIResolvedOptions } from '@hanzogui/types';
+export declare function generateTypes(options: CLIResolvedOptions): Promise<void>;
+export declare function getTypes(options: CLIResolvedOptions): Promise<{
+    [k: string]: (string | undefined)[][];
+}>;
+//# sourceMappingURL=generate.d.ts.map
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+//# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,2 @@
+export declare function updateTemplate(templateUrl: string, ignoredPatterns?: string[]): void;
+//# sourceMappingURL=update-template.d.ts.map
@@ -0,0 +1,2 @@
+export declare const update: () => Promise<void>;
+//# sourceMappingURL=update.d.ts.map
@@ -0,0 +1,13 @@
+interface UpgradeOptions {
+    from?: string;
+    to?: string;
+    changelogOnly?: boolean;
+    dryRun?: boolean;
+    debug?: boolean;
+}
+/**
+ * Main upgrade function
+ */
+export declare function upgrade(options?: UpgradeOptions): Promise<void>;
+export {};
+//# sourceMappingURL=upgrade.d.ts.map
@@ -0,0 +1,8 @@
+import type { HanzoguiOptions, HanzoguiProjectInfo } from '@hanzogui/static';
+import type { CLIResolvedOptions, CLIUserOptions } from '@hanzogui/types';
+export declare function getOptions({ root, tsconfigPath, hanzoguiOptions, host, debug, loadHanzoguiOptions, }?: Partial<CLIUserOptions>): Promise<CLIResolvedOptions>;
+export declare function ensure(condition: boolean, message: string): void;
+export declare const loadHanzogui: (opts: Partial<HanzoguiOptions>) => Promise<HanzoguiProjectInfo | null>;
+export declare function registerDispose(cb: () => void): void;
+export declare function disposeAll(): void;
+//# sourceMappingURL=utils.d.ts.map
--- a/Show More
+++ b/Show More