@motiadev/workbench 0.8.2-beta.140-628177 → 0.8.2-beta.140-111855

package/dist/components.json

@@ -18,4 +18,4 @@
     "hooks": "@/hooks"
   },
   "iconLibrary": "lucide"
-}
+}

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-export { EventNode } from './src/publicComponents/event-node';
-export { ApiNode } from './src/publicComponents/api-node';
-export { NoopNode } from './src/publicComponents/noop-node';
-export { BaseNode } from './src/publicComponents/base-node/base-node';
-export { BaseHandle } from './src/publicComponents/base-node/base-handle';
 export { Position } from '@xyflow/react';
-export type { EventNodeData, ApiNodeData } from './src/types/flow';
-export type { ApiNodeProps, BaseNodeProps, CronNodeProps, EventNodeProps, NoopNodeProps, } from './src/publicComponents/node-props';
 export type { TutorialStep } from './src/components/tutorial/engine/tutorial-types';
 export { workbenchXPath } from './src/components/tutorial/engine/workbench-xpath';
+export { ApiNode } from './src/publicComponents/api-node';
+export { BaseHandle } from './src/publicComponents/base-node/base-handle';
+export { BaseNode } from './src/publicComponents/base-node/base-node';
+export { EventNode } from './src/publicComponents/event-node';
+export type { ApiNodeProps, BaseNodeProps, CronNodeProps, EventNodeProps, NoopNodeProps, } from './src/publicComponents/node-props';
+export { NoopNode } from './src/publicComponents/noop-node';
+export type { ApiNodeData, EventNodeData } from './src/types/flow';

package/dist/index.js

@@ -1,7 +1,7 @@
-export { EventNode } from './src/publicComponents/event-node';
-export { ApiNode } from './src/publicComponents/api-node';
-export { NoopNode } from './src/publicComponents/noop-node';
-export { BaseNode } from './src/publicComponents/base-node/base-node';
-export { BaseHandle } from './src/publicComponents/base-node/base-handle';
 export { Position } from '@xyflow/react';
 export { workbenchXPath } from './src/components/tutorial/engine/workbench-xpath';
+export { ApiNode } from './src/publicComponents/api-node';
+export { BaseHandle } from './src/publicComponents/base-node/base-handle';
+export { BaseNode } from './src/publicComponents/base-node/base-node';
+export { EventNode } from './src/publicComponents/event-node';
+export { NoopNode } from './src/publicComponents/noop-node';

package/dist/middleware.d.ts

@@ -1,5 +1,5 @@
 import type { Express } from 'express';
-import { type WorkbenchPlugin } from './vite-plugin-motia-plugins';
+import type { WorkbenchPlugin } from './motia-plugin/types';
 export type ApplyMiddlewareParams = {
     app: Express;
     port: number;

package/dist/middleware.js

@@ -8,7 +8,7 @@ const plugin_react_1 = __importDefault(require("@vitejs/plugin-react"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const vite_1 = require("vite");
-const vite_plugin_motia_plugins_1 = __importDefault(require("./vite-plugin-motia-plugins"));
+const motia_plugin_1 = __importDefault(require("./motia-plugin"));
 const workbenchBasePlugin = (workbenchBase) => {
     return {
         name: 'html-transform',
@@ -60,6 +60,7 @@ const applyMiddleware = async ({ app, port, workbenchBase, plugins }) => {
                     path_1.default.join(process.cwd(), './steps'), // steps directory
                     path_1.default.join(process.cwd(), './tutorial.tsx'), // tutorial file
                     path_1.default.join(process.cwd(), './node_modules'), // node_modules directory
+                    path_1.default.join(__dirname, './node_modules'), // node_modules directory
                 ],
             },
         },
@@ -67,14 +68,13 @@ const applyMiddleware = async ({ app, port, workbenchBase, plugins }) => {
             alias: {
                 '@': path_1.default.resolve(__dirname, './src'),
                 '@/assets': path_1.default.resolve(__dirname, './src/assets'),
-                // antd: path.join(process.cwd(), './node_modules/antd'),
             },
         },
         plugins: [
             (0, plugin_react_1.default)(),
             processCwdPlugin(),
             reoPlugin(),
-            (0, vite_plugin_motia_plugins_1.default)(plugins),
+            (0, motia_plugin_1.default)(plugins),
             workbenchBasePlugin(workbenchBase),
         ],
         assetsInclude: ['**/*.png', '**/*.jpg', '**/*.jpeg', '**/*.gif', '**/*.svg', '**/*.ico', '**/*.webp', '**/*.avif'],

package/dist/motia-plugin/__tests__/generator.test.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_1 = require("../generator");
+describe('Generator', () => {
+    describe('generateImports', () => {
+        it('should generate import statements', () => {
+            const packages = ['@test/plugin-1', '@test/plugin-2'];
+            const imports = (0, generator_1.generateImports)(packages);
+            expect(imports).toContain("import * as plugin_0 from '@test/plugin-1'");
+            expect(imports).toContain("import * as plugin_1 from '@test/plugin-2'");
+        });
+        it('should handle empty package array', () => {
+            const imports = (0, generator_1.generateImports)([]);
+            expect(imports).toBe('');
+        });
+    });
+    describe('generatePackageMap', () => {
+        it('should generate package map', () => {
+            const packages = ['@test/plugin-1', '@test/plugin-2'];
+            const map = (0, generator_1.generatePackageMap)(packages);
+            expect(map).toContain('const packageMap');
+            expect(map).toContain("'@test/plugin-1': plugin_0");
+            expect(map).toContain("'@test/plugin-2': plugin_1");
+        });
+    });
+    describe('generatePluginLogic', () => {
+        it('should generate plugin processing logic', () => {
+            const plugins = [{ packageName: '@test/plugin', label: 'Test' }];
+            const logic = (0, generator_1.generatePluginLogic)(plugins);
+            expect(logic).toContain('const motiaPlugins');
+            expect(logic).toContain('export const plugins');
+            expect(logic).toContain('packageMap[plugin.packageName]');
+        });
+    });
+    describe('generatePluginCode', () => {
+        it('should generate complete module code', () => {
+            const plugins = [{ packageName: '@test/plugin', label: 'Test' }];
+            const code = (0, generator_1.generatePluginCode)(plugins);
+            expect(code).toContain('import * as plugin_0');
+            expect(code).toContain('const packageMap');
+            expect(code).toContain('export const plugins');
+        });
+        it('should handle empty plugins array', () => {
+            const code = (0, generator_1.generatePluginCode)([]);
+            expect(code).toBe('export const plugins = []');
+        });
+        it('should handle multiple plugins', () => {
+            const plugins = [{ packageName: '@test/plugin-1' }, { packageName: '@test/plugin-2' }];
+            const code = (0, generator_1.generatePluginCode)(plugins);
+            expect(code).toContain("'@test/plugin-1'");
+            expect(code).toContain("'@test/plugin-2'");
+        });
+    });
+    describe('generateCssImports', () => {
+        it('should generate CSS import statements', () => {
+            const plugins = [{ packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'styles.css';");
+            expect(css).toContain("@import 'theme.css';");
+        });
+        it('should filter empty CSS imports', () => {
+            const plugins = [{ packageName: '@test/plugin', cssImports: ['styles.css', '', '  '] }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'styles.css';");
+            expect(css).not.toContain("@import '';");
+        });
+        it('should return empty string for plugins without CSS imports', () => {
+            const plugins = [{ packageName: '@test/plugin' }];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toBe('');
+        });
+        it('should flatten CSS imports from multiple plugins', () => {
+            const plugins = [
+                { packageName: '@test/plugin-1', cssImports: ['a.css'] },
+                { packageName: '@test/plugin-2', cssImports: ['b.css'] },
+            ];
+            const css = (0, generator_1.generateCssImports)(plugins);
+            expect(css).toContain("@import 'a.css';");
+            expect(css).toContain("@import 'b.css';");
+        });
+    });
+    describe('isValidCode', () => {
+        it('should return true for valid code', () => {
+            expect((0, generator_1.isValidCode)('export const plugins = []')).toBe(true);
+        });
+        it('should return false for empty string', () => {
+            expect((0, generator_1.isValidCode)('')).toBe(false);
+        });
+        it('should return false for whitespace only', () => {
+            expect((0, generator_1.isValidCode)('   \n\t  ')).toBe(false);
+        });
+        it('should return false for non-string', () => {
+            expect((0, generator_1.isValidCode)(null)).toBe(false);
+            expect((0, generator_1.isValidCode)(undefined)).toBe(false);
+        });
+    });
+});

package/dist/motia-plugin/__tests__/resolver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/motia-plugin/__tests__/resolver.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolver_1 = require("../resolver");
+describe('Resolver', () => {
+    describe('resolvePluginPackage', () => {
+        it('should resolve local plugin', () => {
+            const plugin = { packageName: '~/plugins/local' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.packageName).toBe('~/plugins/local');
+            expect(resolved.isLocal).toBe(true);
+            expect(resolved.resolvedPath).toContain('plugins/local');
+            expect(resolved.alias).toBe('~/plugins/local');
+        });
+        it('should resolve npm package', () => {
+            const plugin = { packageName: '@test/plugin' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.packageName).toBe('@test/plugin');
+            expect(resolved.isLocal).toBe(false);
+            expect(resolved.resolvedPath).toContain('node_modules');
+            expect(resolved.resolvedPath).toContain('@test/plugin');
+            expect(resolved.alias).toBe('@test/plugin');
+        });
+        it('should normalize paths', () => {
+            const plugin = { packageName: 'simple-plugin' };
+            const resolved = (0, resolver_1.resolvePluginPackage)(plugin);
+            expect(resolved.resolvedPath).not.toContain('\\');
+        });
+    });
+    describe('createAliasConfig', () => {
+        it('should create aliases for all plugins', () => {
+            const plugins = [{ packageName: '~/plugins/local' }, { packageName: '@test/npm' }];
+            const aliases = (0, resolver_1.createAliasConfig)(plugins);
+            expect(aliases['~/plugins/local']).toBeDefined();
+            expect(aliases['@test/npm']).toBeDefined();
+        });
+        it('should handle duplicate package names', () => {
+            const plugins = [{ packageName: '@test/plugin' }, { packageName: '@test/plugin' }];
+            const aliases = (0, resolver_1.createAliasConfig)(plugins);
+            expect(Object.keys(aliases)).toHaveLength(1);
+            expect(aliases['@test/plugin']).toBeDefined();
+        });
+        it('should return empty object for empty plugins array', () => {
+            const aliases = (0, resolver_1.createAliasConfig)([]);
+            expect(aliases).toEqual({});
+        });
+    });
+    describe('getUniquePackageNames', () => {
+        it('should return unique package names', () => {
+            const plugins = [
+                { packageName: '@test/a' },
+                { packageName: '@test/b' },
+                { packageName: '@test/a' },
+            ];
+            const unique = (0, resolver_1.getUniquePackageNames)(plugins);
+            expect(unique).toHaveLength(2);
+            expect(unique).toContain('@test/a');
+            expect(unique).toContain('@test/b');
+        });
+        it('should return empty array for no plugins', () => {
+            const unique = (0, resolver_1.getUniquePackageNames)([]);
+            expect(unique).toEqual([]);
+        });
+    });
+});

package/dist/motia-plugin/__tests__/validator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/motia-plugin/__tests__/validator.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+describe('Validator', () => {
+    describe('validatePlugins', () => {
+        it('should validate array of valid plugins', () => {
+            const plugins = [
+                { packageName: '@test/plugin-1', label: 'Plugin 1' },
+                { packageName: '@test/plugin-2', label: 'Plugin 2' },
+            ];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+        it('should reject non-array input', () => {
+            const result = (0, validator_1.validatePlugins)('not-an-array');
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((err) => err.includes('array'))).toBe(true);
+        });
+        it('should handle empty array', () => {
+            const result = (0, validator_1.validatePlugins)([]);
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some((w) => w.includes('No plugins'))).toBe(true);
+        });
+        it('should collect all errors from multiple plugins', () => {
+            const plugins = [{ packageName: '' }, { packageName: '' }, { packageName: 'valid' }];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should warn about duplicate package names', () => {
+            const plugins = [
+                { packageName: '@test/plugin', label: 'Plugin 1' },
+                { packageName: '@test/plugin', label: 'Plugin 2' },
+            ];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(true);
+            expect(result.warnings.some((w) => w.includes('Duplicate'))).toBe(true);
+        });
+        it('should support failFast option', () => {
+            const plugins = [{ packageName: '' }, { packageName: '' }];
+            const result = (0, validator_1.validatePlugins)(plugins, { failFast: true });
+            expect(result.valid).toBe(false);
+            // With failFast, should stop after first plugin validation fails
+            // Each plugin with empty packageName generates 2 errors (min length + invalid format)
+            // So failFast should result in only the first plugin's errors
+            expect(result.errors.length).toBeLessThanOrEqual(2);
+            // Verify it didn't process second plugin by checking error messages don't mention index 1
+            const hasIndex1Error = result.errors.some((err) => err.includes('index 1'));
+            expect(hasIndex1Error).toBe(false);
+        });
+        it('should handle mixed valid and invalid plugins', () => {
+            const plugins = [{ packageName: '@test/valid' }, { packageName: '' }, { packageName: '@test/another-valid' }];
+            const result = (0, validator_1.validatePlugins)(plugins);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/motia-plugin/generator.d.ts

@@ -0,0 +1,78 @@
+import type { WorkbenchPlugin } from './types';
+/**
+ * Generates import statements for all unique plugin packages.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string with import statements
+ *
+ * @example
+ * ```ts
+ * generateImports(['@org/plugin-1', '~/plugins/local'])
+ * // Returns:
+ * // import * as plugin_0 from '@org/plugin-1'
+ * // import * as plugin_1 from '~/plugins/local'
+ * ```
+ */
+export declare function generateImports(packages: string[]): string;
+/**
+ * Generates the package map that links package names to their imported modules.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string defining the package map
+ *
+ * @example
+ * ```ts
+ * generatePackageMap(['@org/plugin-1', '~/plugins/local'])
+ * // Returns: const packageMap = {'@org/plugin-1': plugin_0,'~/plugins/local': plugin_1}
+ * ```
+ */
+export declare function generatePackageMap(packages: string[]): string;
+/**
+ * Generates the plugin transformation logic that processes plugin configurations.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns JavaScript code string with plugin processing logic
+ */
+export declare function generatePluginLogic(plugins: WorkbenchPlugin[]): string;
+/**
+ * Generates the complete virtual module code for all plugins.
+ * This is the main code generation function that combines all parts.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Complete JavaScript code string for the virtual module
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', label: 'Test' }
+ * ]
+ * const code = generatePluginCode(plugins)
+ * // Returns complete module code with imports, map, and logic
+ * ```
+ */
+export declare function generatePluginCode(plugins: WorkbenchPlugin[]): string;
+/**
+ * Generates CSS imports for plugins that specify cssImports.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns CSS import statements as a string
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }
+ * ]
+ * generateCssImports(plugins)
+ * // Returns:
+ * // @import 'styles.css';
+ * // @import 'theme.css';
+ * ```
+ */
+export declare function generateCssImports(plugins: WorkbenchPlugin[]): string;
+/**
+ * Checks if the generated code is valid (non-empty and has content).
+ *
+ * @param code - The generated code to check
+ * @returns True if code is valid
+ */
+export declare function isValidCode(code: string): boolean;

package/dist/motia-plugin/generator.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImports = generateImports;
+exports.generatePackageMap = generatePackageMap;
+exports.generatePluginLogic = generatePluginLogic;
+exports.generatePluginCode = generatePluginCode;
+exports.generateCssImports = generateCssImports;
+exports.isValidCode = isValidCode;
+const resolver_1 = require("./resolver");
+/**
+ * Generates import statements for all unique plugin packages.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string with import statements
+ *
+ * @example
+ * ```ts
+ * generateImports(['@org/plugin-1', '~/plugins/local'])
+ * // Returns:
+ * // import * as plugin_0 from '@org/plugin-1'
+ * // import * as plugin_1 from '~/plugins/local'
+ * ```
+ */
+function generateImports(packages) {
+    return packages.map((packageName, index) => `import * as plugin_${index} from '${packageName}'`).join('\n');
+}
+/**
+ * Generates the package map that links package names to their imported modules.
+ *
+ * @param packages - Array of unique package names
+ * @returns JavaScript code string defining the package map
+ *
+ * @example
+ * ```ts
+ * generatePackageMap(['@org/plugin-1', '~/plugins/local'])
+ * // Returns: const packageMap = {'@org/plugin-1': plugin_0,'~/plugins/local': plugin_1}
+ * ```
+ */
+function generatePackageMap(packages) {
+    const entries = packages.map((packageName, index) => `'${packageName}': plugin_${index}`);
+    return `const packageMap = {${entries.join(',')}}`;
+}
+/**
+ * Generates the plugin transformation logic that processes plugin configurations.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns JavaScript code string with plugin processing logic
+ */
+function generatePluginLogic(plugins) {
+    return `
+      const motiaPlugins = ${JSON.stringify(plugins)}
+
+      export const plugins = motiaPlugins.map((plugin) => {
+        const component = packageMap[plugin.packageName]
+        const config = component.config || {}
+        const componentName = config.componentName || plugin.componentName
+
+        return {
+          label: plugin.label || config.label || 'Plugin label',
+          labelIcon: plugin.labelIcon || config.labelIcon || 'toy-brick',
+          position: plugin.position || config.position || 'top',
+          props: plugin.props || config.props || {},
+          component: componentName ? component[componentName] : component.default,
+        }
+      })
+`;
+}
+/**
+ * Generates the complete virtual module code for all plugins.
+ * This is the main code generation function that combines all parts.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns Complete JavaScript code string for the virtual module
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', label: 'Test' }
+ * ]
+ * const code = generatePluginCode(plugins)
+ * // Returns complete module code with imports, map, and logic
+ * ```
+ */
+function generatePluginCode(plugins) {
+    if (!plugins || plugins.length === 0) {
+        return 'export const plugins = []';
+    }
+    const packages = (0, resolver_1.getUniquePackageNames)(plugins);
+    const imports = generateImports(packages);
+    const packageMap = generatePackageMap(packages);
+    const logic = generatePluginLogic(plugins);
+    return `${imports}
+${packageMap}
+${logic}`;
+}
+/**
+ * Generates CSS imports for plugins that specify cssImports.
+ *
+ * @param plugins - Array of plugin configurations
+ * @returns CSS import statements as a string
+ *
+ * @example
+ * ```ts
+ * const plugins = [
+ *   { packageName: '@test/plugin', cssImports: ['styles.css', 'theme.css'] }
+ * ]
+ * generateCssImports(plugins)
+ * // Returns:
+ * // @import 'styles.css';
+ * // @import 'theme.css';
+ * ```
+ */
+function generateCssImports(plugins) {
+    const cssImports = plugins
+        .flatMap((plugin) => plugin.cssImports || [])
+        .filter((cssImport) => cssImport && cssImport.trim() !== '')
+        .map((cssImport) => `@import '${cssImport}';`);
+    return cssImports.join('\n');
+}
+/**
+ * Checks if the generated code is valid (non-empty and has content).
+ *
+ * @param code - The generated code to check
+ * @returns True if code is valid
+ */
+function isValidCode(code) {
+    return typeof code === 'string' && code.trim().length > 0;
+}

package/dist/motia-plugin/hmr.d.ts

@@ -0,0 +1,19 @@
+import type { HmrContext, ModuleNode } from 'vite';
+import type { WorkbenchPlugin } from './types';
+/**
+ * Checks if a file change should trigger HMR for plugins.
+ *
+ * @param file - The file path that changed
+ * @param plugins - Current plugin configurations
+ * @returns True if the change affects plugins
+ */
+export declare function shouldInvalidatePlugins(file: string, plugins: WorkbenchPlugin[]): boolean;
+/**
+ * Handles hot updates for the plugin system.
+ * This function is called by Vite's handleHotUpdate hook.
+ *
+ * @param ctx - Vite's HMR context
+ * @param plugins - Current plugin configurations
+ * @returns Array of modules to update, or undefined to continue with default behavior
+ */
+export declare function handlePluginHotUpdate(ctx: HmrContext, plugins: WorkbenchPlugin[]): ModuleNode[] | void;

package/dist/motia-plugin/hmr.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldInvalidatePlugins = shouldInvalidatePlugins;
+exports.handlePluginHotUpdate = handlePluginHotUpdate;
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+/**
+ * Checks if a file change should trigger HMR for plugins.
+ *
+ * @param file - The file path that changed
+ * @param plugins - Current plugin configurations
+ * @returns True if the change affects plugins
+ */
+function shouldInvalidatePlugins(file, plugins) {
+    const normalizedFile = (0, utils_1.normalizePath)(file);
+    // Check if the changed file is a local plugin
+    for (const plugin of plugins) {
+        if (plugin.packageName.startsWith('~/')) {
+            const pluginPath = plugin.packageName.replace('~/', '');
+            if (normalizedFile.includes(pluginPath)) {
+                return true;
+            }
+        }
+    }
+    // Check if it's a plugin configuration file
+    if (normalizedFile.endsWith('motia.config.ts') || normalizedFile.endsWith('motia.config.js')) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Handles hot updates for the plugin system.
+ * This function is called by Vite's handleHotUpdate hook.
+ *
+ * @param ctx - Vite's HMR context
+ * @param plugins - Current plugin configurations
+ * @returns Array of modules to update, or undefined to continue with default behavior
+ */
+function handlePluginHotUpdate(ctx, plugins) {
+    const { file, server } = ctx;
+    console.log('[motia-plugins] HMR: File changed:', file);
+    // Check if this change affects plugins
+    if (!shouldInvalidatePlugins(file, plugins)) {
+        return; // Let Vite handle it normally
+    }
+    console.log('[motia-plugins] HMR: Plugin configuration or local plugin changed, invalidating virtual module');
+    // Find the virtual module
+    const virtualModule = server.moduleGraph.getModuleById(types_1.CONSTANTS.RESOLVED_VIRTUAL_MODULE_ID);
+    if (virtualModule) {
+        // Invalidate the virtual module to force regeneration
+        server.moduleGraph.invalidateModule(virtualModule);
+        console.log('[motia-plugins] HMR: Virtual module invalidated');
+    }
+    // Return modules to update (includes the virtual module and any dependent modules)
+    const modulesToUpdate = [];
+    if (virtualModule) {
+        modulesToUpdate.push(virtualModule);
+    }
+    // Add any modules that import the virtual module
+    const importers = virtualModule?.importers || new Set();
+    for (const importer of importers) {
+        modulesToUpdate.push(importer);
+        console.log('[motia-plugins] HMR: Invalidating importer:', importer.id);
+    }
+    return modulesToUpdate;
+}

package/dist/motia-plugin/index.d.ts

@@ -0,0 +1,27 @@
+import type { Plugin } from 'vite';
+import type { WorkbenchPlugin } from './types';
+/**
+ * Vite plugin for loading and managing Motia workbench plugins.
+ *
+ * Features:
+ * - Hot Module Replacement (HMR) support
+ * - Runtime validation with detailed error messages
+ * - Verbose logging for debugging
+ * - CSS injection for plugin styles
+ *
+ * @param plugins - Array of plugin configurations
+ * @param options - Optional loader configuration
+ * @returns Vite plugin instance
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *   plugins: [
+ *     motiaPluginsPlugin([
+ *       { packageName: '@my-org/plugin', label: 'My Plugin' }
+ *     ])
+ *   ]
+ * })
+ * ```
+ */
+export default function motiaPluginsPlugin(plugins: WorkbenchPlugin[]): Plugin;