chaincss 2.0.7 → 2.1.1

package/dist/runtime/injector.d.ts

@@ -1,86 +1,53 @@
-/**
- * ChainCSS Runtime Style Injector
- * This is the core 3.2KB runtime that users opt into
- */
 export interface StyleDefinition {
-    selectors: string[];
+    selectors?: string[];
     hover?: Record<string, string | number>;
     [key: string]: any;
 }
-export interface CompiledStyle {
-    className: string;
-    css: string;
+export interface TokenStore {
+    colors?: Record<string, string>;
+    spacing?: Record<string, string>;
+    typography?: Record<string, any>;
+    [key: string]: any;
 }
 declare class StyleInjector {
     private styleElement;
-    private stylesCache;
-    private injectedStyles;
+    private injectedHashes;
+    private moduleMap;
+    private debugMode;
+    private get tokenStore();
     constructor();
-    private initStyleElement;
-    private generateClassName;
+    /**
+     * Enable debug logging
+     */
+    enableDebug(enable?: boolean): void;
+    /**
+     * Set global tokens (e.g., brand colors, spacing scales)
+     */
+    setTokens(tokens: TokenStore): void;
+    /**
+     * Get a token value by path
+     */
+    getToken(path: string): any;
+    /**
+     * Resolves $variables within a string using the tokenStore
+     */
+    resolveToken(value: any): any;
     private generateCSS;
-    inject(styleId: string, style: StyleDefinition): string;
-    injectMultiple(styles: Record<string, StyleDefinition>): Record<string, string>;
-    update(styleId: string, style: StyleDefinition): string;
-    remove(styleId: string): void;
+    injectMultiple(styles: Record<string, StyleDefinition>, moduleId?: string): Record<string, string>;
+    writeToDOM(css: string): void;
+    removeModule(moduleId: string): void;
+    removeAll(): void;
     getStyleElement(): HTMLStyleElement | null;
-    clear(): void;
+    getStats(): {
+        injectedStyles: number;
+        modules: number;
+    };
 }
 export declare const styleInjector: StyleInjector;
-export declare function chainRuntime(useTokens?: boolean): {};
-export declare const $: {};
-export declare function compileRuntime(styles: Record<string, StyleDefinition>): Record<string, string>;
+export declare const setTokens: (t: TokenStore) => void;
+export declare const compileRuntime: (s: Record<string, StyleDefinition>, moduleId?: string) => Record<string, string>;
+export declare const removeRuntimeModule: (moduleId: string) => void;
+export declare const clearRuntimeStyles: () => void;
+export declare const enableRuntimeDebug: (enabled: boolean) => void;
 export declare function runRuntime(...styles: StyleDefinition[]): string;
-/**
- * Add animation presets to runtime
- */
-export declare const runtimeAnimations: {
-    fadeIn: {
-        '0%': {
-            opacity: number;
-        };
-        '100%': {
-            opacity: number;
-        };
-    };
-    fadeOut: {
-        '0%': {
-            opacity: number;
-        };
-        '100%': {
-            opacity: number;
-        };
-    };
-    slideInUp: {
-        '0%': {
-            transform: string;
-            opacity: number;
-        };
-        '100%': {
-            transform: string;
-            opacity: number;
-        };
-    };
-    pulse: {
-        '0%, 100%': {
-            transform: string;
-        };
-        '50%': {
-            transform: string;
-        };
-    };
-    spin: {
-        '0%': {
-            transform: string;
-        };
-        '100%': {
-            transform: string;
-        };
-    };
-};
-/**
- * Add animation to runtime style
- */
-export declare function withAnimation(style: Record<string, any>, animationName: keyof typeof runtimeAnimations, duration?: string, timing?: string): Record<string, any>;
 export {};
-//# sourceMappingURL=injector.d.ts.map

package/dist/runtime/react.d.ts

@@ -3,12 +3,13 @@ export interface UseChainStylesOptions {
     cache?: boolean;
     namespace?: string;
     watch?: boolean;
+    debug?: boolean;
+    ssr?: boolean;
 }
 /**
  * React hook for ChainCSS runtime styles
- * WARNING: This adds ~3.2KB to your bundle. For production, use build-time compilation.
  */
-export declare function useChainStyles(styles: Record<string, any> | (() => Record<string, any>), deps?: any[], options?: UseChainStylesOptions): Record<string, string>;
+export declare function useChainStyles(styles: Record<string, any>, deps?: any[], options?: UseChainStylesOptions): Record<string, string>;
 /**
  * Dynamic styles hook - re-runs when deps change
  */
@@ -20,16 +21,15 @@ export declare function useThemeChainStyles(styles: Record<string, any> | ((them
 /**
  * Global style injection component
  */
-export declare function ChainCSSGlobal({ styles }: {
-    styles: Record<string, any>;
-}): null;
+export declare function ChainCSSGlobal({ styles, tokens, children }: {
+    styles?: Record<string, any>;
+    tokens?: any;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
 /**
  * Class name utility (like clsx)
  */
-export declare function cx(...classes: (string | undefined | null | false)[]): string;
-export declare function enableChainCSSDebug(): void;
-export declare function disableChainCSSDebug(): void;
-export declare function isDebugEnabled(): boolean;
+export declare function cx(...classes: (string | undefined | null | false | Record<string, boolean>)[]): string;
 /**
  * HOC for class components
  */
@@ -38,9 +38,8 @@ export declare function withChainStyles<P extends object>(styles: Record<string,
 }) => import("react/jsx-runtime").JSX.Element;
 /**
  * Create a styled component (React)
- * Similar to .component() in build-time, but for runtime
  */
-export declare function createStyledComponent<T extends keyof JSX.IntrinsicElements = 'div'>(elementType: T, styles: Record<string, any> | (() => Record<string, any>), options?: UseChainStylesOptions): React.FC<React.ComponentProps<T> & {
+export declare function createStyledComponent<T extends keyof React.JSX.IntrinsicElements = "div">(elementType: T, styles: Record<string, any> | (() => Record<string, any>), options?: UseChainStylesOptions): React.FC<React.ComponentProps<T> & {
     className?: string;
 }>;
 /**
@@ -51,4 +50,10 @@ export declare function createStyledComponents(components: Record<string, any>):
  * CSS-in-JS hook with computed styles
  */
 export declare function useComputedStyles<T extends Record<string, any>>(styles: (props: T) => Record<string, any>, props: T, deps?: any[], options?: UseChainStylesOptions): Record<string, string>;
-//# sourceMappingURL=react.d.ts.map
+/**
+ * Set global tokens from React
+ */
+export declare function setTokens(tokens: any): void;
+export declare function enableChainCSSDebug(): void;
+export declare function disableChainCSSDebug(): void;
+export declare function isDebugEnabled(): boolean;

package/dist/runtime/svelte.d.ts

@@ -0,0 +1,15 @@
+export declare function useAtomicClasses(): {
+    subscribe: () => void;
+    get: () => {};
+};
+export declare function cx(...args: any[]): string;
+export declare function ChainCSSGlobal(): null;
+export declare function createStyledComponent(): () => null;
+export declare function createStyledComponents(): {};
+export declare function useComputedStyles(): {
+    subscribe: () => void;
+    get: () => string;
+};
+export declare function provideStyleContext(): void;
+export declare function injectStyleContext(): {};
+export declare function chainStyles(): {};

package/dist/runtime/types.d.ts

@@ -3,8 +3,10 @@
  * Only needed if using runtime mode
  */
 export interface RuntimeStyleDefinition {
-    selectors: string[];
+    selectors?: string[];
     hover?: Record<string, string | number>;
+    _classes?: string[];
+    _name?: string;
     [cssProperty: string]: any;
 }
 export interface UseChainStylesOptions {
@@ -14,32 +16,152 @@ export interface UseChainStylesOptions {
     namespace?: string;
     /** Watch for changes (development only) */
     watch?: boolean;
+    /** Debug mode */
+    debug?: boolean;
+    /** Server-side rendering mode */
+    ssr?: boolean;
 }
 export interface RuntimeCompiledResult {
     [key: string]: string;
 }
 export interface StyleInjector {
     inject(styleId: string, style: RuntimeStyleDefinition): string;
-    injectMultiple(styles: Record<string, RuntimeStyleDefinition>): Record<string, string>;
+    injectMultiple(styles: Record<string, RuntimeStyleDefinition>, moduleId?: string): Record<string, string>;
     update(styleId: string, style: RuntimeStyleDefinition): string;
     remove(styleId: string): void;
+    removeModule(moduleId: string): void;
     clear(): void;
+    setTokens(tokens: TokenStore): void;
     getStyleElement(): HTMLStyleElement | null;
+    getStats(): {
+        injectedStyles: number;
+        modules: number;
+    };
+}
+export interface TokenStore {
+    colors?: Record<string, string>;
+    spacing?: Record<string, string>;
+    typography?: {
+        fontFamily?: Record<string, string>;
+        fontSize?: Record<string, string>;
+        fontWeight?: Record<string, string>;
+        lineHeight?: Record<string, string>;
+        letterSpacing?: Record<string, string>;
+    };
+    breakpoints?: Record<string, string>;
+    zIndex?: Record<string, string>;
+    shadows?: Record<string, string>;
+    borderRadius?: Record<string, string>;
+    animations?: Record<string, any>;
+    [key: string]: any;
+}
+export interface ChainCSSManifest {
+    atomicMap: Record<string, string>;
+    version: string;
+    timestamp?: number;
+    stats?: {
+        totalStyles: number;
+        atomicStyles: number;
+        uniqueProperties: number;
+        savings: string;
+    };
 }
 export interface UseAtomicClassesReturn {
     classes: Record<string, string>;
     cx: (name: string) => string;
     cn: (...names: string[]) => string;
+    inject?: (styles: Record<string, any>) => void;
+}
+export interface UseDynamicChainStylesReturn extends UseAtomicClassesReturn {
+    updateStyles: (newStyles: Record<string, any>) => void;
+}
+export interface UseThemeChainStylesReturn extends UseAtomicClassesReturn {
+    theme: any;
+    setTheme: (theme: any) => void;
+}
+export interface UseAtomicClassesReturnVue {
+    classes: import('vue').Ref<Record<string, string>>;
+    cx: (name: string) => string;
+    cn: (...names: string[]) => string;
+    inject: (styles: Record<string, any>) => void;
+}
+export interface UseComputedStylesReturnVue {
+    classes: import('vue').Ref<Record<string, string>>;
+    rootClass: import('vue').ComputedRef<string>;
+}
+export interface UseAtomicClassesReturnSvelte {
+    subscribe: (callback: (value: Record<string, string>) => void) => () => void;
+    get: () => Record<string, string>;
+    cx: (name: string) => string;
+    cn: (...names: string[]) => string;
+}
+export interface UseComputedStylesReturnSvelte {
+    classes: UseAtomicClassesReturnSvelte;
+    rootClass: import('svelte/store').Readable<string>;
+}
+type SolidAccessor<T> = T extends any ? (() => T) : never;
+export interface UseAtomicClassesReturnSolid {
+    classes: SolidAccessor<Record<string, string>>;
+    cx: (...names: string[]) => string;
+    inject: (styles: Record<string, any>) => void;
+}
+export interface UseComputedStylesReturnSolid {
+    classes: SolidAccessor<Record<string, string>>;
+    rootClass: SolidAccessor<string>;
 }
 export interface HMRPayload {
     file: string;
-    classes: Record<string, string>;
+    css?: string;
+    map?: Record<string, string>;
+    styles?: Record<string, any>;
     timestamp: number;
+    moduleId?: string;
+}
+export interface HMRUpdateEvent {
+    type: 'chaincss:update';
+    data: HMRPayload;
 }
 export interface ChainCSSDebugger {
     enabled: boolean;
     log: (...args: any[]) => void;
     warn: (...args: any[]) => void;
     error: (...args: any[]) => void;
+    group: (label: string) => void;
+    groupEnd: () => void;
+    time: (label: string) => void;
+    timeEnd: (label: string) => void;
+}
+export interface DebugOptions {
+    enabled?: boolean;
+    verbose?: boolean;
+    prefix?: string;
+}
+export type CSSValue = string | number | undefined;
+export type CSSProperties = Record<string, CSSValue>;
+export type ResponsiveValue<T> = T | {
+    base?: T;
+    sm?: T;
+    md?: T;
+    lg?: T;
+    xl?: T;
+    '2xl'?: T;
+    [key: string]: T | undefined;
+};
+export type TokenValue<T = string> = T | `$${string}`;
+declare global {
+    interface Window {
+        __CHAINCSS_V2_TOKENS__?: TokenStore;
+        __CHAINCSS_MANIFEST__?: ChainCSSManifest;
+        __CHAINCSS_DEBUG__?: boolean;
+        __CHAINCSS_VUE_DEBUG__?: boolean;
+        __CHAINCSS_SVELTE_DEBUG__?: boolean;
+        __CHAINCSS_SOLID_DEBUG__?: boolean;
+        __CHAINCSS_REACT_DEBUG__?: boolean;
+    }
 }
-//# sourceMappingURL=types.d.ts.map
+export declare function isRuntimeStyleDefinition(obj: any): obj is RuntimeStyleDefinition;
+export declare function isStyleInjector(obj: any): obj is StyleInjector;
+export declare function isChainCSSManifest(obj: any): obj is ChainCSSManifest;
+export declare function isTokenStore(obj: any): obj is TokenStore;
+export declare function isHMRPayload(obj: any): obj is HMRPayload;
+export {};

package/dist/runtime/utils.d.ts

@@ -59,4 +59,3 @@ export declare function createDebugger(module: string): {
     warn: (...args: any[]) => void;
     error: (...args: any[]) => void;
 };
-//# sourceMappingURL=utils.d.ts.map

package/dist/runtime/vue.d.ts

@@ -2,18 +2,31 @@ import { Ref } from 'vue';
 export interface UseAtomicClassesOptions {
     atomic?: boolean;
     global?: boolean;
+    debug?: boolean;
 }
-export declare function useAtomicClasses(styles: any, options?: UseAtomicClassesOptions): {
-    classes: import("vue").ComputedRef<Record<string, string>>;
+export interface AtomicClassesReturn {
+    classes: Ref<Record<string, string>>;
     cx: (name: string) => string;
     cn: (...names: string[]) => string;
-};
+    inject: (styles: Record<string, any>) => void;
+}
+export declare function useAtomicClasses(styles: any, options?: UseAtomicClassesOptions): AtomicClassesReturn;
 export declare const ChainCSSGlobal: {
     name: string;
     props: {
         styles: {
             type: ObjectConstructor;
             required: boolean;
+            default: () => {};
+        };
+        tokens: {
+            type: ObjectConstructor;
+            required: boolean;
+            default: () => {};
+        };
+        debug: {
+            type: BooleanConstructor;
+            default: boolean;
         };
     };
     setup(props: any): () => null;
@@ -21,32 +34,39 @@ export declare const ChainCSSGlobal: {
 /**
  * Create a styled Vue component
  */
-export declare function createStyledComponent(styles: Record<string, any> | (() => Record<string, any>), tag?: string): {
+export declare function createStyledComponent(styles: Record<string, any> | (() => Record<string, any>), tag?: string, options?: UseAtomicClassesOptions): {
     name: string;
     props: {
         className: {
             type: StringConstructor;
             default: string;
         };
+        as: {
+            type: StringConstructor;
+            default: string;
+        };
     };
-    setup(props: any, { slots, attrs }: any): () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>;
+    setup(props: any, { slots, attrs }: any): () => any;
 };
 /**
  * Create multiple styled Vue components at once
  */
-export declare function createStyledComponents(components: Record<string, any>): Record<string, any>;
+export declare function createStyledComponents(components: Record<string, any>, options?: UseAtomicClassesOptions): Record<string, any>;
 /**
  * CSS-in-JS with computed props (Vue)
  */
-export declare function useComputedStyles<T extends Record<string, any>>(styles: (props: T) => Record<string, any>, props: T): {
-    classes: import("vue").ComputedRef<Record<string, string>>;
-    rootClass: import("vue").ComputedRef<string>;
+export declare function useComputedStyles<T extends Record<string, any>>(styles: (props: T) => Record<string, any>, props: T, options?: UseAtomicClassesOptions): {
+    classes: Ref<Record<string, string>>;
+    rootClass: Ref<string>;
 };
 /**
  * Style provider for theme/context (Vue)
  */
-export declare function provideStyleContext(theme: any): Ref<any, any>;
-export declare function injectStyleContext(): Ref<any, any>;
-//# sourceMappingURL=vue.d.ts.map
+export declare function provideStyleContext(theme: any): Ref<any>;
+export declare function injectStyleContext(): Ref<any>;
+/**
+ * Debug utilities for Vue
+ */
+export declare function enableVueDebug(): void;
+export declare function disableVueDebug(): void;
+export declare function isVueDebugEnabled(): boolean;

package/package.json

@@ -1,80 +1,59 @@
 {
   "name": "chaincss",
-  "version": "2.0.7",
-  "description": "The JavaScript-native styling engine for the modern web",
+  "version": "2.1.1",
+  "description": "ChainCSS v3.0 - The first CSS-in-JS library with true auto-detection mixed mode. Zero runtime by default, dynamic when you need it.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": [
-    "dist/**/*",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "bin": {
-    "chaincss": "dist/cli/cli.cjs"
-  },
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./compiler": {
-      "import": "./dist/compiler/index.js",
-      "types": "./dist/compiler/index.d.ts"
+      "default": "./dist/index.js"
     },
     "./runtime": {
-      "import": "./dist/runtime/index.js",
       "types": "./dist/runtime/index.d.ts",
-      "development": "./dist/runtime/index.js"
+      "import": "./dist/runtime/index.js",
+      "default": "./dist/runtime/index.js"
+    },
+    "./compiler": {
+      "types": "./dist/compiler/index.d.ts",
+      "import": "./dist/compiler/index.js",
+      "default": "./dist/compiler/index.js"
     },
     "./plugin/vite": {
+      "types": "./dist/plugins/vite.d.ts",
       "import": "./dist/plugins/vite.js",
-      "types": "./dist/plugins/vite.d.ts"
+      "default": "./dist/plugins/vite.js"
     },
     "./plugin/webpack": {
+      "types": "./dist/plugins/webpack.d.ts",
       "import": "./dist/plugins/webpack.js",
-      "types": "./dist/plugins/webpack.d.ts"
+      "default": "./dist/plugins/webpack.js"
     }
   },
   "scripts": {
     "build": "npm run build:clean && npm run build:types && npm run build:core && npm run build:cli && npm run build:plugins && npm run build:runtime && npm run build:compiler",
     "build:clean": "rm -rf dist",
-    "build:types": "tsc --emitDeclarationOnly --outDir dist",
-    "build:core": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:chokidar --external:glob --external:commander --external:chalk --external:autoprefixer --external:postcss --external:clean-css",
-    "build:cli": "esbuild src/cli/index.ts --bundle --platform=node --format=esm --outfile=dist/cli/index.js --external:chokidar --external:glob --external:commander --external:chalk --external:autoprefixer --external:postcss --external:clean-css && chmod +x dist/cli/index.js && echo '#!/usr/bin/env node\nconst { spawn } = require(\"child_process\");\nconst path = require(\"path\");\nconst cliPath = path.join(__dirname, \"index.js\");\nconst args = process.argv.slice(2);\nconst child = spawn(\"node\", [cliPath, ...args], { stdio: \"inherit\", shell: false });\nchild.on(\"close\", (code) => process.exit(code));' > dist/cli/cli.cjs && chmod +x dist/cli/cli.cjs",
-    "build:plugins": "esbuild src/plugins/vite.ts --bundle --platform=node --format=esm --outfile=dist/plugins/vite.js --external:vite && esbuild src/plugins/webpack.ts --bundle --platform=node --format=esm --outfile=dist/plugins/webpack.js --external:webpack",
-    "build:runtime": "esbuild src/runtime/index.ts --bundle --platform=browser --format=esm --outfile=dist/runtime/index.js --external:react --external:vue && esbuild src/runtime/react.tsx --bundle --platform=browser --format=esm --outfile=dist/runtime/react.js --external:react --external:vue && esbuild src/runtime/vue.ts --bundle --platform=browser --format=esm --outfile=dist/runtime/vue.js --external:vue --external:react",
-    "build:compiler": "esbuild src/compiler/index.ts --bundle --platform=node --format=esm --outfile=dist/compiler/index.js --external:chokidar --external:glob --external:commander --external:chalk --external:autoprefixer --external:postcss --external:clean-css",
-    "dev": "npm run build:clean && npm run build:types && npm run build:core -- --watch",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:core": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external",
+    "build:cli": "esbuild src/cli/index.ts --bundle --platform=node --format=esm --outfile=dist/cli/index.js --packages=external && chmod +x dist/cli/index.js",
+    "build:plugins": "esbuild src/plugins/vite.ts --bundle --platform=node --format=esm --outfile=dist/plugins/vite.js --packages=external && esbuild src/plugins/webpack.ts --bundle --platform=node --format=esm --outfile=dist/plugins/webpack.js --packages=external",
+    "build:runtime": "esbuild src/runtime/index.ts --bundle --platform=browser --format=esm --outfile=dist/runtime/index.js --external:react --external:react-dom --external:vue --external:svelte",
+    "build:compiler": "esbuild src/compiler/index.ts --bundle --platform=node --format=esm --outfile=dist/compiler/index.js --packages=external",
+    "dev": "tsc -w",
     "prepublishOnly": "npm run build",
-    "version": "git add -A",
-    "postversion": "git push && git push --tags"
-  },
-  "dependencies": {
-    "chalk": "^5.3.0",
-    "chokidar": "^3.5.3",
-    "clean-css": "^5.3.2",
-    "commander": "^11.1.0"
-  },
-  "devDependencies": {
-    "@types/clean-css": "^4.2.10",
-    "@types/node": "^20.8.10",
-    "@types/react": "^18.2.0",
-    "esbuild": "^0.19.12",
-    "glob": "^10.3.10",
-    "react": "^18.2.0",
-    "typescript": "^5.2.2",
-    "vite": "^5.0.0",
-    "vue": "^3.3.4"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:verbose": "CHAINCSS_TEST_VERBOSE=1 vitest run",
+    "test:unit": "vitest run __tests__/unit",
+    "test:integration": "vitest run __tests__/integration"
   },
   "peerDependencies": {
-    "react": "^18.0.0",
-    "vue": "^3.0.0",
-    "autoprefixer": "^10.4.16",
-    "postcss": "^8.4.31",
-    "browserslist": "^4.22.1",
-    "caniuse-db": "^1.0.30001785"
+    "react": ">=16.8.0",
+    "svelte": ">=4.0.0",
+    "vue": ">=3.0.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -83,30 +62,37 @@
     "vue": {
       "optional": true
     },
-    "autoprefixer": {
-      "optional": true
-    },
-    "postcss": {
-      "optional": true
-    },
-    "browserslist": {
-      "optional": true
-    },
-    "caniuse-db": {
+    "svelte": {
       "optional": true
     }
   },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@types/react": "^19.2.14",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^1.6.0",
+    "csstype": "^3.2.3",
+    "esbuild": "^0.28.0",
+    "typescript": "^6.0.3",
+    "vite": "^5.0.0",
+    "vitest": "^1.6.0"
+  },
+  "vitest": {
+    "setupFiles": [
+      "./vitest.setup.ts"
+    ]
+  },
   "keywords": [
     "css-in-js",
     "zero-runtime",
     "atomic-css",
-    "css-compiler",
-    "design-tokens",
+    "mixed-mode",
+    "auto-detection",
     "react",
     "vue",
+    "svelte",
     "vite",
-    "webpack",
-    "nextjs"
+    "webpack"
   ],
   "author": "Rommel Caneos",
   "license": "MIT",
@@ -121,5 +107,12 @@
   "sideEffects": false,
   "engines": {
     "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "browserslist": "^4.28.2",
+    "chalk": "^5.6.2",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.3",
+    "glob": "^13.0.6"
   }
 }