@gtkx/cli 2.0.0-beta.3 → 2.0.0-beta.5

package/src/deploy/freedesktop/validate.ts

@@ -6,6 +6,12 @@ type ToolResult = {
     status: number;
 };
 
+type Diagnostic = {
+    severity: string;
+    rule: string;
+    detail: string;
+};
+
 type MetainfoResult = {
     subject: string;
     output: string;
@@ -13,6 +19,7 @@ type MetainfoResult = {
     errors: string[];
     warnings: string[];
     rules: string[];
+    notes: string[];
     areWarningsFatal: boolean;
 };
 
@@ -22,12 +29,19 @@ type ToolRequest = {
     subject: string;
 };
 
-const DIAGNOSTIC = /^(?<severity>[EIPW]): \S+ (?<rule>[\w-]+)/;
+const DIAGNOSTIC = /^(?<severity>[EIPW]): \S+ (?<rule>[\w-]+)(?: (?<detail>.*))?$/;
+const SUCCESS_SUMMARY = /^\W*Validation was successful/u;
 const ERROR_SEVERITY = "E";
 const WARNING_SEVERITY = "W";
 const INFO_SEVERITY = "I";
 const FATAL_WARNING_RULES: Set<string> = new Set(["unknown-tag"]);
 
+const FATAL_RULE_NOTES: Record<string, (detail: string) => string> = {
+    "unknown-tag": (element) =>
+        "GTKX treats unknown-tag as fatal for every target, whatever severity appstreamcli assigns it; " +
+        `the unsupported element is <${element}>`,
+};
+
 const REMEDY_FOR_RULE: Record<string, string> = {
     "component-summary-missing": "set `deploy.summary`",
     "description-first-para-too-short": "open `deploy.description` with a paragraph longer than 80 characters",
@@ -35,6 +49,7 @@ const REMEDY_FOR_RULE: Record<string, string> = {
     "metainfo-legacy-path": "this file is generated; report it as a gtkx bug",
     "summary-has-dot-suffix": "drop the trailing period from `deploy.summary`",
     "summary-too-long": "shorten `deploy.summary`",
+    "unknown-tag": "remove the unsupported `deploy.metainfoExtra` element or use a `<custom>` value",
     "url-homepage-missing": "set `deploy.homepage`, or `homepage` in package.json",
 };
 
@@ -48,12 +63,31 @@ const runTool = ({ tool, args, subject }: ToolRequest): ToolResult => {
     return { output: [result.stdout, result.stderr].join("\n").trim(), status: result.status ?? 0 };
 };
 
-const rulesIn = (output: string, severities: string[]): string[] =>
+const parseDiagnostics = (output: string): Diagnostic[] =>
+    output.split("\n").flatMap((line) => {
+        const groups = DIAGNOSTIC.exec(line)?.groups;
+
+        return groups === undefined
+            ? []
+            : [{ severity: groups.severity ?? "", rule: groups.rule ?? "", detail: (groups.detail ?? "").trim() }];
+    });
+
+const rulesIn = (diagnostics: Diagnostic[], severities: string[]): string[] =>
+    diagnostics.filter((diagnostic) => severities.includes(diagnostic.severity)).map((diagnostic) => diagnostic.rule);
+
+const fatalNotes = (diagnostics: Diagnostic[]): string[] =>
+    diagnostics
+        .filter((diagnostic) => diagnostic.severity !== ERROR_SEVERITY && FATAL_WARNING_RULES.has(diagnostic.rule))
+        .map((diagnostic) =>
+            FATAL_RULE_NOTES[diagnostic.rule]?.(diagnostic.detail) ??
+            `GTKX treats ${diagnostic.rule} as fatal for every target`);
+
+const withoutSuccessSummary = (output: string): string =>
     output
         .split("\n")
-        .map((line) => DIAGNOSTIC.exec(line)?.groups)
-        .filter((groups) => groups !== undefined && severities.includes(groups.severity ?? ""))
-        .map((groups) => groups?.rule ?? "");
+        .filter((line) => !SUCCESS_SUMMARY.test(line))
+        .join("\n")
+        .trimEnd();
 
 const remedyLines = (rules: string[]): string[] => {
     const remedies = sortStrings([...new Set(rules)])
@@ -63,8 +97,13 @@ const remedyLines = (rules: string[]): string[] => {
     return remedies.length === 0 ? [] : ["", "Fix it in gtkx.config.ts:", ...remedies];
 };
 
-const invalid = (subject: string, output: string, rules: string[]): Error =>
-    new Error([`${subject} is not valid:`, output.length > 0 ? output : "no output", ...remedyLines(rules)].join("\n"));
+const invalid = (subject: string, output: string, rules: string[], notes: string[]): Error =>
+    new Error([
+        `${subject} is not valid:`,
+        output.length > 0 ? output : "no output",
+        ...notes,
+        ...remedyLines(rules),
+    ].join("\n"));
 
 const isFatalResult = ({ status, errors, warnings, rules, areWarningsFatal }: MetainfoResult): boolean => {
     if (errors.length > 0) {
@@ -84,7 +123,7 @@ const isFatalResult = ({ status, errors, warnings, rules, areWarningsFatal }: Me
 
 const assertNotFatal = (result: MetainfoResult): void => {
     if (isFatalResult(result)) {
-        throw invalid(result.subject, result.output, result.rules);
+        throw invalid(result.subject, result.output, result.rules, result.notes);
     }
 };
 
@@ -108,7 +147,7 @@ const validateDesktopEntry = (path: string): void => {
     });
 
     if (status !== 0 || output.length > 0) {
-        throw invalid("The desktop entry", output, []);
+        throw invalid("The desktop entry", output, [], []);
     }
 };
 
@@ -121,11 +160,22 @@ const validateMetainfo = (path: string, areWarningsFatal: boolean): void => {
         subject,
     });
 
-    const errors = rulesIn(output, [ERROR_SEVERITY]);
-    const warnings = rulesIn(output, [WARNING_SEVERITY]);
-    const infos = rulesIn(output, [INFO_SEVERITY]);
+    const diagnostics = parseDiagnostics(output);
+    const errors = rulesIn(diagnostics, [ERROR_SEVERITY]);
+    const warnings = rulesIn(diagnostics, [WARNING_SEVERITY]);
+    const infos = rulesIn(diagnostics, [INFO_SEVERITY]);
     const rules = [...errors, ...warnings, ...infos];
-    assertNotFatal({ subject, output, status, errors, warnings, rules, areWarningsFatal });
+    const notes = fatalNotes(diagnostics);
+    assertNotFatal({
+        subject,
+        output: withoutSuccessSummary(output),
+        status,
+        errors,
+        warnings,
+        rules,
+        notes,
+        areWarningsFatal,
+    });
     reportDiagnostics(subject, [...warnings, ...infos]);
 };
 

package/src/deploy/payload/stage.ts

@@ -1,4 +1,4 @@
-import { sortStringsBy } from "@gtkx/utils";
+import { sortStringsBy, warn } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
@@ -82,9 +82,48 @@ const stageMetadata = (settings: DeploySettings, root: string, metadata: StagedM
         : [writeInto(root, join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`), metadata.mimePackage)]),
 ];
 
-const stageExtraFiles = (settings: DeploySettings, root: string): StagedFile[] =>
+const generatedMetadataKind = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    destination: string,
+): string | null => {
+    if (destination === join(SHARE_APPLICATIONS, `${settings.applicationId}.desktop`)) {
+        return "desktop entry";
+    }
+
+    if (destination === join(SHARE_METAINFO, `${settings.applicationId}.metainfo.xml`)) {
+        return "metainfo";
+    }
+
+    if (
+        metadata.mimePackage !== null &&
+        destination === join(SHARE_MIME_PACKAGES, `${settings.applicationId}.xml`)
+    ) {
+        return "MIME package";
+    }
+
+    return null;
+};
+
+const warnMetadataCollision = (
+    settings: DeploySettings,
+    metadata: StagedMetadata,
+    file: DeploySettings["extraFiles"][number],
+): void => {
+    const kind = generatedMetadataKind(settings, metadata, file.destination);
+
+    if (kind !== null) {
+        warn(
+            `extraFiles source "${file.source}" targeting "${file.destination}" is overridden by the ` +
+            `GTKX-generated ${kind}`,
+        );
+    }
+};
+
+const stageExtraFiles = (settings: DeploySettings, root: string, metadata: StagedMetadata): StagedFile[] =>
     settings.extraFiles.map((file) => {
         const source = resolve(settings.paths.root, file.source);
+        warnMetadataCollision(settings, metadata, file);
 
         return copyInto(root, file.destination, source, file.mode ?? executableModeFor(source));
     });
@@ -108,7 +147,7 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
         ...stageCatalogs(settings, root),
-        ...stageExtraFiles(settings, root),
+        ...stageExtraFiles(settings, root, metadata),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),

package/src/deploy/settings/extra-files.ts

@@ -1,5 +1,5 @@
 import { statSync } from "node:fs";
-import { resolve } from "node:path";
+import { normalize, resolve } from "node:path";
 import type { DeployConfig, DeployExtraFile } from "../types.js";
 
 type ExtraFiles = NonNullable<DeployConfig["extraFiles"]>;
@@ -22,13 +22,15 @@ const assertSourceFile = (root: string, file: DeployExtraFile): void => {
 };
 
 const resolveExtraFile = (destination: string, entry: ExtraFileEntry): DeployExtraFile => {
+    const normalizedDestination = normalize(destination);
+
     if (typeof entry === "string") {
-        return { destination, source: entry, mode: null };
+        return { destination: normalizedDestination, source: entry, mode: null };
     }
 
     const mode = entry.mode === undefined ? null : Number.parseInt(entry.mode, OCTAL_RADIX);
 
-    return { destination, source: entry.source, mode };
+    return { destination: normalizedDestination, source: entry.source, mode };
 };
 
 const resolveExtraFiles = (root: string, deploy: DeployConfig): DeployExtraFile[] => {

package/src/dev/catalog-writes.ts

@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { WrittenCatalog } from "../i18n/catalogs.js";
+
+type CatalogWrites = {
+    record: (catalogs: WrittenCatalog[]) => void;
+    hasWritten: (path: string) => boolean;
+};
+
+const hasContent = (path: string, content: Buffer): boolean => {
+    try {
+        return readFileSync(path).equals(content);
+    } catch {
+        return false;
+    }
+};
+
+const createCatalogWrites = (): CatalogWrites => {
+    const contents: Map<string, Buffer> = new Map();
+
+    return {
+        record: (catalogs) => {
+            for (const catalog of catalogs) {
+                contents.set(resolve(catalog.path), catalog.content);
+            }
+        },
+        hasWritten: (path) => {
+            const content = contents.get(resolve(path));
+
+            return content !== undefined && hasContent(path, content);
+        },
+    };
+};
+
+export { type CatalogWrites, createCatalogWrites };

package/src/dev/runner-deps.ts

@@ -17,6 +17,7 @@ import { isRefreshBoundary, performRefresh, staleExportName } from "../refresh-r
 import { gtkxFastRefresh } from "../vite-plugins/fast-refresh/swc-refresh.js";
 import { gtkxVitePlugins } from "../vite-plugins/index.js";
 import { gtkxReactDomPrebundle } from "../vite-plugins/react-dom-prebundle.js";
+import { type CatalogWrites, createCatalogWrites } from "./catalog-writes.js";
 
 const DEV_MODE = "development";
 const APPLICATION_POLL_INTERVAL_MS = 50;
@@ -43,7 +44,14 @@ const waitForApplicationId = async (timeoutMs: number, shouldKeepWaiting: () =>
 
 const readFileRevision = (path: string): Promise<string> => readFile(path, "utf8");
 
-const defaultDevRunnerDeps = (configFile: string): DevRunnerDeps => ({
+const devPlugins = (configFile: string, catalogWrites: CatalogWrites): DevRunnerDeps["plugins"] =>
+    (entryPath) => [
+        ...gtkxVitePlugins({ mode: DEV_MODE, entryPath, configFile, onCatalogsWritten: catalogWrites.record }),
+        ...gtkxFastRefresh(),
+        gtkxReactDomPrebundle(),
+    ];
+
+const createDevRunnerDeps = (configFile: string, catalogWrites: CatalogWrites): DevRunnerDeps => ({
     createServer,
     waitForApplicationId,
     getConfiguredApplicationId: async (root: string) => {
@@ -86,13 +94,13 @@ const defaultDevRunnerDeps = (configFile: string): DevRunnerDeps => ({
     isRefreshBoundary,
     staleExportName,
     readFileRevision,
-    plugins: (entryPath) => [
-        ...gtkxVitePlugins({ mode: DEV_MODE, entryPath, configFile }),
-        ...gtkxFastRefresh(),
-        gtkxReactDomPrebundle(),
-    ],
+    hasWrittenCatalog: catalogWrites.hasWritten,
+    plugins: devPlugins(configFile, catalogWrites),
     log: info,
     exit: (code: number): never => process.exit(code),
 });
 
+const defaultDevRunnerDeps = (configFile: string): DevRunnerDeps =>
+    createDevRunnerDeps(configFile, createCatalogWrites());
+
 export { defaultDevRunnerDeps };

package/src/dev/runner.ts

@@ -33,6 +33,7 @@ type DevRunnerDeps = {
     isRefreshBoundary(module: Record<string, unknown>): boolean;
     staleExportName(previous: Record<string, unknown>, current: Record<string, unknown>): string | null;
     readFileRevision(path: string): Promise<string>;
+    hasWrittenCatalog(path: string): boolean;
     plugins(entryPath: string): Plugin[];
     log(message: string): void;
     exit(code: number): never;
@@ -370,14 +371,22 @@ const restartForServerConfig = async (session: DevSession, changedPath: string):
     await requestRestart(session);
 };
 
+const restartForCatalog = async (session: DevSession, changedPath: string): Promise<void> => {
+    if (session.deps.hasWrittenCatalog(changedPath)) {
+        return;
+    }
+
+    session.deps.log(`Translation catalog changed: ${changedPath}`);
+    await requestRestart(session);
+};
+
 const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
     if (session.controller.isShuttingDown()) {
         return;
     }
 
     if (isCatalogSource(session.server.config.root, change.path)) {
-        session.deps.log(`Translation catalog changed: ${change.path}`);
-        await requestRestart(session);
+        await restartForCatalog(session, change.path);
 
         return;
     }

package/src/dev/supervisor.ts

@@ -1,7 +1,7 @@
 import { error, exitCodeForSignal, info, installGracefulShutdown } from "@gtkx/utils";
 import { fork as nodeFork } from "node:child_process";
-import { type FSWatcher, watch as watchFs } from "node:fs";
-import { basename, dirname } from "node:path";
+import { type FSWatcher, statSync, watch as watchFs } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
 
@@ -18,7 +18,8 @@ type ForkRunner = (modulePath: string, args: string[], env: NodeJS.ProcessEnv, c
 
 type DevWatch = {
     paths: string[];
-    regenerate: () => Promise<void>;
+    resolvePaths: () => string[];
+    regenerate: () => Promise<string[]>;
 };
 
 type SupervisorState = {
@@ -29,10 +30,13 @@ type SupervisorState = {
     args: string[];
     watch: DevWatch | undefined;
     watchers: FSWatcher[];
+    changedPaths: Set<string>;
+    restartTimer: DebounceTimer;
     fork: ForkRunner;
     child: SupervisedChild | null;
     isShuttingDown: boolean;
     isRestarting: boolean;
+    isRestartPending: boolean;
     capturedChildExit: number | undefined;
 };
 
@@ -141,39 +145,94 @@ const launch = (state: SupervisorState): void => {
     });
 };
 
-const isRestartBlocked = (state: SupervisorState): boolean => state.isRestarting || state.isShuttingDown;
-
-const relaunchAfterExit = (state: SupervisorState): void => {
+const runPendingRestart = (state: SupervisorState): void => {
     state.isRestarting = false;
 
+    if (!state.isRestartPending || state.isShuttingDown) {
+        return;
+    }
+
+    state.isRestartPending = false;
+    void restart(state);
+};
+
+const relaunchAfterExit = (state: SupervisorState): void => {
     if (state.isShuttingDown) {
+        state.isRestarting = false;
+
         return;
     }
 
     info("Restarting dev runner...");
     launch(state);
+    runPendingRestart(state);
+};
+
+const isSupervisorShuttingDown = (state: SupervisorState): boolean => state.isShuttingDown;
+
+const reconcileConfigWatchers = (
+    state: SupervisorState,
+    paths: string[],
+    previous: ReadonlyMap<string, string | null>,
+): void => {
+    const changed = changedWatchPaths(previous, paths);
+
+    closeWatchers(state);
+
+    if (state.watch !== undefined) {
+        state.watch.paths = paths;
+    }
+
+    if (state.isShuttingDown) {
+        return;
+    }
+
+    installConfigWatchers(state);
+
+    if (changed.length > 0 && !state.isRestartPending) {
+        scheduleRestart(state, changed);
+    }
+};
+
+const consumeChangedPaths = (state: SupervisorState): string => {
+    const changed = [...state.changedPaths].map((path) => relative(state.cwd, path));
+    state.changedPaths.clear();
+
+    return changed.length === 0 ? basename(state.configFile) : changed.join(", ");
 };
 
 const restart = async (state: SupervisorState): Promise<void> => {
     const watch = state.watch;
 
-    if (watch === undefined || isRestartBlocked(state)) {
+    if (watch === undefined || state.isShuttingDown) {
+        return;
+    }
+
+    if (state.isRestarting) {
+        state.isRestartPending = true;
+
         return;
     }
 
     state.isRestarting = true;
-    info("gtkx.config.ts changed; regenerating bindings...");
+    info(`${consumeChangedPaths(state)} changed; regenerating bindings...`);
+    closeWatchers(state);
+    watch.paths = watch.resolvePaths();
+    const previous = snapshotWatchPaths(watch.paths);
+    installConfigWatchers(state);
 
     try {
-        await watch.regenerate();
+        const paths = await watch.regenerate();
+        reconcileConfigWatchers(state, paths, previous);
     } catch (error_) {
+        reconcileConfigWatchers(state, watch.resolvePaths(), previous);
         error("Codegen failed; keeping the current dev runner. Fix the error and save again.", error_);
-        state.isRestarting = false;
+        runPendingRestart(state);
 
         return;
     }
 
-    if (state.isShuttingDown) {
+    if (isSupervisorShuttingDown(state)) {
         state.isRestarting = false;
 
         return;
@@ -182,8 +241,8 @@ const restart = async (state: SupervisorState): Promise<void> => {
     const current = state.child;
 
     if (current === null) {
-        state.isRestarting = false;
         launch(state);
+        runPendingRestart(state);
 
         return;
     }
@@ -195,29 +254,103 @@ const restart = async (state: SupervisorState): Promise<void> => {
     forwardSignal(current, "SIGTERM");
 };
 
-const scheduleRestart = (state: SupervisorState, timer: DebounceTimer): void => {
+const scheduleRestart = (state: SupervisorState, changedPaths: string[] = []): void => {
+    const timer = state.restartTimer;
+
+    for (const path of changedPaths) {
+        state.changedPaths.add(path);
+    }
+
     if (timer.handle !== null) {
         clearTimeout(timer.handle);
     }
 
-    timer.handle = setTimeout(() => void restart(state), CONFIG_DEBOUNCE_MS);
+    timer.handle = setTimeout(() => {
+        timer.handle = null;
+        void restart(state);
+    }, CONFIG_DEBOUNCE_MS);
 };
 
-const isWatchedChange = (state: SupervisorState, names: Set<string>, filename: string | Buffer | null): boolean => {
+const watchedChangePath = (
+    state: SupervisorState,
+    directory: string,
+    names: Set<string>,
+    filename: string | Buffer | null,
+): string | undefined => {
     if (filename === null || state.isShuttingDown) {
+        return undefined;
+    }
+
+    const name = basename(filename.toString());
+
+    return names.has(name) ? join(directory, name) : undefined;
+};
+
+const isDirectory = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isDirectory() === true;
+    } catch {
         return false;
     }
+};
 
-    return names.has(basename(filename.toString()));
+const nearestWatchTarget = (path: string): { directory: string; name: string } => {
+    let directory = dirname(path);
+    let name = basename(path);
+
+    while (!isDirectory(directory)) {
+        const parent = dirname(directory);
+
+        if (parent === directory) {
+            break;
+        }
+
+        name = basename(directory);
+        directory = parent;
+    }
+
+    return { directory, name };
 };
 
+const watchTargets = (paths: string[]): Set<string> =>
+    new Set(paths.flatMap((path) => {
+        const { directory, name } = nearestWatchTarget(path);
+
+        return [path, join(directory, name)];
+    }));
+
+const watchPathState = (path: string): string | null => {
+    try {
+        const stat = statSync(path, { bigint: true, throwIfNoEntry: false });
+
+        return stat === undefined
+            ? null
+            : [stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
+    } catch {
+        return null;
+    }
+};
+
+const snapshotWatchPaths = (paths: string[]): Map<string, string | null> =>
+    new Map([...watchTargets(paths)].map((path) => [path, watchPathState(path)]));
+
+const changedWatchPaths = (
+    previous: ReadonlyMap<string, string | null>,
+    paths: string[],
+): string[] =>
+    [...watchTargets(paths)].filter((path) => {
+        const current = watchPathState(path);
+
+        return previous.has(path) ? previous.get(path) !== current : current !== null;
+    });
+
 const groupWatchNamesByDirectory = (paths: string[]): Map<string, Set<string>> => {
     const namesByDirectory: Map<string, Set<string>> = new Map();
 
     for (const path of paths) {
-        const directory = dirname(path);
+        const { directory, name } = nearestWatchTarget(path);
         const names = namesByDirectory.get(directory) ?? new Set<string>();
-        names.add(basename(path));
+        names.add(name);
         namesByDirectory.set(directory, names);
     }
 
@@ -228,16 +361,23 @@ const watchConfigDirectory = (
     state: SupervisorState,
     directory: string,
     names: Set<string>,
-    timer: DebounceTimer,
 ): void => {
-    const watcher = watchFs(directory, (_event, filename) => {
-        if (isWatchedChange(state, names, filename)) {
-            scheduleRestart(state, timer);
-        }
-    });
+    try {
+        const watcher = watchFs(directory, (_event, filename) => {
+            const changed = watchedChangePath(state, directory, names, filename);
+
+            if (changed !== undefined) {
+                scheduleRestart(state, [changed]);
+            }
+        });
 
-    watcher.on("error", (): void => undefined);
-    state.watchers.push(watcher);
+        watcher.on("error", (cause) => {
+            error(`Configuration watch failed for ${directory}`, cause);
+        });
+        state.watchers.push(watcher);
+    } catch (error_) {
+        error(`Configuration watch failed for ${directory}`, error_);
+    }
 };
 
 const installConfigWatchers = (state: SupervisorState): void => {
@@ -247,10 +387,8 @@ const installConfigWatchers = (state: SupervisorState): void => {
         return;
     }
 
-    const timer: DebounceTimer = { handle: null };
-
     for (const [directory, names] of groupWatchNamesByDirectory(watch.paths)) {
-        watchConfigDirectory(state, directory, names, timer);
+        watchConfigDirectory(state, directory, names);
     }
 };
 
@@ -258,6 +396,8 @@ const closeWatchers = (state: SupervisorState): void => {
     for (const watcher of state.watchers) {
         watcher.close();
     }
+
+    state.watchers = [];
 };
 
 const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promise<void> =>
@@ -265,6 +405,11 @@ const shutdownOnSignal = (state: SupervisorState, signal: NodeJS.Signals): Promi
         state.isShuttingDown = true;
         closeWatchers(state);
 
+        if (state.restartTimer.handle !== null) {
+            clearTimeout(state.restartTimer.handle);
+            state.restartTimer.handle = null;
+        }
+
         if (!state.child) {
             resolve();
 
@@ -298,10 +443,13 @@ const runDevSupervisor = async (options: DevSupervisorOptions): Promise<never> =
         args,
         watch,
         watchers: [],
+        changedPaths: new Set(),
+        restartTimer: { handle: null },
         fork,
         child: null,
         isShuttingDown: false,
         isRestarting: false,
+        isRestartPending: false,
         capturedChildExit: undefined,
     };