auklet 0.0.29 → 0.1.1

package/README.md

@@ -74,6 +74,9 @@ The package exposes both `auk` and `auklet`.
 | `auk build-css`         | Generate CSS output only.                                             |
 | `auk build-css --watch` | Watch source/config/style files and rebuild CSS.                      |
 | `auk publish`           | Run the pnpm-based publish workflow.                                  |
+| `auk inspect publish`   | Check publish readiness without changing files or registry state.     |
+| `auk inspect pack`      | Check package entry/export files before publishing.                   |
+| `auk inspect css`       | Explain CSS output entry, theme, and module plans.                    |
 | `auk owner add <user>`  | Add npm owners through pnpm.                                          |
 
 Build and dev commands can override package config for one run:
@@ -126,7 +129,11 @@ auk publish
 auk publish --filter @scope/ui
 auk publish --version patch --dry-run
 auk publish --no-format
+auk publish --no-git
 auk publish --otp 123456
+auk inspect publish --version patch
+auk inspect pack --filter @scope/ui
+auk inspect css --modules
 auk owner add alice
 auk owner add alice --filter @scope/ui --otp 123456
 ```
@@ -148,6 +155,8 @@ auk owner add <user...>
 
 `--no-format` disables auklet's publish output formatter for that run. It is not
 configured in `package.json`.
+`--no-git` skips auklet's release commit and tag for that run. The publish flow
+still checks that the git worktree is clean unless `--allow-dirty` is also set.
 Before writing versions, auklet checks npm authentication from each target
 package directory. Package-local `.npmrc` files and
 `package.json#publishConfig.registry` are respected.
@@ -155,6 +164,21 @@ package directory. Package-local `.npmrc` files and
 require publish 2FA, and to `pnpm owner add` for owner management 2FA. In CI,
 prefer an npm automation token.
 
+`auk inspect publish` accepts the same publish selection and version flags as
+`auk publish`. It resolves the publish plan, checks package entry/export files,
+then checks registry authentication and whether target versions already exist.
+It does not write versions, run hooks, build, commit, tag, or publish packages.
+Local package file failures or registry issues exit with code 1.
+
+`auk inspect pack` accepts `--filter` for workspace package selection. It checks
+whether `package.json` entry fields, `exports`, `bin`, `types`, CSS entry fields,
+and declared `files` paths point to existing package files.
+
+`auk inspect css` accepts the same build override flags as `auk build`. It
+prints the normalized CSS plan, including output entries, theme files, and
+module entries. When run from a pnpm workspace root, it inspects workspace child
+packages instead of the root package. It does not write CSS output.
+
 ## Configuration
 
 `auklet.config.js` or `auklet.config.mjs` is loaded from the current package
@@ -430,4 +454,4 @@ Notes:
 
 - `pnpm build` rewrites `dist`.
 - `pnpm run format` formats `bin`, `src`, `dist`, `examples`, and related files.
-- Read `TESTING.md` before changing tests.
+- Read `docs/testing.md` before changing tests.

package/dist/cli/inspect.d.ts

@@ -0,0 +1 @@
+export declare function runInspect(args: Array<string>): Promise<number>;

package/dist/cli/inspect.js

@@ -0,0 +1,20 @@
+import { runInspectCssCli } from '#auklet/css/inspect';
+import { runInspectPublishCli } from '#auklet/publish/inspect';
+import { runInspectPackCli } from '#auklet/publish/inspectPack';
+export async function runInspect(args) {
+    const normalizedArgs = args[0] === '--' ? args.slice(1) : args;
+    const [command, ...restArgs] = normalizedArgs;
+    if (command === 'css') {
+        return runInspectCssCli(restArgs);
+    }
+    if (command === 'publish') {
+        return runInspectPublishCli(restArgs);
+    }
+    if (command === 'pack') {
+        return runInspectPackCli(restArgs);
+    }
+    if (command) {
+        throw new Error(`[inspect] unknown inspect command: ${command}`);
+    }
+    throw new Error('[inspect] expected inspect command: auk inspect publish, auk inspect pack, or auk inspect css');
+}

package/dist/cli/main.js

@@ -7,6 +7,7 @@ import { runDev } from '#auklet/cli/dev';
 import { runBuildCss } from '#auklet/cli/buildCss';
 import { runBuild, runBuildJs } from '#auklet/cli/build';
 import { runOwner, runPublish } from '#auklet/cli/publish';
+import { runInspect } from '#auklet/cli/inspect';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const getPackageVersion = () => {
     const packageJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf8'));
@@ -53,6 +54,10 @@ async function runCli(argv) {
         .command('owner [...args]', 'Manage npm package owners with pnpm')
         .allowUnknownOptions()
         .action(() => runCliCommand(runOwner, getCommandArgs(argv, 'owner')));
+    cli
+        .command('inspect [...args]', 'Inspect auklet plans without side effects')
+        .allowUnknownOptions()
+        .action(() => runCliCommand(runInspect, getCommandArgs(argv, 'inspect')));
     cli
         .command('version', 'Print auklet version')
         .action(() => runCliCommand(runVersion, []));

package/dist/css/inspect.d.ts

@@ -0,0 +1,87 @@
+import type { AukletConfig, ModuleStyleBuildConfig } from '#auklet/types';
+type CssInspectEntryRow = {
+    entry: string;
+    parts: Array<string>;
+};
+type CssInspectModuleRow = {
+    sourceDir: string;
+    imports: Array<string>;
+    ownStyles: Array<string>;
+};
+export type CssInspectModel = {
+    details: {
+        packageName: string;
+        packageRoot: string;
+        source: string;
+        output: string;
+        modules: boolean;
+        sourceFiles: number;
+        styleFiles: number;
+        themes: number;
+        moduleEntries: number;
+    };
+    packageEntries: Array<CssInspectEntryRow>;
+    themeFiles: Array<{
+        theme: string;
+        file: string;
+    }>;
+    styleFiles: Array<string>;
+    moduleEntries: Array<CssInspectModuleRow>;
+};
+export declare function runInspectCssCli(args: Array<string>): Promise<number>;
+export declare function resolveInspectCssOptions(args: Array<string>): Promise<{
+    cwd: string;
+    targets: {
+        packageRoot: string;
+        packageName: string;
+        aukletConfig: {
+            build: {
+                formats?: Array<import("#auklet/types").PackageBuildFormat>;
+                target?: import("#auklet/types").PackageBuildTarget;
+                platform?: import("#auklet/types").PackageBuildPlatform;
+                banner?: string;
+                externals?: Array<string>;
+                alias?: Record<string, string>;
+                mainFields?: Array<string>;
+                globals?: Record<string, string>;
+                configureTsdown?: import("#auklet/types").ConfigureTsdown;
+                tsconfig?: string;
+            } | undefined;
+            source?: string;
+            output?: string;
+            modules?: boolean;
+            styles?: import("#auklet/types").StyleOptions;
+        };
+        config: ModuleStyleBuildConfig;
+    }[];
+}>;
+export declare function createCssInspectModel(options: {
+    packageRoot: string;
+    packageName?: string;
+    aukletConfig?: AukletConfig;
+    config?: ModuleStyleBuildConfig;
+}): {
+    details: {
+        packageName: string;
+        packageRoot: string;
+        source: string;
+        output: string;
+        modules: boolean;
+        sourceFiles: number;
+        styleFiles: number;
+        themes: number;
+        moduleEntries: number;
+    };
+    packageEntries: CssInspectEntryRow[];
+    themeFiles: {
+        theme: string;
+        file: string;
+    }[];
+    styleFiles: string[];
+    moduleEntries: {
+        sourceDir: string;
+        imports: string[];
+        ownStyles: string[];
+    }[];
+};
+export {};

package/dist/css/inspect.js

@@ -0,0 +1,303 @@
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { isPlainObject, isString } from 'aidly';
+import { normalizeAukletConfig } from '#auklet/config';
+import { loadAukletConfig } from '#auklet/configLoader';
+import { resolveBuildCliArgs } from '#auklet/cli/buildArgs';
+import { moduleStyleBuildConfig } from '#auklet/css/config';
+import { mergeAukletConfigOverrides } from '#auklet/build/cliOverrides';
+import { createExternalEntryParts, createModuleStyleEntryPlans, createStyleEntryParts, createThemeEntryParts, } from '#auklet/css/core/style/entries';
+import { toPosixPath } from '#auklet/utils';
+import { createAukletLogger } from '#auklet/logger';
+import { StylePackageContext } from '#auklet/css/core/stylePackageContext';
+import { findWorkspaceRoot } from '#auklet/workspace/root';
+import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
+const packageSeparator = '-'.repeat(84);
+export async function runInspectCssCli(args) {
+    const inspectOptions = await resolveInspectCssOptions(args);
+    const models = inspectOptions.targets.map((target) => createCssInspectModel(target));
+    new CssInspectReporter(inspectOptions.cwd, models).report();
+    return 0;
+}
+export async function resolveInspectCssOptions(args) {
+    const buildArgs = resolveBuildCliArgs(args.filter((arg) => arg !== '--'));
+    if (buildArgs.args.length) {
+        throw new Error(`[inspect] unknown inspect css argument: ${buildArgs.args[0]}`);
+    }
+    const cwd = process.cwd();
+    const workspaceRoot = findWorkspaceRoot(cwd);
+    const packageRoots = workspaceRoot === cwd
+        ? (await readPnpmWorkspacePackageInfo(cwd))
+            .map((item) => path.resolve(item.path))
+            .filter((packageRoot) => packageRoot !== cwd)
+        : [cwd];
+    return {
+        cwd,
+        targets: await Promise.all(packageRoots.map(async (packageRoot) => ({
+            packageRoot,
+            packageName: readPackageName(packageRoot),
+            aukletConfig: mergeAukletConfigOverrides(await loadAukletConfig(packageRoot), buildArgs.config),
+            config: moduleStyleBuildConfig,
+        }))),
+    };
+}
+export function createCssInspectModel(options) {
+    const config = options.config ?? moduleStyleBuildConfig;
+    const normalizedConfig = normalizeAukletConfig(options.aukletConfig ?? {});
+    const context = createBuildContext(options.packageRoot, normalizedConfig);
+    const packageContext = new StylePackageContext({
+        config,
+        context,
+        normalizedConfig,
+    });
+    const moduleEntries = normalizedConfig.modules
+        ? createModuleStyleEntryPlans(packageContext)
+        : [];
+    const packageEntries = createCssInspectEntryRows(config, normalizedConfig, packageContext);
+    return {
+        details: {
+            packageName: options.packageName ?? readPackageName(context.packageRoot),
+            packageRoot: context.packageRoot,
+            source: context.sourceDir,
+            output: context.outputDir,
+            modules: normalizedConfig.modules,
+            sourceFiles: packageContext.sourceFiles.length,
+            styleFiles: packageContext.styleFiles.length,
+            themes: packageContext.themeFiles.size,
+            moduleEntries: moduleEntries.length,
+        },
+        packageEntries,
+        themeFiles: Array.from(packageContext.themeFiles.entries()).map(([theme, file]) => ({
+            theme,
+            file: toRelativePath(context.packageRoot, file),
+        })),
+        styleFiles: packageContext.styleFiles.map((file) => toRelativePath(context.packageRoot, file)),
+        moduleEntries: moduleEntries.map((entry) => ({
+            sourceDir: toPosixPath(entry.sourceDir),
+            imports: sortStyleDependencies(entry.moduleStyleImports),
+            ownStyles: entry.ownStyleFiles.map((file) => toRelativePath(context.packageRoot, file)),
+        })),
+    };
+}
+const createCssInspectEntryRows = (config, normalizedConfig, packageContext) => {
+    const rows = [];
+    const styleEntryParts = createStyleEntryParts(normalizedConfig);
+    const externalEntryParts = createExternalEntryParts(normalizedConfig);
+    if (packageContext.styleFiles.length ||
+        packageContext.themeFiles.size ||
+        hasDependencyParts(styleEntryParts)) {
+        rows.push({
+            entry: config.output.indexStyleFile,
+            parts: styleEntryParts.map(formatEntryPart),
+        });
+    }
+    if (hasDependencyParts(externalEntryParts)) {
+        rows.push({
+            entry: path.posix.join(config.output.styleDir, config.output.externalStyleFile),
+            parts: externalEntryParts.map(formatEntryPart),
+        });
+    }
+    rows.push(...packageContext.themeNames.map((themeName) => ({
+        entry: path.posix.join(config.output.styleDir, `${themeName}.css`),
+        parts: createThemeEntryParts(normalizedConfig, themeName).map(formatEntryPart),
+    })));
+    return rows;
+};
+const hasDependencyParts = (parts) => {
+    return parts.some((part) => {
+        if (part.type !== 'dependencies')
+            return false;
+        const specifiers = Reflect.get(part, 'specifiers');
+        return specifiers.length > 0;
+    });
+};
+const createBuildContext = (packageRoot, config) => {
+    return {
+        packageRoot,
+        sourceDir: config.source,
+        outputDir: config.output,
+    };
+};
+const readPackageName = (packageRoot) => {
+    const packageJson = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    if (!isPlainObject(packageJson) || !isString(packageJson.name)) {
+        return path.basename(packageRoot);
+    }
+    return packageJson.name;
+};
+const formatEntryPart = (part) => {
+    if (part.type === 'dependencies') {
+        const specifiers = Reflect.get(part, 'specifiers');
+        return specifiers.length
+            ? `dependencies: ${specifiers.join(', ')}`
+            : 'dependencies: none';
+    }
+    if (part.type === 'themes') {
+        const themeNames = Reflect.get(part, 'themeNames');
+        return themeNames.length ? `themes: ${themeNames.join(', ')}` : 'themes';
+    }
+    if (part.type === 'theme') {
+        return `theme: ${String(Reflect.get(part, 'themeName'))}`;
+    }
+    return part.type;
+};
+const toRelativePath = (root, file) => {
+    return toPosixPath(path.relative(root, file));
+};
+const sortStyleDependencies = (dependencies) => {
+    return [...dependencies].sort((left, right) => {
+        const leftExternal = isExternalStyleDependency(left);
+        const rightExternal = isExternalStyleDependency(right);
+        if (leftExternal !== rightExternal)
+            return leftExternal ? -1 : 1;
+        return left.localeCompare(right);
+    });
+};
+const isExternalStyleDependency = (dependency) => {
+    return !dependency.startsWith('.') && !dependency.startsWith('/');
+};
+class CssInspectReporter {
+    cwd;
+    models;
+    logger = createAukletLogger();
+    constructor(cwd, models) {
+        this.cwd = cwd;
+        this.models = models;
+    }
+    report() {
+        this.logger.newline();
+        this.logger.result({
+            title: this.logger.colors.bold(this.logger.colors.green('CSS inspect')),
+            status: 'info',
+            body: [this.logger.colors.gray('Read-only CSS plan. No files changed.')],
+            details: {
+                packages: this.formatValue(this.models.length),
+                styles: this.formatValue(this.models.reduce((total, model) => total + model.details.styleFiles, 0)),
+                themes: this.formatValue(this.models.reduce((total, model) => total + model.details.themes, 0)),
+                entries: this.formatValue(this.models.reduce((total, model) => total + model.details.moduleEntries, 0)),
+            },
+        });
+        for (const [index, model] of this.models.entries()) {
+            this.logger.newline();
+            if (index > 0) {
+                this.writePackageSeparator();
+                this.logger.newline();
+            }
+            this.reportPackage(model);
+        }
+        this.logger.newline();
+    }
+    reportPackage(model) {
+        this.logger.result({
+            title: this.formatPackage(model.details.packageName),
+            status: 'info',
+            details: {
+                root: this.logger.path(toRelativePath(this.cwd, model.details.packageRoot) || '.'),
+                source: this.logger.path(model.details.source),
+                output: this.logger.path(model.details.output),
+                modules: this.formatValue(model.details.modules ? 'on' : 'off'),
+                styles: this.formatValue(model.details.styleFiles),
+                themes: this.formatValue(model.details.themes),
+                entries: this.formatValue(model.details.moduleEntries),
+            },
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Output entries');
+        this.logger.rows({
+            columns: this.formatColumns(['entry', 'parts']),
+            rows: model.packageEntries.map((entry) => [
+                this.logger.path(entry.entry),
+                this.formatEntryParts(entry.parts),
+            ]),
+            empty: this.logger.colors.gray('No package-level CSS entries found.'),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Theme files');
+        this.logger.rows({
+            columns: this.formatColumns(['theme', 'file']),
+            rows: model.themeFiles.map((theme) => [
+                this.formatTheme(theme.theme),
+                this.logger.path(theme.file),
+            ]),
+            empty: this.logger.colors.gray('No theme files configured.'),
+        });
+        this.logger.newline();
+        this.writeSectionTitle('Module entries');
+        this.writeModuleEntries(model);
+    }
+    writeSectionTitle(title) {
+        this.logger.raw(title);
+    }
+    writePackageSeparator() {
+        this.logger.raw(this.logger.colors.gray(packageSeparator));
+    }
+    writeModuleEntries(model) {
+        if (!model.moduleEntries.length) {
+            this.logger.empty(model.details.modules
+                ? this.logger.colors.gray('No module style entries found.')
+                : this.logger.colors.gray('Module output is disabled.'));
+            return;
+        }
+        for (const [index, entry] of model.moduleEntries.entries()) {
+            if (index > 0)
+                this.logger.newline();
+            this.logger.rows({
+                title: this.formatSource(entry.sourceDir),
+                columns: this.formatColumns(['type', 'file']),
+                rows: [
+                    ...this.createModuleEntryRows('own style', entry.ownStyles, (value) => this.formatOwnStyle(value)),
+                    ...this.createModuleEntryRows('dependency', entry.imports, (value) => this.formatDependency(value)),
+                ],
+            });
+        }
+    }
+    createModuleEntryRows(title, values, format) {
+        if (!values.length) {
+            return [
+                [this.logger.colors.gray(title), this.logger.colors.gray('none')],
+            ];
+        }
+        return values.map((value) => [
+            this.logger.colors.gray(title),
+            format(value),
+        ]);
+    }
+    formatColumns(columns) {
+        return columns.map((column) => this.logger.colors.gray(column));
+    }
+    formatEntryParts(parts) {
+        return parts.flatMap((part, index) => [
+            ...(index > 0 ? [this.logger.colors.gray(' | ')] : []),
+            this.formatEntryPart(part),
+        ]);
+    }
+    formatEntryPart(part) {
+        if (part.startsWith('dependencies:')) {
+            return this.logger.colors.yellow(part);
+        }
+        if (part.startsWith('themes:') || part.startsWith('theme:')) {
+            return this.logger.colors.hex('#7c3aed')(part);
+        }
+        if (part === 'module')
+            return this.logger.colors.green(part);
+        return this.logger.colors.gray(part);
+    }
+    formatSource(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(value));
+    }
+    formatDependency(value) {
+        return this.logger.colors.yellow(value);
+    }
+    formatOwnStyle(value) {
+        return this.logger.colors.green(value);
+    }
+    formatTheme(value) {
+        return this.logger.colors.bold(this.logger.colors.hex('#7c3aed')(value));
+    }
+    formatPackage(value) {
+        return this.logger.colors.bold(this.logger.colors.hex('#5b21b6')(value));
+    }
+    formatValue(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(String(value)));
+    }
+}

package/dist/css/vite/hmr.js

@@ -2,13 +2,6 @@ import path from 'node:path';
 import { isString } from 'aidly';
 import { normalizeFileKey } from '#auklet/utils';
 import { createScopedAukletLogger } from '#auklet/logger';
-// package CSS 的 HMR 不能直接走 Vite 原生 CSS 文件链路：
-// 1. 浏览器 import 的是 auklet-css:* 虚拟 CSS 模块，不是真实的
-//   packages/*/src/**/*.css 文件，所以真实 CSS 变化时 Vite 的 modules 可能为空。
-// 2. Vite dev 会把 CSS 转成自接受的 JS 模块，重新执行模块里的 updateStyle()
-//   才能更新样式，因此这里手动发送 js-update，而不是 css-update。
-// 3. @tailwindcss/vite 会在相关 CSS 变化时主动发 full-reload。package CSS 已由
-//   这个插件接管 HMR 时，需要在一个很短的窗口内吞掉这次 reload。
 const FULL_RELOAD_SUPPRESS_MS = 100;
 const DUPLICATE_UPDATE_IGNORE_MS = 500;
 const logger = createScopedAukletLogger('css:vite');

package/dist/css/watch/watcher.d.ts

@@ -1,16 +1,23 @@
+import { type AukletLogger } from '#auklet/logger';
 import type { ModuleStyleBuildConfig, ModuleStyleBuildContext } from '#auklet/types';
+type ModuleStyleWatcherLogger = Pick<AukletLogger, 'error'>;
 export declare class ModuleStyleWatcher {
-    private readonly config;
     private readonly context;
+    private readonly config;
+    private readonly logger;
     private timer;
+    private closed;
     private isBuilding;
     private shouldRebuild;
     private watcher;
-    constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig);
+    private readonly lastErrorLogTimes;
+    constructor(context?: ModuleStyleBuildContext, config?: ModuleStyleBuildConfig, logger?: ModuleStyleWatcherLogger | null);
     watch(): Promise<void>;
     private rebuild;
     private refreshWatcher;
+    private logError;
     private scheduleBuild;
     private shouldRebuildForFile;
     close(): Promise<void>;
 }
+export {};

package/dist/css/watch/watcher.js

@@ -3,69 +3,112 @@ import path from 'node:path';
 import chokidar from 'chokidar';
 import { isString } from 'aidly';
 import { aukletConfigFiles, aukletDefaultOptions, isAukletConfigFile, } from '#auklet/config';
-import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { SOURCE_MODULE_RE } from '#auklet/css/constants';
+import { moduleStyleBuildConfig } from '#auklet/css/config';
 import { ModuleStyleBuilder } from '#auklet/css/production/builder';
+import { createAukletLogger } from '#auklet/logger';
+const errorLogInterval = 2_000;
 export class ModuleStyleWatcher {
-    config;
     context;
+    config;
+    logger;
     timer = null;
+    closed = false;
     isBuilding = false;
     shouldRebuild = false;
     watcher = null;
-    constructor(context = {}, config = moduleStyleBuildConfig) {
-        this.config = config;
+    lastErrorLogTimes = new Map();
+    constructor(context = {}, config = moduleStyleBuildConfig, logger = null) {
         this.context = {
             packageRoot: process.cwd(),
             ...context,
         };
+        this.config = config;
+        this.logger = logger ?? createAukletLogger({ scope: 'css' });
     }
     async watch() {
+        if (this.closed)
+            return;
         await this.rebuild();
     }
     async rebuild() {
+        if (this.closed)
+            return;
         if (this.isBuilding) {
             this.shouldRebuild = true;
             return;
         }
         this.isBuilding = true;
         try {
-            const builder = new ModuleStyleBuilder(this.context, this.config);
-            await builder.build();
-            await this.refreshWatcher();
-        }
-        catch (error) {
-            // Watch mode keeps running after transient build or watcher errors.
+            try {
+                const builder = new ModuleStyleBuilder(this.context, this.config);
+                await builder.build();
+            }
+            catch (error) {
+                this.logError('build', 'CSS build failed; waiting for changes.', error);
+            }
+            if (!this.closed) {
+                try {
+                    await this.refreshWatcher();
+                }
+                catch (error) {
+                    this.logError('watch-refresh', 'CSS watcher failed; waiting for changes.', error);
+                }
+            }
         }
         finally {
             this.isBuilding = false;
-            if (this.shouldRebuild) {
+            if (this.shouldRebuild && !this.closed) {
                 this.shouldRebuild = false;
                 this.scheduleBuild();
             }
         }
     }
     async refreshWatcher() {
+        if (this.closed)
+            return;
         const aukletConfig = this.context.aukletConfig ?? {};
         const sourceDir = this.context.source ?? aukletConfig.source ?? aukletDefaultOptions.source;
         const sourceRoot = path.join(this.context.packageRoot, sourceDir);
         const configPaths = aukletConfigFiles.map((file) => path.join(this.context.packageRoot, file));
         const watchPaths = [sourceRoot, ...configPaths].filter((file) => fs.existsSync(file));
-        await this.watcher?.close();
+        const previousWatcher = this.watcher;
+        this.watcher = null;
+        await previousWatcher?.close();
+        if (this.closed)
+            return;
         this.watcher = chokidar.watch(watchPaths, {
             ignoreInitial: true,
             interval: 300,
             usePolling: true,
         });
         this.watcher.on('all', (_event, file) => {
+            if (this.closed)
+                return;
             if (isString(file) && !this.shouldRebuildForFile(file)) {
                 return;
             }
             this.scheduleBuild();
         });
-        this.watcher.on('error', () => undefined);
+        this.watcher.on('error', (error) => {
+            if (this.closed)
+                return;
+            this.logError('watch-event', 'CSS watcher error; waiting for changes.', error);
+            this.scheduleBuild();
+        });
+    }
+    logError(kind, message, error) {
+        const now = Date.now();
+        const lastLogTime = this.lastErrorLogTimes.get(kind) ?? 0;
+        if (now - lastLogTime < errorLogInterval)
+            return;
+        this.lastErrorLogTimes.set(kind, now);
+        this.logger.error(message);
+        this.logger.error(error);
     }
     scheduleBuild() {
+        if (this.closed)
+            return;
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = setTimeout(() => {
@@ -81,8 +124,14 @@ export class ModuleStyleWatcher {
         return this.config.styleExtensions.includes(path.extname(file));
     }
     async close() {
-        if (this.timer)
+        this.closed = true;
+        this.shouldRebuild = false;
+        if (this.timer) {
             clearTimeout(this.timer);
-        await this.watcher?.close();
+            this.timer = null;
+        }
+        const watcher = this.watcher;
+        this.watcher = null;
+        await watcher?.close();
     }
 }