@bsb/base 9.1.5 → 9.1.8

package/lib/scripts/bsb-plugin-cli.js

@@ -13,9 +13,11 @@
  *   bsb-plugin-cli clean   - Remove build artifacts
  */
 import { execSync, execFileSync, spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { createRequire } from 'node:module';
+import chokidar from 'chokidar';
 import { getModuleDir, toImportUrl } from '../base/module-runtime.js';
 // Colors for terminal output
 const colors = {
@@ -44,6 +46,236 @@ function info(message) {
 const CWD = process.cwd();
 const COMMAND = process.argv[2];
 const MODULE_DIR = getModuleDir(import.meta.url);
+const BSB_DIR = path.join(CWD, 'src', '.bsb');
+const CACHE_DIR = path.join(BSB_DIR, 'cache');
+const BUILD_CACHE_PATH = path.join(CACHE_DIR, 'build-state.json');
+const TSC_BUILD_INFO_PATH = path.join(CACHE_DIR, 'tsc.tsbuildinfo');
+const DEV_WATCH_PATHS = [
+    path.join(CWD, 'package.json'),
+    path.join(CWD, 'sec-config.yaml'),
+    path.join(CWD, 'src'),
+];
+const DEV_IGNORE_PATHS = [
+    path.join(CWD, '.git'),
+    path.join(CWD, 'lib'),
+    path.join(CWD, 'node_modules'),
+    path.join(CWD, 'src', '.bsb'),
+];
+const SCHEMA_FILE_BASENAMES = new Set([
+    'index.ts',
+    'index.tsx',
+    'config.ts',
+    'config.tsx',
+    'events.ts',
+    'events.tsx',
+    'schema.ts',
+    'schema.tsx',
+    'schemas.ts',
+    'schemas.tsx',
+    'types.ts',
+    'types.tsx',
+]);
+function readPackageJson() {
+    const packageJsonPath = path.join(CWD, 'package.json');
+    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+}
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+function normalizePath(inputPath) {
+    return inputPath.replace(/\\/g, '/');
+}
+function normalizeChangedPath(filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? path.relative(CWD, filePath) : filePath;
+    return normalizePath(resolvedPath);
+}
+function hashStrings(values) {
+    const hash = createHash('sha256');
+    for (const value of values.sort()) {
+        hash.update(value);
+        hash.update('\n');
+    }
+    return hash.digest('hex');
+}
+function hashFile(filePath) {
+    const hash = createHash('sha256');
+    hash.update(fs.readFileSync(filePath));
+    return hash.digest('hex');
+}
+function collectFilesRecursive(dirPath, predicate) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    const files = [];
+    const stack = [dirPath];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const entries = fs.readdirSync(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+            }
+            else if (entry.isFile() && predicate(fullPath)) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files;
+}
+function readBuildCache() {
+    try {
+        if (!fs.existsSync(BUILD_CACHE_PATH)) {
+            return { version: 1 };
+        }
+        const parsed = JSON.parse(fs.readFileSync(BUILD_CACHE_PATH, 'utf-8'));
+        if (parsed.version === 1) {
+            return parsed;
+        }
+    }
+    catch {
+        // Ignore malformed cache files.
+    }
+    return { version: 1 };
+}
+function writeBuildCache(cache) {
+    ensureDir(CACHE_DIR);
+    fs.writeFileSync(BUILD_CACHE_PATH, JSON.stringify(cache, null, 2), 'utf-8');
+}
+function getCoreSchemasHash() {
+    const bsbBasePath = resolveBsbBasePath();
+    if (!bsbBasePath) {
+        return '';
+    }
+    const packageJsonPath = path.join(bsbBasePath, 'package.json');
+    const inputs = [fs.existsSync(packageJsonPath) ? `pkg:${hashFile(packageJsonPath)}` : 'pkg:missing'];
+    const sourcePluginsDir = path.join(bsbBasePath, 'src', 'plugins');
+    if (fs.existsSync(sourcePluginsDir)) {
+        inputs.push(...collectFilesRecursive(sourcePluginsDir, (filePath) => {
+            const ext = path.extname(filePath).toLowerCase();
+            if (ext !== '.ts' && ext !== '.tsx') {
+                return false;
+            }
+            return SCHEMA_FILE_BASENAMES.has(path.basename(filePath));
+        }).map((filePath) => `${normalizePath(path.relative(bsbBasePath, filePath))}:${hashFile(filePath)}`));
+    }
+    else {
+        const schemaDir = path.join(bsbBasePath, 'lib', 'schemas');
+        inputs.push(...collectFilesRecursive(schemaDir, (filePath) => filePath.endsWith('.json'))
+            .map((filePath) => `${normalizePath(path.relative(bsbBasePath, filePath))}:${hashFile(filePath)}`));
+    }
+    return hashStrings(inputs);
+}
+function getSchemaInputsHash(plugins, coreSchemasHash) {
+    const inputs = [`core:${coreSchemasHash}`];
+    const packageJsonPath = path.join(CWD, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+        inputs.push(`pkg:${hashFile(packageJsonPath)}`);
+    }
+    for (const plugin of plugins) {
+        const pluginFiles = collectFilesRecursive(plugin.srcDir, (filePath) => {
+            const ext = path.extname(filePath).toLowerCase();
+            if (ext !== '.ts' && ext !== '.tsx') {
+                return false;
+            }
+            return SCHEMA_FILE_BASENAMES.has(path.basename(filePath));
+        });
+        for (const filePath of pluginFiles) {
+            inputs.push(`${normalizePath(path.relative(CWD, filePath))}:${hashFile(filePath)}`);
+        }
+    }
+    return hashStrings(inputs);
+}
+function getGeneratedSchemasHash() {
+    const schemaDir = path.join(CWD, 'src', '.bsb', 'schemas');
+    const schemaFiles = collectFilesRecursive(schemaDir, (filePath) => filePath.endsWith('.json'));
+    if (schemaFiles.length === 0) {
+        return '';
+    }
+    return hashStrings(schemaFiles.map((filePath) => `${normalizePath(path.relative(CWD, filePath))}:${hashFile(filePath)}`));
+}
+function hasGeneratedSchemas() {
+    const schemaDir = path.join(CWD, 'src', '.bsb', 'schemas');
+    return fs.existsSync(schemaDir) && fs.readdirSync(schemaDir).some((file) => file.endsWith('.json'));
+}
+function hasGeneratedClients() {
+    const clientsDir = path.join(CWD, 'src', '.bsb', 'clients');
+    return fs.existsSync(clientsDir) && fs.readdirSync(clientsDir).some((file) => file.endsWith('.ts'));
+}
+function isTsSourcePath(filePath) {
+    const normalized = normalizeChangedPath(filePath);
+    return normalized.startsWith('src/') && (normalized.endsWith('.ts') || normalized.endsWith('.tsx'));
+}
+function isSchemaRelevantPath(filePath) {
+    const normalized = normalizeChangedPath(filePath);
+    if (normalized === 'package.json') {
+        return true;
+    }
+    if (!isTsSourcePath(normalized)) {
+        return false;
+    }
+    return SCHEMA_FILE_BASENAMES.has(path.basename(normalized));
+}
+function isAssetPath(filePath) {
+    const normalized = normalizeChangedPath(filePath);
+    if (!normalized.startsWith('src/plugins/')) {
+        return false;
+    }
+    const ext = path.extname(normalized).toLowerCase();
+    return ext !== '.ts' && ext !== '.tsx';
+}
+function isStaticAssetPath(filePath) {
+    return normalizeChangedPath(filePath).includes('/static/');
+}
+function isConfigPath(filePath) {
+    const normalized = normalizeChangedPath(filePath);
+    return normalized === 'sec-config.yaml' || normalized === 'package.json';
+}
+function copySingleAssetFile(changedPath) {
+    const normalized = normalizeChangedPath(changedPath);
+    if (!isAssetPath(normalized)) {
+        return false;
+    }
+    const absoluteSource = path.join(CWD, normalized);
+    const relativeToSrc = path.relative(path.join(CWD, 'src'), absoluteSource);
+    const destination = path.join(CWD, 'lib', relativeToSrc);
+    if (fs.existsSync(absoluteSource)) {
+        ensureDir(path.dirname(destination));
+        fs.copyFileSync(absoluteSource, destination);
+    }
+    else if (fs.existsSync(destination)) {
+        fs.rmSync(destination, { force: true });
+    }
+    return true;
+}
+function hasLibSchemas() {
+    const libSchemas = path.join(CWD, 'lib', 'schemas');
+    return fs.existsSync(libSchemas) && fs.readdirSync(libSchemas).some((file) => file.endsWith('.json'));
+}
+function hasPluginMetadataOutputs(plugins) {
+    const schemasDir = path.join(CWD, 'lib', 'schemas');
+    return plugins.every((plugin) => fs.existsSync(path.join(schemasDir, `${plugin.name}.plugin.json`)));
+}
+function getMetadataInputsHash(plugins) {
+    const packageJsonPath = path.join(CWD, 'package.json');
+    const inputs = [];
+    if (fs.existsSync(packageJsonPath)) {
+        inputs.push(`pkg:${hashFile(packageJsonPath)}`);
+    }
+    for (const plugin of plugins) {
+        const indexPath = path.join(plugin.srcDir, 'index.ts');
+        if (fs.existsSync(indexPath)) {
+            inputs.push(`${normalizePath(path.relative(CWD, indexPath))}:${hashFile(indexPath)}`);
+        }
+        const schemaPath = path.join(CWD, 'src', '.bsb', 'schemas', `${plugin.name}.json`);
+        if (fs.existsSync(schemaPath)) {
+            inputs.push(`${normalizePath(path.relative(CWD, schemaPath))}:${hashFile(schemaPath)}`);
+        }
+    }
+    return hashStrings(inputs);
+}
 // Resolve @bsb/base package root using Node module resolution.
 // Handles npm workspaces (hoisted node_modules), symlinks, and pnpm.
 function resolveBsbBasePath() {
@@ -222,6 +454,7 @@ async function generatePluginJson(plugin) {
         }
         info(`Generating plugin metadata for ${plugin.name}`);
         const metadata = pluginModule.Config.metadata;
+        const packageJson = readPackageJson();
         // Auto-detect category from plugin directory name
         const category = plugin.name.startsWith('service-') ? 'service' :
             plugin.name.startsWith('observable-') ? 'observable' :
@@ -231,7 +464,7 @@ async function generatePluginJson(plugin) {
         const pluginMetadata = {
             id: plugin.name,
             name: metadata.name,
-            version: metadata.version || '1.0.0',
+            version: packageJson.version || '1.0.0',
             description: metadata.description || '',
             category,
             tags: metadata.tags || [],
@@ -239,10 +472,10 @@ async function generatePluginJson(plugin) {
             dependencies: [],
         };
         // Only include optional fields if they have real values
-        if (metadata.author)
-            pluginMetadata.author = metadata.author;
-        if (metadata.license)
-            pluginMetadata.license = metadata.license;
+        if (packageJson.author)
+            pluginMetadata.author = packageJson.author;
+        if (packageJson.license)
+            pluginMetadata.license = packageJson.license;
         if (metadata.homepage)
             pluginMetadata.homepage = metadata.homepage;
         if (metadata.repository)
@@ -443,51 +676,183 @@ function generateRootTestsJson(plugins) {
     fs.writeFileSync(testsPath, JSON.stringify(updated, null, 2), 'utf-8');
     success(`Generated bsb-tests.json with ${plugins.length} plugin(s)`);
 }
+function shouldRunSchemaPipeline(changedPaths) {
+    if (!changedPaths || changedPaths.length === 0) {
+        return true;
+    }
+    return changedPaths.some(isSchemaRelevantPath);
+}
+function getBsbCliPath() {
+    const bsbBase = resolveBsbBasePath();
+    if (!bsbBase) {
+        error('BSB CLI not found. Make sure @bsb/base is installed.');
+    }
+    const bsbCliPath = path.join(bsbBase, 'lib', 'cli.js');
+    if (!fs.existsSync(bsbCliPath)) {
+        error(`BSB CLI entry not found at ${bsbCliPath}. @bsb/base may need rebuilding.`);
+    }
+    return bsbCliPath;
+}
+function getBsbDevPath() {
+    const bsbBase = resolveBsbBasePath();
+    if (!bsbBase) {
+        error('BSB dev entry not found. Make sure @bsb/base is installed.');
+    }
+    const sourceDevPath = path.join(bsbBase, 'src', 'dev.ts');
+    if (fs.existsSync(sourceDevPath)) {
+        return sourceDevPath;
+    }
+    const compiledDevPath = path.join(bsbBase, 'lib', 'dev.js');
+    if (fs.existsSync(compiledDevPath)) {
+        return compiledDevPath;
+    }
+    error(`BSB dev entry not found in ${bsbBase}`);
+}
+function typecheckDev() {
+    try {
+        info('Type checking TypeScript');
+        execSync(`npx tsc --noEmit --incremental --tsBuildInfoFile "${normalizePath(TSC_BUILD_INFO_PATH)}"`, { cwd: CWD, stdio: 'inherit' });
+        success('Type checking TypeScript');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function prepareGeneratedArtifacts(options = {}) {
+    ensureDir(CACHE_DIR);
+    const plugins = detectPluginStructure();
+    const cache = readBuildCache();
+    const changedPaths = options.changedPaths ?? [];
+    let coreSchemasHash = getCoreSchemasHash();
+    let schemaInputsHash = getSchemaInputsHash(plugins, coreSchemasHash);
+    const runSchemaPipeline = shouldRunSchemaPipeline(options.changedPaths);
+    const metadataInputsHash = getMetadataInputsHash(plugins);
+    const coreSchemasChanged = cache.coreSchemasHash !== coreSchemasHash;
+    const shouldSyncCoreSchemas = coreSchemasChanged || !hasGeneratedClients() || !hasGeneratedSchemas();
+    if (shouldSyncCoreSchemas) {
+        syncParentSchemas();
+        coreSchemasHash = getCoreSchemasHash();
+        schemaInputsHash = getSchemaInputsHash(plugins, coreSchemasHash);
+    }
+    else {
+        info('Skipping core schema sync (unchanged)');
+    }
+    const shouldExtractSchemas = runSchemaPipeline && (shouldSyncCoreSchemas ||
+        cache.schemaInputsHash !== schemaInputsHash ||
+        !hasGeneratedSchemas());
+    if (shouldExtractSchemas) {
+        await extractSchemasFromSource();
+    }
+    else {
+        info('Skipping schema extraction (unchanged)');
+    }
+    const generatedSchemasHash = getGeneratedSchemasHash();
+    const shouldGenerateClients = runSchemaPipeline && (shouldExtractSchemas ||
+        cache.clientInputsHash !== generatedSchemasHash ||
+        !hasGeneratedClients());
+    if (shouldGenerateClients) {
+        generateVirtualClients();
+    }
+    else {
+        info('Skipping virtual client generation (unchanged)');
+    }
+    writeBuildCache({
+        version: 1,
+        coreSchemasHash,
+        schemaInputsHash,
+        clientInputsHash: getGeneratedSchemasHash(),
+        metadataInputsHash: changedPaths.length > 0 ? cache.metadataInputsHash : metadataInputsHash,
+    });
+    return {
+        plugins,
+        coreSchemasHash,
+        schemaInputsHash,
+        generatedSchemasHash: getGeneratedSchemasHash(),
+    };
+}
 // Build the plugin
-async function build() {
+async function build(options = {}) {
     log('\n=== Building BSB Plugin ===\n', 'bright');
-    // Step 1: Sync schemas with parent @bsb/base core plugins FIRST
-    // This ensures latest types are available during compilation
-    syncParentSchemas();
-    // Step 2: Extract schemas from TypeScript source (pre-compilation)
-    // This reads TS files directly, no compiled JS needed — breaks circular dependency
-    await extractSchemasFromSource();
-    // Step 3: Generate virtual clients from extracted schemas
-    // These will be compiled alongside the project in step 5
-    generateVirtualClients();
+    const cache = readBuildCache();
+    const changedPaths = options.changedPaths ?? [];
+    const { plugins, coreSchemasHash, schemaInputsHash } = await prepareGeneratedArtifacts(options);
+    const runSchemaPipeline = shouldRunSchemaPipeline(options.changedPaths);
+    const metadataInputsHash = getMetadataInputsHash(plugins);
+    const packageChanged = changedPaths.some((filePath) => normalizeChangedPath(filePath) === 'package.json');
+    const assetChanged = changedPaths.some(isAssetPath);
     // Step 4: Clean
-    clean();
+    if (options.clean !== false) {
+        clean();
+    }
+    else {
+        info('Skipping clean for incremental rebuild');
+    }
     // Step 5: Compile TypeScript (virtual clients in src/.bsb/clients/ compile with the project)
-    exec('npx tsc', 'Compiling TypeScript');
+    if (options.incremental) {
+        exec(`npx tsc --incremental --tsBuildInfoFile "${normalizePath(TSC_BUILD_INFO_PATH)}"`, 'Compiling TypeScript incrementally');
+    }
+    else {
+        exec('npx tsc', 'Compiling TypeScript');
+    }
     // Step 6: Copy non-TypeScript assets for each plugin
-    const plugins = detectPluginStructure();
-    for (const plugin of plugins) {
-        copyPluginAssets(plugin);
+    const shouldCopyAllAssets = !options.changedPaths || changedPaths.length === 0 || assetChanged || !fs.existsSync(path.join(CWD, 'lib'));
+    if (shouldCopyAllAssets) {
+        for (const plugin of plugins) {
+            copyPluginAssets(plugin);
+        }
+    }
+    else {
+        info('Skipping asset copy (unchanged)');
     }
     // Step 7: Copy extracted schemas to lib/schemas/
-    copySchemasToLib();
+    const shouldCopySchemas = runSchemaPipeline || !hasLibSchemas();
+    if (shouldCopySchemas) {
+        copySchemasToLib();
+    }
+    else {
+        info('Skipping schema copy (unchanged)');
+    }
     // Step 8: Generate per-plugin metadata JSON (needs compiled JS for Config.metadata)
-    for (const plugin of plugins) {
-        await generatePluginJson(plugin);
+    const shouldGenerateMetadata = runSchemaPipeline ||
+        packageChanged ||
+        cache.metadataInputsHash !== metadataInputsHash ||
+        !hasPluginMetadataOutputs(plugins);
+    if (shouldGenerateMetadata) {
+        for (const plugin of plugins) {
+            await generatePluginJson(plugin);
+        }
+    }
+    else {
+        info('Skipping plugin metadata generation (unchanged)');
     }
     // Step 9: Generate root bsb-plugin.json (aggregates all per-plugin metadata)
-    generateRootPluginJson();
+    if (shouldGenerateMetadata || !fs.existsSync(path.join(CWD, 'bsb-plugin.json'))) {
+        generateRootPluginJson();
+    }
+    else {
+        info('Skipping bsb-plugin.json generation (unchanged)');
+    }
     // Step 10: Generate root bsb-tests.json (default ignore entries)
-    generateRootTestsJson(plugins.map(p => ({ id: p.name })));
+    if (shouldGenerateMetadata || !fs.existsSync(path.join(CWD, 'bsb-tests.json'))) {
+        generateRootTestsJson(plugins.map(p => ({ id: p.name })));
+    }
+    else {
+        info('Skipping bsb-tests.json generation (unchanged)');
+    }
+    writeBuildCache({
+        version: 1,
+        coreSchemasHash,
+        schemaInputsHash,
+        clientInputsHash: getGeneratedSchemasHash(),
+        metadataInputsHash: getMetadataInputsHash(plugins),
+    });
     log('\n' + colors.green + colors.bright + '[BUILD COMPLETE]' + colors.reset + '\n');
 }
 // Start the BSB service
 function start() {
     log('\n=== Starting BSB Service ===\n', 'bright');
-    // Find the BSB CLI (uses Node module resolution to handle workspace hoisting)
-    const bsbBase = resolveBsbBasePath();
-    if (!bsbBase) {
-        error('BSB CLI not found. Make sure @bsb/base is installed.');
-    }
-    const bsbCliPath = path.join(bsbBase, 'lib', 'cli.js');
-    if (!fs.existsSync(bsbCliPath)) {
-        error(`BSB CLI entry not found at ${bsbCliPath}. @bsb/base may need rebuilding.`);
-    }
+    const bsbCliPath = getBsbCliPath();
     info('Starting service');
     // Spawn the process and inherit stdio for real-time output
     const child = spawn('node', [bsbCliPath], {
@@ -507,13 +872,170 @@ function start() {
         child.kill('SIGINT');
     });
 }
-// Development mode (build + start)
+function startServiceProcess() {
+    const bsbDevPath = getBsbDevPath();
+    info('Starting service');
+    return spawn('node', ['--import', 'tsx', bsbDevPath], {
+        cwd: CWD,
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            APP_DIR: CWD,
+            BSB_DEV_EXTERNAL_WATCH: '1',
+            BSB_DEV_LOADER: 'tsx',
+        },
+    });
+}
+async function stopServiceProcess(child) {
+    if (!child || child.killed || child.exitCode !== null) {
+        return;
+    }
+    await new Promise((resolve) => {
+        child.once('exit', () => resolve());
+        child.kill('SIGINT');
+        setTimeout(() => {
+            if (child.exitCode === null) {
+                child.kill('SIGTERM');
+            }
+        }, 2000);
+        setTimeout(() => {
+            if (child.exitCode === null) {
+                child.kill('SIGKILL');
+            }
+        }, 4000);
+    });
+}
+// Development mode with incremental rebuilds and restarts
 async function dev() {
     log('\n=== Development Mode ===\n', 'bright');
-    // Build first
-    await build();
-    // Then start
-    start();
+    let child = null;
+    let watcher = null;
+    let isRebuilding = false;
+    let restartPending = false;
+    const pendingChanges = new Set();
+    let debounceTimer = null;
+    const rebuildAndRestart = async () => {
+        if (isRebuilding) {
+            restartPending = true;
+            info('Rebuild already in progress, queueing another pass');
+            return;
+        }
+        isRebuilding = true;
+        const changedPaths = Array.from(pendingChanges);
+        pendingChanges.clear();
+        try {
+            if (changedPaths.length > 0) {
+                info(`Detected changes: ${changedPaths.join(', ')}`);
+            }
+            const configOnly = changedPaths.length > 0 &&
+                changedPaths.every((filePath) => isConfigPath(filePath));
+            const assetOnly = changedPaths.length > 0 &&
+                changedPaths.every((filePath) => isAssetPath(filePath) || isConfigPath(filePath));
+            const staticAssetOnly = changedPaths.length > 0 &&
+                changedPaths.every((filePath) => isStaticAssetPath(filePath) || isConfigPath(filePath));
+            const sourceCodeChanged = changedPaths.some(isTsSourcePath);
+            const copiedAnyAsset = assetOnly
+                ? changedPaths.map(copySingleAssetFile).some(Boolean)
+                : false;
+            if (configOnly) {
+                info('Skipping rebuild (config-only change)');
+            }
+            else if (!assetOnly || !copiedAnyAsset) {
+                info('Preparing generated artifacts for dev');
+                await prepareGeneratedArtifacts({ changedPaths });
+                if (sourceCodeChanged) {
+                    const typecheckOk = typecheckDev();
+                    if (!typecheckOk) {
+                        info('Type check failed, keeping current service instance');
+                        return;
+                    }
+                }
+            }
+            else {
+                info('Skipping TypeScript rebuild (asset/config-only change)');
+            }
+            if (staticAssetOnly && copiedAnyAsset && !configOnly) {
+                info('Skipping restart (static asset-only change)');
+                return;
+            }
+            info('Restarting service');
+            await stopServiceProcess(child);
+            child = startServiceProcess();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log(`Dev rebuild failed: ${message}`, 'red');
+        }
+        finally {
+            isRebuilding = false;
+            if (restartPending) {
+                restartPending = false;
+                void rebuildAndRestart();
+            }
+        }
+    };
+    const queueChange = (filePath) => {
+        const normalizedPath = normalizeChangedPath(filePath);
+        info(`Change detected: ${normalizedPath}`);
+        pendingChanges.add(normalizedPath);
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(() => {
+            void rebuildAndRestart();
+        }, 200);
+    };
+    try {
+        info(`Watching paths: ${DEV_WATCH_PATHS.map(normalizePath).join(', ')}`);
+        watcher = chokidar.watch(DEV_WATCH_PATHS, {
+            ignored: (watchPath) => {
+                const normalized = normalizeChangedPath(String(watchPath));
+                return DEV_IGNORE_PATHS.some((ignorePath) => {
+                    const normalizedIgnorePath = normalizeChangedPath(ignorePath);
+                    return normalized === normalizedIgnorePath || normalized.startsWith(`${normalizedIgnorePath}/`);
+                });
+            },
+            ignoreInitial: true,
+            persistent: true,
+        });
+        watcher.on('add', queueChange);
+        watcher.on('change', queueChange);
+        watcher.on('unlink', queueChange);
+        await new Promise((resolve) => {
+            watcher.once('ready', () => {
+                info('Watching for changes');
+                resolve();
+            });
+        });
+        info('Preparing generated artifacts for dev');
+        await prepareGeneratedArtifacts();
+        if (typecheckDev()) {
+            child = startServiceProcess();
+        }
+        else {
+            info('Initial type check failed, waiting for changes');
+        }
+        process.on('SIGINT', async () => {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            if (watcher) {
+                await watcher.close();
+            }
+            await stopServiceProcess(child);
+            process.exit(0);
+        });
+        await new Promise(() => { });
+    }
+    finally {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        if (watcher) {
+            await watcher.close();
+        }
+        await stopServiceProcess(child);
+    }
 }
 // Run tests
 function test() {