Commit 2ed3077

- Reconciles and restarts share one serialized queue (`enqueue`); a reconcile leaves a live stack alone, so the restart commands are the only path that rebuilds one. Do not add a second queue.

- Restart is a shell concern, not a stack one: `rstack.restart` rebuilds every controller, `rstack.<stack>.restart` rebuilds one. A stack must never register its own restart command — a shallower "bounce the tool's process" restart keeps that controller's stale package resolution and version check, which is the bug the command exists to clear.

- `projectModules.ts` has no cache-invalidation hook and restart must not grow one. Node's ESM registry is keyed by resolved URL and process-lifetime, so clearing the local memo hands back the identical module object (verified); a `?epoch=` query does reload the entry but relative specifiers inside it do not inherit the query, yielding a fresh entry over stale dependencies. In-place reinstalls under an unchanged path need a window reload — say so, don't fake it.

Config files and lockfiles are watched, so detection re-runs without a window reload. When something changes that none of those files record — a reinstall that leaves the lockfile untouched, or a `node_modules` that ends up broken — run **Rstack: Relaunch Extension** from the Command Palette (also on the status bar hover) to tear every tool down and start over. To rebuild a single tool, use **Rstack: Restart Rslint** / **Restart Rstest** / **Restart rs fmt**.

A restart re-resolves every binary and package version and respawns every tool process, but it cannot reload JavaScript the editor has already imported from your project — Node keeps those modules for the lifetime of the window. If a reinstall replaced `@rslint/core` in place and lint still behaves like the old version, reload the window. Deprecated `rslint.json` / `rslint.jsonc` configs are **not** detection signals — migrate them with `rslint --init`.

{

"command": "rstack.restart",

"title": "Relaunch Extension",

"category": "Rstack",

"icon": "$(debug-restart)"

},

"title": "Restart Rslint",

{

"command": "rstack.rstest.restart",

"title": "Restart Rstest",

"category": "Rstack",

"icon": "$(refresh)"

},

},

{

"command": "rstack.fmt.restart",

"title": "Restart rs fmt",

"category": "Rstack",

"icon": "$(refresh)"

{

"command": "rstack.rstest.restart",

"when": "rstack.rstest.active"

},

{

"command": "rstack.fmt.restart",

"when": "rstack.fmt.active"

},

// An externalized dependency is imported by the chunk itself, so it loads

// before any `rs.mock` can intervene — and `vscode-languageclient/node`

// does a bare `require('vscode')` at load time, which no mock can serve

// from plain Node. Bundling it routes that require through the bundler,

// where the `vscode` external (and therefore the mock) applies. This is

// what lets a test import the shell, whose module graph reaches the Rslint

// stack.

bundleDependencies: ['vscode-languageclient'],

import type vscode from 'vscode';

import type { DetectionSnapshot } from './types';

class EventEmitter {

readonly #listeners = new Set<(value: unknown) => void>();

readonly event = (listener: (value: unknown) => void) => {

this.#listeners.add(listener);

return {

dispose: () => {

this.#listeners.delete(listener);

},

};

};

fire(value: unknown): void {

for (const listener of [...this.#listeners]) {

listener(value);

}

}

dispose(): void {

this.#listeners.clear();

}

}

const disposable = { dispose: () => undefined };

const vscode = {

EventEmitter,

workspace: {

// No folder is open: every pass produces the empty snapshot, so the

// detection signature is unchanged by construction.

workspaceFolders: undefined,

onDidChangeWorkspaceFolders: () => disposable,

onDidChangeConfiguration: () => disposable,

},

};

DetectionService,

describe('DetectionService — notification rules', () => {

const fakeOutput = () =>

({

info: () => undefined,

warn: () => undefined,

error: () => undefined,

}) as unknown as vscode.LogOutputChannel;

const listen = (service: DetectionService) => {

const seen: DetectionSnapshot[] = [];

service.onDidChange((snapshot) => seen.push(snapshot));

return seen;

};

it('stays quiet when the signature did not change', async () => {

const service = new DetectionService(fakeOutput());

const seen = listen(service);

await service.initialize();

await service.refresh();

expect(seen).toHaveLength(0);

service.dispose();

});

it('does not notify after disposal', async () => {

const service = new DetectionService(fakeOutput());

const seen = listen(service);

await service.initialize();

service.dispose();

await service.refresh();

expect(seen).toHaveLength(0);

});

// resolutions are never retried until a window reload. Set by the lockfile

// watcher only — a caller that drives the rebuild itself does not need the

// event, it already has the fresh snapshot.

// Consumed before the first `await`: a pass that rejects (a folder removed

// mid-scan, a filesystem provider erroring) must not leave the flag set for

// an unrelated later pass to act on.

const notifyUnchanged = this.#notifyUnchanged;

this.#notifyUnchanged = false;