neutrinos-cli 2.0.0-beta.5 → 2.0.0-beta.7

package/README.md

@@ -41,6 +41,7 @@ neutrinos <command> [options]
 | `deprecate [name]` | Deprecate a published package |
 | `auth` | Login or check auth state |
 | `doctor` | Check workspace health (`--fix` to auto-repair) |
+| `migrate` | Migrate workspace to current CLI version (`--dry-run` to preview) |
 | `completion <shell>` | Output shell completion script (`bash` or `zsh`) |
 
 ### `new <name>`
@@ -114,20 +115,37 @@ neutrinos doctor        # Run all health checks
 neutrinos doctor --fix  # Auto-fix what it can
 ```
 
-Runs 10 workspace health checks and reports pass/warn/fail for each:
+Runs 14 workspace health checks and reports pass/warn/fail for each:
 
 - `node_modules` — Dependencies installed
 - `plugin.json` — Exists with required fields (`name`, `components.selectorPrefix`, `modules.idPrefix`)
 - `package.json` — Has `workspaces`, `type: "module"`, expected dependencies
 - `tsconfig.json` — Exists and is valid (verified via `tsc --showConfig`)
 - `plugins-server/` — Directory exists with `index.js`
+- `.storybook/` — Storybook config exists with `main.ts` and `preview.ts`
+- `vitest.config.ts` — Vitest config exists
 - Package `alpha` block — Each package has `alpha.component` or `alpha.module`
 - Component entry file — Component packages have a matching `<name>.ts` file
 - Node version — Meets `>=22` requirement
 - Auth state — Token file exists and is not expired
 - Lock file sync — Lock file is up to date with `package.json`
+- CLI update available — Checks npm registry for newer versions
+- Local CLI version — `devDependencies['neutrinos-cli']` matches running CLI
 
-`--fix` auto-repairs: missing `node_modules` (runs install), `plugin.json` defaults, `workspaces`/`type` in `package.json`, `plugins-server/` from template, missing `alpha` blocks, stale lock files.
+`--fix` auto-repairs: missing `node_modules` (runs install), `plugin.json` defaults, `workspaces`/`type` in `package.json`, `plugins-server/` from template, `.storybook/` from template, `vitest.config.ts` from template, missing `alpha` blocks, stale lock files.
+
+### `migrate`
+
+```sh
+neutrinos migrate              # Migrate workspace to current CLI version
+neutrinos migrate --dry-run    # Preview changes without writing
+```
+
+Upgrades an existing workspace to match the current CLI version. Handles dependency updates, Storybook config scaffolding, file cleanup, and version pinning.
+
+The migration enforces git safety: it errors on dirty working trees, auto-inits git if absent, and commits changes on success. All steps are idempotent — safe to re-run after `git checkout .`.
+
+Version tracking uses `devDependencies['neutrinos-cli']` — no separate schema version field.
 
 ### `auth`
 

package/dist/src/bin/cli.js

@@ -45,6 +45,7 @@ import { startPluginsServer } from '../commands/serve.js';
 import { runTests } from '../commands/test.js';
 import { completion } from '../commands/completion.js';
 import { doctor } from '../commands/doctor.js';
+import { migrate } from '../commands/migrate.js';
 import { getPackages } from '../utils/get-packages.js';
 import { validateWorkspace } from '../utils/check-valid-ws.js';
 import { done, failed, inprogress, log } from '../utils/logger.js';
@@ -225,6 +226,13 @@ export const createProgram = () => {
         .action((options) => {
         doctor(cwd(), options);
     });
+    program
+        .command('migrate')
+        .description('Migrate workspace to current CLI version')
+        .option('--dry-run', 'Preview changes without writing')
+        .action((options) => {
+        migrate(cwd(), options);
+    });
     program
         .command('__list-packages', { hidden: true })
         .description('List workspace package names (used by shell completion)')
@@ -242,7 +250,7 @@ export const createProgram = () => {
     });
     program.hook('preAction', async (_thisCmd, actionCmd) => {
         const cmd = actionCmd.name();
-        if (cmd === 'new' || cmd === 'login' || cmd === 'completion' || cmd === '__list-packages' || cmd === 'doctor') {
+        if (cmd === 'new' || cmd === 'login' || cmd === 'completion' || cmd === '__list-packages' || cmd === 'doctor' || cmd === 'migrate') {
             return;
         }
         if (!validateWorkspace(cwd())) {

package/dist/src/commands/migrate.js

@@ -0,0 +1,4 @@
+import { runMigration } from '../utils/migrate-runner.js';
+export function migrate(wsPath, opts) {
+    runMigration(wsPath, opts);
+}

package/dist/src/types/migrate.js

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

package/dist/src/utils/doctor-checks/cli-update-available.js

@@ -0,0 +1,30 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { getCliPackagePath } from '../path-utils.js';
+export const cliUpdateAvailableCheck = {
+    name: 'CLI update available',
+    run() {
+        const { version: current } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
+        const isBeta = current.includes('-beta');
+        const tag = isBeta ? 'beta' : 'latest';
+        try {
+            const output = execSync('npm view neutrinos-cli dist-tags --json', {
+                stdio: 'pipe',
+                encoding: 'utf-8',
+                timeout: 3000,
+            });
+            const tags = JSON.parse(output);
+            const latest = tags[tag];
+            if (!latest) {
+                return [{ name: 'CLI update available', status: 'pass', message: `v${current} (could not determine ${tag} tag)`, fixable: false }];
+            }
+            if (latest === current) {
+                return [{ name: 'CLI update available', status: 'pass', message: `v${current} is the latest ${tag}`, fixable: false }];
+            }
+            return [{ name: 'CLI update available', status: 'warn', message: `v${current} → v${latest} available. Run "npm i -g neutrinos-cli@${tag}"`, fixable: false }];
+        }
+        catch {
+            return [{ name: 'CLI update available', status: 'warn', message: `v${current} (could not reach npm registry)`, fixable: false }];
+        }
+    },
+};

package/dist/src/utils/doctor-checks/index.js

@@ -10,6 +10,8 @@ import { componentEntryFileCheck } from './component-entry-file.js';
 import { nodeVersionCheck } from './node-version.js';
 import { authStateCheck } from './auth-state.js';
 import { lockFileSyncCheck } from './lock-file-sync.js';
+import { cliUpdateAvailableCheck } from './cli-update-available.js';
+import { localCliVersionCheck } from './local-cli-version.js';
 export const checks = [
     nodeModulesCheck,
     pluginJsonCheck,
@@ -23,4 +25,6 @@ export const checks = [
     nodeVersionCheck,
     authStateCheck,
     lockFileSyncCheck,
+    cliUpdateAvailableCheck,
+    localCliVersionCheck,
 ];

package/dist/src/utils/doctor-checks/local-cli-version.js

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getCliPackagePath } from '../path-utils.js';
+export const localCliVersionCheck = {
+    name: 'Local CLI version',
+    run(wsPath) {
+        const installedPkgPath = join(wsPath, 'node_modules', 'neutrinos-cli', 'package.json');
+        if (!existsSync(installedPkgPath)) {
+            return [{ name: 'Local CLI version', status: 'warn', message: 'neutrinos-cli not installed locally. Run "npm install"', fixable: false }];
+        }
+        const { version: localVersion } = JSON.parse(readFileSync(installedPkgPath, 'utf-8'));
+        const { version: runningVersion } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
+        if (localVersion === runningVersion) {
+            return [{ name: 'Local CLI version', status: 'pass', message: `v${localVersion} matches running CLI`, fixable: false }];
+        }
+        return [{ name: 'Local CLI version', status: 'warn', message: `v${localVersion} differs from running v${runningVersion}. Run "neutrinos migrate"`, fixable: false }];
+    },
+};

package/dist/src/utils/migrate-runner.js

@@ -0,0 +1,115 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { bold, greenBright, red, yellowBright } from 'colorette';
+import { log as _log } from 'node:console';
+import { getCliPackagePath } from './path-utils.js';
+import { migrations } from './migrations/index.js';
+import { compareVersions } from './migrations/version-compare.js';
+import { failed } from './logger.js';
+const SYMBOLS = {
+    pass: greenBright('✔'),
+    warn: yellowBright('⚠'),
+    skip: yellowBright('–'),
+    fail: red('✖'),
+};
+const colorize = {
+    pass: greenBright,
+    warn: yellowBright,
+    skip: yellowBright,
+    fail: red,
+};
+function printResult(result) {
+    const sym = SYMBOLS[result.status];
+    const color = colorize[result.status];
+    _log(`  ${sym} ${color(`${result.name} — ${result.message}`)}`);
+}
+function getWorkspaceCliVersion(wsPath) {
+    const installedPkgPath = join(wsPath, 'node_modules', 'neutrinos-cli', 'package.json');
+    if (!existsSync(installedPkgPath))
+        return null;
+    const { version } = JSON.parse(readFileSync(installedPkgPath, 'utf-8'));
+    return version;
+}
+function getRunningCliVersion() {
+    const { version } = JSON.parse(readFileSync(getCliPackagePath(), 'utf-8'));
+    return version;
+}
+function isGitRepo(wsPath) {
+    try {
+        execSync('git rev-parse --is-inside-work-tree', { cwd: wsPath, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isGitDirty(wsPath) {
+    const output = execSync('git status --porcelain', { cwd: wsPath, encoding: 'utf-8' });
+    return output.trim().length > 0;
+}
+function gitSnapshot(wsPath) {
+    execSync('git init', { cwd: wsPath, stdio: 'pipe' });
+    execSync('git add -A', { cwd: wsPath, stdio: 'pipe' });
+    execSync('git commit -m "chore: snapshot before migration"', { cwd: wsPath, stdio: 'pipe' });
+}
+function gitCommit(wsPath, version) {
+    execSync('git add -A', { cwd: wsPath, stdio: 'pipe' });
+    execSync(`git commit -m "chore: migrate workspace to neutrinos-cli@${version}"`, { cwd: wsPath, stdio: 'pipe' });
+}
+export function runMigration(wsPath, opts) {
+    const dryRun = opts.dryRun ?? false;
+    if (!existsSync(join(wsPath, 'node_modules'))) {
+        failed('node_modules not found. Run "npm install" before migrating.');
+        process.exit(1);
+    }
+    const cliVersion = getRunningCliVersion();
+    const wsVersion = getWorkspaceCliVersion(wsPath);
+    if (wsVersion && compareVersions(wsVersion, cliVersion) >= 0) {
+        _log(greenBright('\nAlready up to date.\n'));
+        return;
+    }
+    // Filter applicable migrations
+    const applicable = migrations.filter((m) => {
+        if (!wsVersion)
+            return true;
+        return compareVersions(m.targetVersion, wsVersion) > 0;
+    });
+    if (applicable.length === 0) {
+        _log(greenBright('\nAlready up to date.\n'));
+        return;
+    }
+    // Git safety (skip for dry-run)
+    if (!dryRun) {
+        if (!isGitRepo(wsPath)) {
+            _log(yellowBright('\nNo git repository found. Initializing and creating snapshot...\n'));
+            gitSnapshot(wsPath);
+        }
+        else if (isGitDirty(wsPath)) {
+            failed('Working tree has uncommitted changes. Commit or stash before migrating.');
+            process.exit(1);
+        }
+    }
+    const prefix = dryRun ? bold('[dry-run] ') : '';
+    for (const migration of applicable) {
+        _log(`\n${prefix}Migration: → v${migration.targetVersion}`);
+        _log(`${prefix}${migration.description}`);
+        _log('──────────────────────────\n');
+        const results = migration.steps(wsPath, dryRun);
+        let hasFail = false;
+        for (const r of results) {
+            printResult(r);
+            if (r.status === 'fail')
+                hasFail = true;
+        }
+        if (hasFail) {
+            _log(red('\n\nMigration failed. Fix the issues above and re-run.\n'));
+            process.exit(1);
+        }
+    }
+    if (!dryRun) {
+        const lastVersion = applicable[applicable.length - 1].targetVersion;
+        gitCommit(wsPath, lastVersion);
+    }
+    _log(greenBright(`\n${prefix}Migration complete.`) + ' Run "neutrinos doctor" to verify.\n');
+}

package/dist/src/utils/migrations/2.0.0-beta.7.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const migration = {
+    targetVersion: '2.0.0-beta.7',
+    description: 'Bump tsconfig target to ESNext, replace deprecated esbuild with oxc in Storybook config',
+    steps(wsPath, dryRun) {
+        const results = [];
+        // Step 1: Update tsconfig.json target and lib to ESNext
+        const tsconfigPath = join(wsPath, 'tsconfig.json');
+        if (!existsSync(tsconfigPath)) {
+            results.push({ name: 'tsconfig.json', status: 'skip', message: 'File not found' });
+        }
+        else {
+            const raw = readFileSync(tsconfigPath, 'utf-8');
+            const tsconfig = JSON.parse(raw);
+            const opts = tsconfig.compilerOptions ?? {};
+            let changed = false;
+            if (opts['target'] !== 'ESNext') {
+                opts['target'] = 'ESNext';
+                changed = true;
+            }
+            if (Array.isArray(opts['lib'])) {
+                const lib = opts['lib'];
+                const updated = lib.map((l) => /^ES\d{4}$/i.test(l) ? 'ESNext' : l);
+                if (JSON.stringify(updated) !== JSON.stringify(lib)) {
+                    opts['lib'] = updated;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                tsconfig.compilerOptions = opts;
+                if (!dryRun)
+                    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 4) + '\n');
+                results.push({ name: 'tsconfig.json', status: 'pass', message: 'Updated target and lib to ESNext' });
+            }
+            else {
+                results.push({ name: 'tsconfig.json', status: 'skip', message: 'Already at ESNext' });
+            }
+        }
+        // Step 2: Replace deprecated esbuild config with build.keepNames in .storybook/main.ts
+        const mainTsPath = join(wsPath, '.storybook', 'main.ts');
+        if (!existsSync(mainTsPath)) {
+            results.push({ name: '.storybook/main.ts', status: 'skip', message: 'File not found' });
+        }
+        else {
+            let content = readFileSync(mainTsPath, 'utf-8');
+            if (content.includes('esbuild')) {
+                // Replace the esbuild-based viteFinal with the oxc-compatible version
+                const updatedViteFinal = `    async viteFinal(config) {
+        return {
+            ...config,
+            build: {
+                ...config.build,
+                keepNames: true,
+            },
+        };
+    },`;
+                // Match the viteFinal block regardless of formatting
+                const viteFinalPattern = /async\s+viteFinal\s*\(config\)\s*\{[\s\S]*?\n    \},/;
+                if (viteFinalPattern.test(content)) {
+                    content = content.replace(viteFinalPattern, updatedViteFinal);
+                    if (!dryRun)
+                        writeFileSync(mainTsPath, content);
+                    results.push({ name: '.storybook/main.ts', status: 'pass', message: 'Replaced deprecated esbuild config with build.keepNames' });
+                }
+                else {
+                    results.push({ name: '.storybook/main.ts', status: 'warn', message: 'Contains "esbuild" but viteFinal pattern not recognized. Update manually' });
+                }
+            }
+            else {
+                results.push({ name: '.storybook/main.ts', status: 'skip', message: 'No esbuild config found' });
+            }
+        }
+        return results;
+    },
+};

package/dist/src/utils/migrations/2.0.0.js

@@ -0,0 +1,156 @@
+import { cpSync, existsSync, globSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { templatesPath } from '../path-utils.js';
+// ── Frozen dependency targets for v2.0.0 ───────────────────────────
+// These are snapshot values — never change them after release.
+// Future dep bumps go in the next migration file.
+const TARGET_DEPS = {
+    'express': '^5.2.1',
+    '@jatahworx/alpha-annotations-lib': '^1.0.12',
+};
+const TARGET_DEV_DEPS = {
+    'neutrinos-cli': '^2.0.0',
+    'lit': '^3.3.2',
+    'typescript': '^5.9.3',
+    'storybook': '^10.3.1',
+    '@storybook/web-components-vite': '^10.3.1',
+    '@storybook/addon-vitest': '^10.3.1',
+    'vitest': '^4.0.0',
+    '@vitest/browser': '^4.0.0',
+    '@vitest/browser-playwright': '^4.0.0',
+};
+export const migration = {
+    targetVersion: '2.0.0',
+    description: 'Upgrade workspace from v1.0.x to v2.0.0 (Storybook, updated deps, cleanup)',
+    steps(wsPath, dryRun) {
+        const results = [];
+        // Step 1: Node version check
+        const [major] = process.versions.node.split('.').map(Number);
+        if (major < 22) {
+            results.push({ name: 'Node version', status: 'fail', message: `v${process.versions.node} < 22. Install Node.js 22+ before migrating` });
+            return results;
+        }
+        results.push({ name: 'Node version', status: 'pass', message: `v${process.versions.node} meets requirement` });
+        // Read package.json once
+        const pkgPath = join(wsPath, 'package.json');
+        if (!existsSync(pkgPath)) {
+            results.push({ name: 'Root package.json', status: 'fail', message: 'File is missing — cannot migrate' });
+            return results;
+        }
+        const pkgJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        // Step 2: type: "module"
+        if (pkgJson.type !== 'module') {
+            pkgJson.type = 'module';
+            results.push({ name: 'Root package.json', status: 'pass', message: 'Added type: "module"' });
+        }
+        else {
+            results.push({ name: 'Root package.json', status: 'skip', message: 'type: "module" already set' });
+        }
+        // Step 3: Remove old npm scripts
+        const oldScripts = ['build', 'start', 'serve'];
+        const removed = oldScripts.filter((s) => pkgJson.scripts?.[s]);
+        if (removed.length > 0) {
+            pkgJson.scripts = {};
+            results.push({ name: 'npm scripts', status: 'pass', message: `Removed: ${removed.join(', ')}` });
+        }
+        else {
+            results.push({ name: 'npm scripts', status: 'skip', message: 'No old scripts to remove' });
+        }
+        // Steps 4-5: Update dependencies
+        pkgJson.dependencies ??= {};
+        for (const [dep, version] of Object.entries(TARGET_DEPS)) {
+            if (pkgJson.dependencies[dep] && pkgJson.dependencies[dep] !== version) {
+                pkgJson.dependencies[dep] = version;
+                results.push({ name: `dependency ${dep}`, status: 'pass', message: `Updated to ${version}` });
+            }
+            else if (!pkgJson.dependencies[dep]) {
+                results.push({ name: `dependency ${dep}`, status: 'skip', message: 'Not present in workspace' });
+            }
+            else {
+                results.push({ name: `dependency ${dep}`, status: 'skip', message: `Already at ${version}` });
+            }
+        }
+        // Steps 6-14: Update/add devDependencies
+        pkgJson.devDependencies ??= {};
+        for (const [dep, version] of Object.entries(TARGET_DEV_DEPS)) {
+            const current = pkgJson.devDependencies[dep];
+            if (!current) {
+                pkgJson.devDependencies[dep] = version;
+                results.push({ name: `devDependency ${dep}`, status: 'pass', message: `Added ${version}` });
+            }
+            else if (current !== version) {
+                pkgJson.devDependencies[dep] = version;
+                results.push({ name: `devDependency ${dep}`, status: 'pass', message: `Updated ${current} → ${version}` });
+            }
+            else {
+                results.push({ name: `devDependency ${dep}`, status: 'skip', message: `Already at ${version}` });
+            }
+        }
+        // Step 15: Copy .storybook/
+        const storybookDir = join(wsPath, '.storybook');
+        const storybookTemplate = join(templatesPath(), 'project', '.storybook');
+        if (!existsSync(storybookDir)) {
+            if (!dryRun)
+                cpSync(storybookTemplate, storybookDir, { recursive: true });
+            results.push({ name: '.storybook/', status: 'pass', message: 'Copied from template' });
+        }
+        else {
+            results.push({ name: '.storybook/', status: 'skip', message: 'Already exists' });
+        }
+        // Step 16: Copy vitest.config.ts
+        const vitestConfig = join(wsPath, 'vitest.config.ts');
+        const vitestTemplate = join(templatesPath(), 'project', 'vitest.config.ts');
+        if (!existsSync(vitestConfig)) {
+            if (!dryRun)
+                cpSync(vitestTemplate, vitestConfig);
+            results.push({ name: 'vitest.config.ts', status: 'pass', message: 'Copied from template' });
+        }
+        else {
+            results.push({ name: 'vitest.config.ts', status: 'skip', message: 'Already exists' });
+        }
+        // Steps 17-20: Delete obsolete files
+        const deletions = [
+            ['Dockerfile', false],
+            ['helmchart', true],
+            ['index.html', false],
+            ['index.ts', false],
+        ];
+        for (const [name, recursive] of deletions) {
+            const path = join(wsPath, name);
+            if (existsSync(path)) {
+                if (!dryRun)
+                    rmSync(path, { recursive });
+                results.push({ name, status: 'pass', message: 'Removed' });
+            }
+            else {
+                results.push({ name, status: 'skip', message: 'Already absent' });
+            }
+        }
+        // Step 21: Scan for plginId typo in module files
+        try {
+            const moduleFiles = globSync('packages/*/*.js', { cwd: wsPath });
+            const affected = [];
+            for (const file of moduleFiles) {
+                const content = readFileSync(join(wsPath, file), 'utf-8');
+                if (content.includes('plginId')) {
+                    affected.push(file);
+                }
+            }
+            if (affected.length > 0) {
+                results.push({ name: 'plginId typo', status: 'warn', message: `Found in: ${affected.join(', ')}. Rename to "pluginId" manually` });
+            }
+            else {
+                results.push({ name: 'plginId typo', status: 'pass', message: 'No occurrences found' });
+            }
+        }
+        catch {
+            results.push({ name: 'plginId typo', status: 'skip', message: 'Could not scan packages' });
+        }
+        // Step 22: Write package.json (single write)
+        if (!dryRun) {
+            writeFileSync(pkgPath, JSON.stringify(pkgJson, null, 4) + '\n');
+        }
+        results.push({ name: 'package.json', status: 'pass', message: 'Written with all updates' });
+        return results;
+    },
+};

package/dist/src/utils/migrations/index.js

@@ -0,0 +1,14 @@
+import { compareVersions } from './version-compare.js';
+import { migration as v200 } from './2.0.0.js';
+import { migration as v200beta7 } from './2.0.0-beta.7.js';
+// Migration registry — ordered by targetVersion ascending.
+// Add new migrations here. The runner applies them in this order.
+export const migrations = [v200beta7, v200];
+// Validate ordering at import time
+for (let i = 1; i < migrations.length; i++) {
+    const prev = migrations[i - 1];
+    const curr = migrations[i];
+    if (compareVersions(prev.targetVersion, curr.targetVersion) >= 0) {
+        throw new Error(`Migration ordering error: ${prev.targetVersion} must come before ${curr.targetVersion}`);
+    }
+}

package/dist/src/utils/migrations/version-compare.js

@@ -0,0 +1,47 @@
+/**
+ * Compare two semver strings. Returns negative if a < b, 0 if equal, positive if a > b.
+ * Handles: major.minor.patch and major.minor.patch-prerelease.N
+ * Prerelease versions are less than their release counterpart (2.0.0-beta.3 < 2.0.0).
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [main, ...preParts] = v.split('-');
+        const parts = main.split('.').map(Number);
+        const pre = preParts.length > 0 ? preParts.join('-') : null;
+        return { parts, pre };
+    };
+    const va = parse(a);
+    const vb = parse(b);
+    for (let i = 0; i < 3; i++) {
+        const diff = (va.parts[i] ?? 0) - (vb.parts[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    // Same main version: release > prerelease
+    if (!va.pre && !vb.pre)
+        return 0;
+    if (!va.pre)
+        return 1;
+    if (!vb.pre)
+        return -1;
+    // Both have prerelease — compare segments
+    const aParts = va.pre.split('.');
+    const bParts = vb.pre.split('.');
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const ap = aParts[i] ?? '';
+        const bp = bParts[i] ?? '';
+        const an = Number(ap);
+        const bn = Number(bp);
+        if (!isNaN(an) && !isNaN(bn)) {
+            if (an !== bn)
+                return an - bn;
+        }
+        else {
+            if (ap < bp)
+                return -1;
+            if (ap > bp)
+                return 1;
+        }
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "neutrinos-cli",
-    "version": "2.0.0-beta.5",
+    "version": "2.0.0-beta.7",
     "type": "module",
     "bin": {
         "neutrinos": "./dist/src/bin/cli.js"

package/templates/component/.component.ts.hbs

@@ -68,9 +68,9 @@ export class {{componentClassName}} extends LitElement {
 
     render() {
         return html`
-            <button @click=${this.increment}>+</button>
+            <button ?disabled=${this.disabled} @click=${this.increment}>+</button>
             ${this.value || 0}
-            <button @click=${this.decrement}>-</button>
+            <button ?disabled=${this.disabled} @click=${this.decrement}>-</button>
         `;
     }
 

package/templates/component/.stories.ts.hbs

@@ -50,4 +50,10 @@ export const Default: Story = {
 
 export const Disabled: Story = {
     args: { disabled: true },
+    play: async ({ canvasElement }) => {
+        const el = canvasElement.querySelector(TAG)!;
+        const buttons = el.shadowRoot!.querySelectorAll('button');
+        await expect(buttons[0]!).toBeDisabled();
+        await expect(buttons[1]!).toBeDisabled();
+    },
 };

package/templates/project/.storybook/main.ts

@@ -7,9 +7,8 @@ const config: StorybookConfig = {
     async viteFinal(config) {
         return {
             ...config,
-            esbuild: {
-                ...config.esbuild,
-                target: 'es2020',
+            build: {
+                ...config.build,
                 keepNames: true,
             },
         };

package/templates/project/tsconfig.json

@@ -1,8 +1,8 @@
 {
     "compilerOptions": {
-        "target": "ES2020",
+        "target": "ESNext",
         "module": "ESNext",
-        "lib": ["ES2020", "DOM", "DOM.Iterable"],
+        "lib": ["ESNext", "DOM", "DOM.Iterable"],
         "skipLibCheck": true,
 
         /* Bundler mode */