nuclie 1.0.0

package/dist/migrate/analyzer.js

@@ -0,0 +1,254 @@
+/**
+ * Migration Analyzer (Day 43)
+ *
+ * Analyzes existing projects (Vite/Webpack/Rollup/Angular CLI) and generates
+ * a migration plan for converting to Nuclie.
+ */
+import fs from 'fs';
+import path from 'path';
+export class MigrationAnalyzer {
+    constructor(projectRoot) {
+        this.projectRoot = path.resolve(projectRoot);
+    }
+    async analyze() {
+        const packageJson = this.readPackageJson();
+        const toolchain = this.detectToolchain();
+        const frameworks = this.detectFrameworks(packageJson);
+        const cssSetup = this.analyzeCSSSetup(packageJson);
+        const projectStructure = this.analyzeProjectStructure(packageJson);
+        const { plugins, loaders } = this.detectPluginsAndLoaders(toolchain, packageJson);
+        const plan = {
+            toolchainType: toolchain,
+            frameworks,
+            plugins,
+            loaders,
+            riskLevel: this.calculateRiskLevel(toolchain, plugins, loaders),
+            autoMigrate: this.determineAutoMigrate(toolchain, frameworks, plugins),
+            manualSteps: this.determineManualSteps(toolchain, plugins, loaders),
+            cssSetup,
+            projectStructure
+        };
+        return plan;
+    }
+    readPackageJson() {
+        const pkgPath = path.join(this.projectRoot, 'package.json');
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`package.json not found in ${this.projectRoot}`);
+        }
+        return JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    }
+    detectToolchain() {
+        // Check for config files in order of specificity
+        const configChecks = [
+            { pattern: /^vite\.config\.(js|ts|mjs|cjs|mts|cts)$/, type: 'vite' },
+            { pattern: /^webpack\.config\.(js|ts|mjs|cjs)$/, type: 'webpack' },
+            { pattern: /^rollup\.config\.(js|ts|mjs|cjs)$/, type: 'rollup' },
+            { pattern: /^angular\.json$/, type: 'angular-cli' }
+        ];
+        const files = fs.readdirSync(this.projectRoot);
+        for (const check of configChecks) {
+            if (files.some(f => check.pattern.test(f))) {
+                return check.type;
+            }
+        }
+        return 'unknown';
+    }
+    detectFrameworks(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const frameworks = [];
+        const frameworkMap = {
+            'react': 'react',
+            'react-dom': 'react',
+            'vue': 'vue',
+            'svelte': 'svelte',
+            '@angular/core': 'angular',
+            'solid-js': 'solid',
+            'preact': 'preact',
+            'lit': 'lit',
+            '@builder.io/qwik': 'qwik'
+        };
+        for (const [dep, framework] of Object.entries(frameworkMap)) {
+            if (deps[dep] && !frameworks.includes(framework)) {
+                frameworks.push(framework);
+            }
+        }
+        return frameworks.length > 0 ? frameworks : ['unknown'];
+    }
+    analyzeCSSSetup(packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const hasTailwind = 'tailwindcss' in deps || fs.existsSync(path.join(this.projectRoot, 'tailwind.config.js')) || fs.existsSync(path.join(this.projectRoot, 'tailwind.config.ts'));
+        const hasSass = 'sass' in deps || 'node-sass' in deps;
+        const hasCSSModules = this.checkForCSSModules();
+        let hasCSSInJS = false;
+        let cssInJSLibrary;
+        const cssInJSLibs = ['styled-components', '@emotion/react', '@emotion/styled', 'styled-jsx', '@mui/material'];
+        for (const lib of cssInJSLibs) {
+            if (lib in deps) {
+                hasCSSInJS = true;
+                cssInJSLibrary = lib;
+                break;
+            }
+        }
+        return {
+            hasTailwind,
+            hasSass,
+            hasCSSModules,
+            hasCSSInJS,
+            cssInJSLibrary
+        };
+    }
+    checkForCSSModules() {
+        // Check for .module.css files in src/
+        const srcDir = path.join(this.projectRoot, 'src');
+        if (!fs.existsSync(srcDir))
+            return false;
+        const hasModuleCSS = (dir) => {
+            const files = fs.readdirSync(dir);
+            for (const file of files) {
+                const fullPath = path.join(dir, file);
+                const stat = fs.statSync(fullPath);
+                if (stat.isDirectory()) {
+                    if (hasModuleCSS(fullPath))
+                        return true;
+                }
+                else if (file.endsWith('.module.css') || file.endsWith('.module.scss')) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        return hasModuleCSS(srcDir);
+    }
+    analyzeProjectStructure(packageJson) {
+        const isMonorepo = 'workspaces' in packageJson || fs.existsSync(path.join(this.projectRoot, 'pnpm-workspace.yaml')) || fs.existsSync(path.join(this.projectRoot, 'lerna.json'));
+        const hasWorkspaces = 'workspaces' in packageJson;
+        const entryPoints = [];
+        // Common entry point patterns
+        const commonEntries = [
+            'src/main.ts',
+            'src/main.tsx',
+            'src/main.js',
+            'src/main.jsx',
+            'src/index.ts',
+            'src/index.tsx',
+            'src/index.js',
+            'src/index.jsx',
+            'index.html'
+        ];
+        for (const entry of commonEntries) {
+            if (fs.existsSync(path.join(this.projectRoot, entry))) {
+                entryPoints.push(entry);
+            }
+        }
+        return {
+            isMonorepo,
+            hasWorkspaces,
+            entryPoints
+        };
+    }
+    detectPluginsAndLoaders(toolchain, packageJson) {
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies
+        };
+        const plugins = [];
+        const loaders = [];
+        // Vite plugins
+        if (toolchain === 'vite') {
+            const vitePlugins = Object.keys(deps).filter(d => d.startsWith('@vitejs/plugin-') || d.startsWith('vite-plugin-'));
+            plugins.push(...vitePlugins);
+        }
+        // Webpack loaders
+        if (toolchain === 'webpack') {
+            const webpackLoaders = Object.keys(deps).filter(d => d.endsWith('-loader'));
+            loaders.push(...webpackLoaders);
+            const webpackPlugins = Object.keys(deps).filter(d => d.includes('webpack-plugin') || d.includes('webpack') && d !== 'webpack');
+            plugins.push(...webpackPlugins);
+        }
+        // Rollup plugins
+        if (toolchain === 'rollup') {
+            const rollupPlugins = Object.keys(deps).filter(d => d.startsWith('@rollup/plugin-') || d.startsWith('rollup-plugin-'));
+            plugins.push(...rollupPlugins);
+        }
+        return { plugins, loaders };
+    }
+    calculateRiskLevel(toolchain, plugins, loaders) {
+        if (toolchain === 'unknown')
+            return 'HIGH';
+        const totalCustomizations = plugins.length + loaders.length;
+        if (totalCustomizations === 0)
+            return 'LOW';
+        if (totalCustomizations <= 5)
+            return 'LOW';
+        if (totalCustomizations <= 15)
+            return 'MEDIUM';
+        return 'HIGH';
+    }
+    determineAutoMigrate(toolchain, frameworks, plugins) {
+        const autoMigrate = [];
+        // Framework detection
+        if (frameworks.length > 0 && frameworks[0] !== 'unknown') {
+            autoMigrate.push(`Framework detection: ${frameworks.join(', ')}`);
+        }
+        // Basic config migration
+        if (toolchain !== 'unknown') {
+            autoMigrate.push('Entry points configuration');
+            autoMigrate.push('Output directory configuration');
+            autoMigrate.push('Development server settings');
+        }
+        // Common plugins that have Nuclie equivalents
+        const autoMigratablePlugins = [
+            '@vitejs/plugin-react',
+            '@vitejs/plugin-vue',
+            'vite-plugin-svelte',
+            'babel-loader',
+            'ts-loader',
+            'css-loader',
+            'style-loader',
+            'sass-loader'
+        ];
+        for (const plugin of plugins) {
+            if (autoMigratablePlugins.includes(plugin)) {
+                autoMigrate.push(`Plugin: ${plugin} → Nuclie preset`);
+            }
+        }
+        return autoMigrate;
+    }
+    determineManualSteps(toolchain, plugins, loaders) {
+        const manualSteps = [];
+        if (toolchain === 'unknown') {
+            manualSteps.push('Unable to detect build tool - manual configuration required');
+            return manualSteps;
+        }
+        // Custom plugins that need manual review
+        const customPlugins = plugins.filter(p => !p.startsWith('@vitejs/plugin-') &&
+            !p.startsWith('@rollup/plugin-') &&
+            !p.endsWith('-loader'));
+        if (customPlugins.length > 0) {
+            manualSteps.push(`Review custom plugins: ${customPlugins.join(', ')}`);
+        }
+        // Complex loaders
+        const complexLoaders = loaders.filter(l => l.includes('file-loader') ||
+            l.includes('url-loader') ||
+            l.includes('worker-loader'));
+        if (complexLoaders.length > 0) {
+            manualSteps.push(`Migrate asset handling: ${complexLoaders.join(', ')}`);
+        }
+        // Environment variables
+        manualSteps.push('Review environment variable usage (process.env → import.meta.env)');
+        // Build scripts
+        manualSteps.push('Update package.json scripts to use Nuclie commands');
+        return manualSteps;
+    }
+}
+// CLI helper
+export async function analyzeMigration(projectPath) {
+    const analyzer = new MigrationAnalyzer(projectPath);
+    return await analyzer.analyze();
+}

package/dist/migrate/cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Migration CLI Command (Day 44)
+ *
+ * CLI interface for nuclie migrate command
+ */
+export interface MigrateCommandOptions {
+    dryRun?: boolean;
+    backup?: boolean;
+}
+export declare function migrateCommand(projectPath: string, options?: MigrateCommandOptions): Promise<void>;

package/dist/migrate/cli.js

@@ -0,0 +1,63 @@
+/**
+ * Migration CLI Command (Day 44)
+ *
+ * CLI interface for nuclie migrate command
+ */
+import { MigrationAnalyzer } from './analyzer.js';
+import { MigrationGenerator } from './generator.js';
+import path from 'path';
+export async function migrateCommand(projectPath, options = {}) {
+    const resolvedPath = path.resolve(projectPath || process.cwd());
+    console.log('🔍 Analyzing project...');
+    console.log(`   Path: ${resolvedPath}\n`);
+    // Step 1: Analyze
+    const analyzer = new MigrationAnalyzer(resolvedPath);
+    const plan = await analyzer.analyze();
+    console.log('📊 Analysis Results:');
+    console.log(`   Toolchain: ${plan.toolchainType}`);
+    console.log(`   Frameworks: ${plan.frameworks.join(', ')}`);
+    console.log(`   Risk Level: ${plan.riskLevel}`);
+    console.log(`   Plugins: ${plan.plugins.length}`);
+    console.log(`   Loaders: ${plan.loaders.length}\n`);
+    if (plan.toolchainType === 'unknown') {
+        console.error('❌ Unable to detect build toolchain.');
+        console.error('   Supported: Vite, Webpack, Rollup, Angular CLI\n');
+        process.exit(1);
+    }
+    // Step 2: Generate
+    if (options.dryRun) {
+        console.log('🔍 DRY RUN MODE - No files will be modified\n');
+    }
+    else {
+        console.log('⚙️  Generating Nuclie configuration...\n');
+    }
+    const generator = new MigrationGenerator(plan, resolvedPath, {
+        dryRun: options.dryRun,
+        backup: options.backup ?? true
+    });
+    const result = await generator.generate();
+    if (result.success) {
+        console.log('✅ Migration configuration generated!\n');
+        console.log('📝 Files created/modified:');
+        for (const file of result.files) {
+            console.log(`   ${options.dryRun ? '[DRY RUN]' : '✓'} ${file}`);
+        }
+        console.log('');
+        if (!options.dryRun) {
+            console.log('📋 Migration Report:');
+            console.log('   See MIGRATION_REPORT.md for details\n');
+            console.log('🎯 Next Steps:');
+            console.log('   1. npm install');
+            console.log('   2. npm run dev');
+            console.log('   3. Review MIGRATION_REPORT.md for manual steps\n');
+        }
+        else {
+            console.log('📋 Preview of Migration Report:\n');
+            console.log(result.report);
+        }
+    }
+    else {
+        console.error('❌ Migration failed\n');
+        process.exit(1);
+    }
+}

package/dist/migrate/generator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Migration Generator (Day 44)
+ *
+ * Generates Nuclie project configuration from a MigrationPlan.
+ * Creates nuclie.config.ts, updates package.json, and generates migration report.
+ */
+import { MigrationPlan } from './analyzer.js';
+export interface GeneratorOptions {
+    dryRun?: boolean;
+    backup?: boolean;
+}
+export declare class MigrationGenerator {
+    private plan;
+    private targetDir;
+    private options;
+    constructor(plan: MigrationPlan, targetDir: string, options?: GeneratorOptions);
+    generate(): Promise<{
+        success: boolean;
+        report: string;
+        files: string[];
+    }>;
+    private backupExistingFiles;
+    private generateNuclieConfig;
+    private generatePackageJsonUpdates;
+    private updatePackageJson;
+    private generateMigrationReport;
+}
+export declare function generateMigration(plan: MigrationPlan, targetDir: string, options?: GeneratorOptions): Promise<{
+    success: boolean;
+    report: string;
+    files: string[];
+}>;

package/dist/migrate/generator.js

@@ -0,0 +1,214 @@
+/**
+ * Migration Generator (Day 44)
+ *
+ * Generates Nuclie project configuration from a MigrationPlan.
+ * Creates nuclie.config.ts, updates package.json, and generates migration report.
+ */
+import fs from 'fs';
+import path from 'path';
+export class MigrationGenerator {
+    constructor(plan, targetDir, options = {}) {
+        this.plan = plan;
+        this.targetDir = path.resolve(targetDir);
+        this.options = {
+            dryRun: options.dryRun ?? false,
+            backup: options.backup ?? true
+        };
+    }
+    async generate() {
+        const files = [];
+        // Backup existing files if not dry run
+        if (!this.options.dryRun && this.options.backup) {
+            this.backupExistingFiles();
+        }
+        // Generate nuclie.config.ts
+        const configContent = this.generateNuclieConfig();
+        files.push('nuclie.config.ts');
+        if (!this.options.dryRun) {
+            fs.writeFileSync(path.join(this.targetDir, 'nuclie.config.ts'), configContent);
+        }
+        // Update package.json
+        const packageJsonUpdates = this.generatePackageJsonUpdates();
+        files.push('package.json');
+        if (!this.options.dryRun) {
+            this.updatePackageJson(packageJsonUpdates);
+        }
+        // Generate migration report
+        const report = this.generateMigrationReport();
+        files.push('MIGRATION_REPORT.md');
+        if (!this.options.dryRun) {
+            fs.writeFileSync(path.join(this.targetDir, 'MIGRATION_REPORT.md'), report);
+        }
+        return {
+            success: true,
+            report,
+            files
+        };
+    }
+    backupExistingFiles() {
+        const backupDir = path.join(this.targetDir, '.nuclie-migration-backup');
+        if (!fs.existsSync(backupDir)) {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+        const filesToBackup = ['package.json'];
+        // Backup old config files
+        const oldConfigs = [
+            'vite.config.js', 'vite.config.ts', 'vite.config.mjs',
+            'webpack.config.js', 'webpack.config.ts',
+            'rollup.config.js', 'rollup.config.ts',
+            'angular.json'
+        ];
+        for (const file of [...filesToBackup, ...oldConfigs]) {
+            const srcPath = path.join(this.targetDir, file);
+            if (fs.existsSync(srcPath)) {
+                const destPath = path.join(backupDir, file);
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    generateNuclieConfig() {
+        const { frameworks, cssSetup, projectStructure } = this.plan;
+        const primaryFramework = frameworks[0] || 'react';
+        // Determine preset
+        let preset = 'spa';
+        // Could be enhanced to detect SSR/SSG from existing config
+        // Build config object
+        const config = {
+            root: '.',
+            entry: projectStructure.entryPoints.length > 0
+                ? projectStructure.entryPoints
+                : ['src/main.ts'],
+            mode: 'development',
+            outDir: 'dist',
+            port: 3000,
+            platform: 'browser',
+            preset,
+        };
+        // Add framework if detected
+        if (primaryFramework !== 'unknown') {
+            config.framework = primaryFramework;
+        }
+        // Add CSS configuration
+        if (cssSetup.hasTailwind || cssSetup.hasSass || cssSetup.hasCSSModules) {
+            config.css = {};
+            if (cssSetup.hasTailwind) {
+                config.css.framework = 'tailwind';
+            }
+            config.css.purge = true;
+            config.css.critical = true;
+        }
+        // Add build optimizations
+        config.build = {
+            minify: true,
+            sourcemap: 'external',
+            splitting: true
+        };
+        // Generate TypeScript config file
+        return `import { defineConfig } from 'nuclie';
+
+export default defineConfig(${JSON.stringify(config, null, 2)});
+`;
+    }
+    generatePackageJsonUpdates() {
+        const scripts = {
+            'dev': 'nuclie dev',
+            'build': 'nuclie build',
+            'preview': 'nuclie preview',
+            'test': 'nuclie test',
+            'audit': 'nuclie audit'
+        };
+        // Mark old scripts as deprecated
+        const deprecatedScripts = {};
+        switch (this.plan.toolchainType) {
+            case 'vite':
+                deprecatedScripts['dev:vite'] = 'vite # DEPRECATED: Use npm run dev';
+                deprecatedScripts['build:vite'] = 'vite build # DEPRECATED: Use npm run build';
+                break;
+            case 'webpack':
+                deprecatedScripts['dev:webpack'] = 'webpack serve # DEPRECATED: Use npm run dev';
+                deprecatedScripts['build:webpack'] = 'webpack # DEPRECATED: Use npm run build';
+                break;
+            case 'angular-cli':
+                deprecatedScripts['ng'] = 'ng # DEPRECATED: Use nuclie commands';
+                break;
+        }
+        return {
+            scripts: { ...scripts, ...deprecatedScripts },
+            devDependencies: {
+                'nuclie': '^2.0.0'
+            }
+        };
+    }
+    updatePackageJson(updates) {
+        const pkgPath = path.join(this.targetDir, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        // Merge scripts
+        pkg.scripts = {
+            ...pkg.scripts,
+            ...updates.scripts
+        };
+        // Add Nuclie to devDependencies
+        pkg.devDependencies = {
+            ...pkg.devDependencies,
+            ...updates.devDependencies
+        };
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    }
+    generateMigrationReport() {
+        const { toolchainType, frameworks, riskLevel, autoMigrate, manualSteps, cssSetup } = this.plan;
+        let report = `# Nuclie Migration Report\n\n`;
+        report += `**Generated**: ${new Date().toISOString()}\n\n`;
+        report += `## Source Project\n\n`;
+        report += `- **Toolchain**: ${toolchainType}\n`;
+        report += `- **Frameworks**: ${frameworks.join(', ')}\n`;
+        report += `- **Risk Level**: ${riskLevel}\n\n`;
+        report += `## CSS Setup\n\n`;
+        report += `- Tailwind: ${cssSetup.hasTailwind ? '✅' : '❌'}\n`;
+        report += `- Sass/SCSS: ${cssSetup.hasSass ? '✅' : '❌'}\n`;
+        report += `- CSS Modules: ${cssSetup.hasCSSModules ? '✅' : '❌'}\n`;
+        report += `- CSS-in-JS: ${cssSetup.hasCSSInJS ? `✅ (${cssSetup.cssInJSLibrary})` : '❌'}\n\n`;
+        report += `## Auto-Migrated ✅\n\n`;
+        report += `The following items have been automatically configured:\n\n`;
+        for (const item of autoMigrate) {
+            report += `- ${item}\n`;
+        }
+        report += `\n`;
+        report += `## Manual Steps Required ⚠️\n\n`;
+        report += `Please complete the following steps manually:\n\n`;
+        for (let i = 0; i < manualSteps.length; i++) {
+            report += `${i + 1}. ${manualSteps[i]}\n`;
+        }
+        report += `\n`;
+        report += `## Next Steps\n\n`;
+        report += `1. Review the generated \`nuclie.config.ts\`\n`;
+        report += `2. Install dependencies: \`npm install\`\n`;
+        report += `3. Start dev server: \`npm run dev\`\n`;
+        report += `4. Test your application thoroughly\n`;
+        report += `5. Update CI/CD pipelines to use Nuclie commands\n\n`;
+        report += `## Known Limitations\n\n`;
+        if (riskLevel === 'HIGH') {
+            report += `⚠️ **HIGH RISK**: This project has many customizations. `;
+            report += `Expect significant manual work to complete migration.\n\n`;
+        }
+        else if (riskLevel === 'MEDIUM') {
+            report += `⚠️ **MEDIUM RISK**: Some custom plugins/loaders detected. `;
+            report += `Review and test carefully.\n\n`;
+        }
+        else {
+            report += `✅ **LOW RISK**: Standard project structure. `;
+            report += `Migration should be straightforward.\n\n`;
+        }
+        report += `## Support\n\n`;
+        report += `- Documentation: https://nuclie.dev/docs/migration\n`;
+        report += `- Issues: https://github.com/nuclie/nuclie/issues\n`;
+        report += `- Discord: https://discord.gg/nuclie\n\n`;
+        report += `---\n\n`;
+        report += `*This report was generated by Nuclie Migration Tool v2.0*\n`;
+        return report;
+    }
+}
+// CLI helper
+export async function generateMigration(plan, targetDir, options) {
+    const generator = new MigrationGenerator(plan, targetDir, options);
+    return await generator.generate();
+}

package/dist/native/cache.d.ts

@@ -0,0 +1,86 @@
+import type { CacheStats } from '../../nuclie_native.node';
+export { CacheStats };
+/**
+ * RocksDB-based persistent build cache
+ *
+ * Features:
+ * - LSM tree architecture for efficient writes
+ * - Automatic compaction and cleanup
+ * - Multi-target support (dev/prod/lib)
+ * - Cache warming and invalidation
+ *
+ * @example
+ * ```ts
+ * const cache = new BuildCache('.nuclie_cache');
+ *
+ * // Set a value
+ * cache.set('input:src/App.tsx:abc123', JSON.stringify(transformResult));
+ *
+ * // Get a value
+ * const cached = cache.get('input:src/App.tsx:abc123');
+ *
+ * // Get statistics
+ * const stats = cache.getStats();
+ * console.log(`Hit rate: ${stats.hitRate}%`);
+ * ```
+ */
+export declare class BuildCache {
+    private cache;
+    constructor(cachePath: string);
+    /**
+     * Get a value from the cache
+     */
+    get(key: string): string | null;
+    /**
+     * Set a value in the cache
+     */
+    set(key: string, value: string): void;
+    /**
+     * Delete a value from the cache
+     */
+    delete(key: string): void;
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key: string): boolean;
+    /**
+     * Batch set multiple key-value pairs
+     */
+    batchSet(entries: Record<string, string>): void;
+    /**
+     * Clear all entries for a specific target (dev/prod/lib)
+     */
+    clearTarget(target: 'dev' | 'prod' | 'lib'): number;
+    /**
+     * Clear all cache entries
+     */
+    clearAll(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Compact the database to reclaim space
+     */
+    compact(): void;
+    /**
+     * Close the cache (cleanup)
+     */
+    close(): void;
+}
+/**
+ * Create cache key for input fingerprint
+ */
+export declare function createInputKey(filePath: string, contentHash: string): string;
+/**
+ * Create cache key for graph hash
+ */
+export declare function createGraphKey(graphHash: string): string;
+/**
+ * Create cache key for plan hash
+ */
+export declare function createPlanKey(planHash: string, target: string): string;
+/**
+ * Create cache key for artifact
+ */
+export declare function createArtifactKey(artifactId: string, target: string): string;