@vscode/component-explorer-cli 0.2.1-3 → 0.2.1-31

package/dist/mcp/McpServer.js

@@ -8,120 +8,17 @@ import { autorun } from '../external/vscode-observables/observables/dist/observa
 import '../external/vscode-observables/observables/dist/observableInternal/observables/derived.js';
 import '../external/vscode-observables/observables/dist/observableInternal/utils/utils.js';
 import '../external/vscode-observables/observables/dist/observableInternal/observables/observableFromEvent.js';
-import { buildExplorerUrl } from '../utils.js';
+import '../packages/common/dist/renderManifest.js';
+import { buildExplorerUrl } from '../packages/common/dist/explorerUrl.js';
+import { EXPLORER_ROUTE } from '../utils.js';
 import { TaskManager } from './TaskManager.js';
+import { isPipeConnectionError } from '../daemon/pipeClient.js';
 
-// ---------------------------------------------------------------------------
-// Client-local state
-// ---------------------------------------------------------------------------
-class ImageLruCache {
-    _maxSize;
-    _entries = [];
-    constructor(_maxSize = 10) {
-        this._maxSize = _maxSize;
-    }
-    put(hash, image) {
-        const idx = this._entries.findIndex(e => e.hash === hash);
-        if (idx !== -1) {
-            this._entries.splice(idx, 1);
-        }
-        this._entries.unshift({ hash, image });
-        if (this._entries.length > this._maxSize) {
-            this._entries.length = this._maxSize;
-        }
-    }
-    get(hash) {
-        const idx = this._entries.findIndex(e => e.hash === hash);
-        if (idx === -1) {
-            return undefined;
-        }
-        const [entry] = this._entries.splice(idx, 1);
-        this._entries.unshift(entry);
-        return entry.image;
-    }
-    keys() {
-        return this._entries.map(e => e.hash);
-    }
-}
-class WatchList {
-    _fixtureIds = new Set();
-    _hashes = new Map();
-    get fixtureIds() { return this._fixtureIds; }
-    add(ids) {
-        for (const id of ids) {
-            this._fixtureIds.add(id);
-        }
-    }
-    remove(ids) {
-        for (const id of ids) {
-            this._fixtureIds.delete(id);
-            this._hashes.delete(id);
-        }
-    }
-    set(ids) {
-        this._fixtureIds.clear();
-        this._hashes.clear();
-        for (const id of ids) {
-            this._fixtureIds.add(id);
-        }
-    }
-    getHash(fixtureId) {
-        return this._hashes.get(fixtureId);
-    }
-    setHash(fixtureId, hash) {
-        this._hashes.set(fixtureId, hash);
-    }
-    toJSON() {
-        return {
-            fixtureIds: [...this._fixtureIds],
-            hashes: Object.fromEntries(this._hashes),
-        };
-    }
-}
-function noDaemonError(hint) {
-    let text = 'Error: No daemon is currently running.';
-    if (hint) {
-        text += ` ${hint}`;
-    }
-    else {
-        text += ' Please start the Component Explorer daemon first by running:\n\n' +
-            '  component-explorer serve --project <config.json>\n\n' +
-            'Or start it in the background:\n\n' +
-            '  component-explorer serve --project <config.json> --background\n\n' +
-            'The daemon manages dev servers and enables fixture screenshots.';
-    }
-    return {
-        content: [{ type: 'text', text }],
-        isError: true,
-    };
-}
-// ---------------------------------------------------------------------------
-// DaemonConnection - wrapper to avoid Proxy issues with observables
-// ---------------------------------------------------------------------------
-class DaemonConnection {
-    client;
-    _stale = false;
-    constructor(client) {
-        this.client = client;
-    }
-    get isStale() { return this._stale; }
-    markStale() { this._stale = true; }
-}
-function isPipeConnectionError(e) {
-    if (!(e instanceof Error)) {
-        return false;
-    }
-    const code = e.code;
-    if (code === 'ENOENT' || code === 'ECONNREFUSED' || code === 'ECONNRESET' || code === 'EPIPE') {
-        return true;
-    }
-    return /connect ENOENT|ECONNREFUSED|ECONNRESET|EPIPE/.test(e.message);
-}
 // ---------------------------------------------------------------------------
 // ComponentExplorerMcpServer
 // ---------------------------------------------------------------------------
 class ComponentExplorerMcpServer extends Disposable {
-    _daemonConnection;
+    _daemon;
     static async create(daemon, options) {
         const server = new ComponentExplorerMcpServer(daemon, options ?? {});
         const transport = new StdioServerTransport();
@@ -133,16 +30,12 @@ class ComponentExplorerMcpServer extends Disposable {
     _imageLru = new ImageLruCache(10);
     _taskManager = new TaskManager();
     _taskLastReportedIndex = new Map();
-    _pollFn;
-    _noAutostartHint;
     _multiSessionTools = [];
     _sessions = [];
     _eventStreamAbortController;
-    constructor(_daemonConnection, options) {
+    constructor(_daemon, options) {
         super();
-        this._daemonConnection = _daemonConnection;
-        this._pollFn = options.pollFn;
-        this._noAutostartHint = options.noAutostartHint;
+        this._daemon = _daemon;
         this._callTimeoutMs = options.callTimeoutMs ?? ComponentExplorerMcpServer._DEFAULT_CALL_TIMEOUT_MS;
         this._mcp = new McpServer({
             name: 'component-explorer',
@@ -150,8 +43,8 @@ class ComponentExplorerMcpServer extends Disposable {
         });
         this._registerTools();
         this._store.add(autorun(async (reader) => {
-            const conn = this._daemonConnection.read(reader);
-            await this._onDaemonChanged(conn?.client);
+            const client = this._daemon.connection.read(reader);
+            await this._onDaemonChanged(client);
         }));
     }
     async _onDaemonChanged(daemon) {
@@ -173,49 +66,13 @@ class ComponentExplorerMcpServer extends Disposable {
             this._sessions = [];
         }
     }
-    _getConnection() {
-        const conn = this._daemonConnection.get();
-        if (conn?.isStale) {
-            return undefined;
-        }
-        return conn;
-    }
-    async _waitForDaemon() {
-        let conn = this._getConnection();
-        if (conn) {
-            return conn.client;
-        }
-        if (!this._pollFn) {
-            return undefined;
-        }
-        this._log('debug', { type: 'waiting-for-daemon' });
-        const startTime = Date.now();
-        const timeout = 3000;
-        while (Date.now() - startTime < timeout) {
-            await this._pollFn();
-            conn = this._getConnection();
-            if (conn) {
-                return conn.client;
-            }
-            await new Promise(resolve => setTimeout(resolve, 200));
-        }
-        return undefined;
-    }
-    _handleDisconnect() {
-        const conn = this._daemonConnection.get();
-        if (conn && !conn.isStale) {
-            conn.markStale();
-            this._sessions = [];
-            this._log('debug', { type: 'daemon-connection-lost' });
-        }
-    }
     _noDaemonError() {
-        return noDaemonError(this._noAutostartHint);
+        return noDaemonError(this._daemon.noDaemonHint);
     }
     static _DEFAULT_CALL_TIMEOUT_MS = 15_000;
     _callTimeoutMs;
     async _withDaemon(fn, options) {
-        const daemon = await this._waitForDaemon();
+        const daemon = await this._daemon.getDaemonOrStart();
         if (!daemon) {
             return this._noDaemonError();
         }
@@ -235,7 +92,6 @@ class ComponentExplorerMcpServer extends Disposable {
             }
             if (isPipeConnectionError(e)) {
                 this._log('debug', { type: 'daemon-call-failed', error: String(e) });
-                this._handleDisconnect();
                 return this._noDaemonError();
             }
             throw e;
@@ -259,7 +115,7 @@ class ComponentExplorerMcpServer extends Disposable {
                         this._updateSessionSourceTreeId(event.sessionName, event.sourceTreeId);
                     }
                     if (event.type === 'ref-change' || event.type === 'session-change') {
-                        await this._refreshSessions();
+                        await this._refreshSessions(daemon);
                     }
                     this._log(event.type === 'log' && event.level === 'debug' ? 'debug' : 'info', event);
                 }
@@ -293,24 +149,11 @@ class ComponentExplorerMcpServer extends Disposable {
             s.sourceTreeId = sourceTreeId;
         }
     }
-    async _refreshSessions() {
-        const conn = this._getConnection();
-        if (conn) {
-            try {
-                const prevCount = this._sessions.length;
-                this._sessions = await conn.client.methods.sessions();
-                if (this._sessions.length !== prevCount) {
-                    this._updateMultiSessionToolVisibility();
-                }
-            }
-            catch (e) {
-                if (isPipeConnectionError(e)) {
-                    this._handleDisconnect();
-                }
-                else {
-                    throw e;
-                }
-            }
+    async _refreshSessions(daemon) {
+        const prevCount = this._sessions.length;
+        this._sessions = await daemon.methods.sessions();
+        if (this._sessions.length !== prevCount) {
+            this._updateMultiSessionToolVisibility();
         }
     }
     _updateMultiSessionToolVisibility() {
@@ -324,37 +167,37 @@ class ComponentExplorerMcpServer extends Disposable {
             }
         }
     }
-    async _withSourceTreeRetry(fn) {
+    async _withSourceTreeRetry(daemon, fn) {
         try {
             return await fn();
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             if (msg.includes('Source tree changed')) {
-                await this._refreshSessions();
+                await this._refreshSessions(daemon);
                 return await fn();
             }
             throw e;
         }
     }
     // -- Tool registration ---------------------------------------------------
-    _filterFixtures(allFixtures, fixtureIdPattern, labelPattern) {
+    _filterFixtures(allFixtures, fixtureIdRegexStr, labelRegexStr) {
         let fixtureIdRegex;
-        if (fixtureIdPattern) {
+        if (fixtureIdRegexStr) {
             try {
-                fixtureIdRegex = new RegExp(fixtureIdPattern);
+                fixtureIdRegex = new RegExp(fixtureIdRegexStr);
             }
             catch {
-                return { error: `Error: Invalid fixtureIdPattern: ${fixtureIdPattern}` };
+                return { error: `Error: Invalid fixtureIdRegex: ${fixtureIdRegexStr}` };
             }
         }
         let labelRegex;
-        if (labelPattern) {
+        if (labelRegexStr) {
             try {
-                labelRegex = new RegExp(labelPattern);
+                labelRegex = new RegExp(labelRegexStr);
             }
             catch {
-                return { error: `Error: Invalid labelPattern: ${labelPattern}` };
+                return { error: `Error: Invalid labelRegex: ${labelRegexStr}` };
             }
         }
         return {
@@ -371,10 +214,10 @@ class ComponentExplorerMcpServer extends Disposable {
         this._registerCheckVisuals();
         this._registerEvaluateJs();
         this._registerDebugReloadPage();
-        this._registerWatchAdd();
-        this._registerWatchRemove();
-        this._registerWatchSet();
-        this._registerWatchCompare();
+        //this._registerWatchAdd();
+        //this._registerWatchRemove();
+        //this._registerWatchSet();
+        //this._registerWatchCompare();
         this._registerWaitForUpdate();
         this._registerSessions();
         this._registerRestartSession();
@@ -382,6 +225,7 @@ class ComponentExplorerMcpServer extends Disposable {
         this._registerCloseSession();
         this._registerUpdateSessionRef();
         this._registerGetUrl();
+        this._registerCheckFixtureErrors();
         this._registerCheckStability();
         this._registerCheckTask();
         this._registerCancelTask();
@@ -391,20 +235,20 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerListFixtures() {
         this._mcp.registerTool('list_fixtures', {
             description: 'List all fixtures from a session',
-            inputSchema: {
-                fixtureIdPattern: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
-                labelPattern: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
+            inputSchema: z.strictObject({
+                fixtureIdRegex: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelRegex: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             this._log('debug', { type: 'tool-call', tool: 'list_fixtures', sessionName });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 const listResult = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
-                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdPattern, args.labelPattern);
+                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdRegex, args.labelRegex);
                 if ('error' in filtered) {
                     return { content: [{ type: 'text', text: filtered.error }], isError: true };
                 }
@@ -420,19 +264,28 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerScreenshot() {
         this._mcp.registerTool('screenshot', {
             description: 'Take a screenshot of a single fixture. ' +
-                'When stabilityCheck is true, the fixture is unmounted and re-mounted, then three screenshots are taken. ',
-            inputSchema: {
+                'When stabilityCheck is true, the fixture is unmounted and re-mounted, then three screenshots are taken. ' +
+                'By default the fixture stays mounted after the screenshot (so a follow-up `evaluate_js` call can still operate on it); ' +
+                'pass `disposeAfter: true` to dispose immediately and surface any teardown errors as `currentDispose` in the result. ' +
+                'Errors / events captured while disposing the previously-mounted fixture (the implicit dispose at the start of every render) are reported as `previousDispose`.',
+            inputSchema: z.strictObject({
                 fixtureId: z.string().describe('The fixture ID'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
                 stabilityCheck: z.boolean().optional().describe('If true, takes three screenshots (at render time, ~500ms, ~3000ms) to check visual stability. Expensive (~3s extra) — only use it when you need to verify rendering stability..'),
-            },
+                includeConsoleLog: z.boolean().optional().describe('If true, include console.log events in the returned events array. Defaults to false — console.log entries are filtered out to reduce noise.'),
+                input: z.unknown().optional().describe('Arbitrary JSON-serializable data passed to the fixture as `RenderContext.input`. ' +
+                    'The fixture decides how to interpret it (e.g. theme switch, scenario selection, mock data).'),
+                disposeAfter: z.boolean().optional().describe('If true, dispose the fixture after taking the screenshot. ' +
+                    'Default: false — the fixture stays mounted until the next render, so `evaluate_js` can still operate on it. ' +
+                    'Use this when validating fixture teardown: dispose errors / events appear in `currentDispose`.'),
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             this._log('debug', { type: 'tool-call', tool: 'screenshot', fixtureId: args.fixtureId, sessionName });
             this._log('trace', { type: 'tool-args', tool: 'screenshot', args });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 const result = await daemon.methods.screenshots.take({
                     fixtureId: args.fixtureId,
@@ -440,6 +293,8 @@ class ComponentExplorerMcpServer extends Disposable {
                     sourceTreeId,
                     includeImage: true,
                     stabilityCheck: args.stabilityCheck,
+                    input: args.input,
+                    disposeAfter: args.disposeAfter,
                 });
                 const r = result;
                 this._updateSessionSourceTreeId(sessionName, r.sourceTreeId);
@@ -447,6 +302,7 @@ class ComponentExplorerMcpServer extends Disposable {
                 if (r.hash && r.image) {
                     this._imageLru.put(r.hash, r.image);
                 }
+                const filterEvents = (events) => args.includeConsoleLog ? events : events.filter(e => e.type !== 'console.log');
                 const info = {
                     hash: r.hash,
                     sourceTreeId: r.sourceTreeId,
@@ -458,14 +314,37 @@ class ComponentExplorerMcpServer extends Disposable {
                     info.error = r.error;
                 }
                 if (r.events && r.events.length > 0) {
-                    info.events = r.events;
+                    const filtered = filterEvents(r.events);
+                    if (filtered.length > 0) {
+                        info.events = filtered;
+                    }
                 }
-                if (r.resultData !== undefined) {
-                    info.resultData = r.resultData;
+                if (r.output !== undefined) {
+                    info.output = r.output;
                 }
                 if (r.isStable !== undefined) {
                     info.isStable = r.isStable;
                 }
+                if (r.previousDispose) {
+                    const filtered = filterEvents(r.previousDispose.events);
+                    if (r.previousDispose.hasError || r.previousDispose.errors.length > 0 || filtered.length > 0) {
+                        info.previousDispose = {
+                            hasError: r.previousDispose.hasError,
+                            errors: r.previousDispose.errors,
+                            events: filtered,
+                        };
+                    }
+                }
+                if (r.currentDispose) {
+                    const filtered = filterEvents(r.currentDispose.events);
+                    if (r.currentDispose.hasError || r.currentDispose.errors.length > 0 || filtered.length > 0) {
+                        info.currentDispose = {
+                            hasError: r.currentDispose.hasError,
+                            errors: r.currentDispose.errors,
+                            events: filtered,
+                        };
+                    }
+                }
                 // Visual review status
                 if (r.hash) {
                     try {
@@ -509,19 +388,19 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerCompareScreenshot() {
         const tool = this._mcp.registerTool('compare_screenshot', {
             description: 'Compare a fixture\'s screenshot across two sessions (e.g. baseline vs current)',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureId: z.string().describe('The fixture ID'),
                 baselineSessionName: z.string().optional().describe('Baseline session name (defaults to worktree session)'),
                 currentSessionName: z.string().optional().describe('Current session name (defaults to current session)'),
                 baselineSourceTreeId: z.string().optional().describe('Baseline source tree ID (defaults to latest known)'),
                 currentSourceTreeId: z.string().optional().describe('Current source tree ID (defaults to latest known)'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const baselineSessionName = args.baselineSessionName ?? this._defaultBaselineSessionName();
             const currentSessionName = args.currentSessionName ?? this._defaultCurrentSessionName();
             this._log('debug', { type: 'tool-call', tool: 'compare_screenshot', fixtureId: args.fixtureId, baselineSessionName, currentSessionName });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
                 const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
                 const result = await daemon.methods.screenshots.compare({
@@ -549,8 +428,8 @@ class ComponentExplorerMcpServer extends Disposable {
                 if (r.baselineEvents && r.baselineEvents.length > 0) {
                     info.baselineEvents = r.baselineEvents;
                 }
-                if (r.baselineResultData !== undefined) {
-                    info.baselineResultData = r.baselineResultData;
+                if (r.baselineOutput !== undefined) {
+                    info.baselineOutput = r.baselineOutput;
                 }
                 if (r.currentHasError) {
                     info.currentHasError = true;
@@ -561,8 +440,8 @@ class ComponentExplorerMcpServer extends Disposable {
                 if (r.currentEvents && r.currentEvents.length > 0) {
                     info.currentEvents = r.currentEvents;
                 }
-                if (r.currentResultData !== undefined) {
-                    info.currentResultData = r.currentResultData;
+                if (r.currentOutput !== undefined) {
+                    info.currentOutput = r.currentOutput;
                 }
                 if (r.approval) {
                     info.approval = r.approval;
@@ -585,12 +464,12 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerApproveDiff() {
         const tool = this._mcp.registerTool('approve_diff', {
             description: 'Approve a visual diff so it won\'t require re-inspection next time',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureId: z.string(),
                 originalHash: z.string(),
                 modifiedHash: z.string(),
                 comment: z.string().describe('Reason for approving this diff'),
-            },
+            }),
         }, async (args) => this._withDaemon(async (daemon) => {
             await daemon.methods.approvals.approve(args);
             return {
@@ -608,18 +487,18 @@ class ComponentExplorerMcpServer extends Disposable {
             description: 'Approve or reject a fixture\'s screenshot based on its expectedVisualDescriptions. ' +
                 'You must take a screenshot first and pass the resulting hash. ' +
                 'On approve, caches (expectedVisualDescriptions, screenshotHash) so future runs auto-approve.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureId: z.string().describe('The fixture ID'),
                 screenshotHash: z.string().describe('The screenshot hash (from a prior screenshot tool call)'),
                 verdict: z.enum(['approve', 'reject']).describe('Whether the visual matches expectations'),
                 comment: z.string().describe('Reason for the verdict'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
-            },
+            }),
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             this._log('debug', { type: 'tool-call', tool: 'review_visual', fixtureId: args.fixtureId, verdict: args.verdict });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 // Get fixture descriptions
                 const listResult = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
@@ -643,13 +522,15 @@ class ComponentExplorerMcpServer extends Disposable {
                 }
                 else {
                     return {
-                        content: [{ type: 'text', text: JSON.stringify({
+                        content: [{
+                                type: 'text', text: JSON.stringify({
                                     fixtureId: args.fixtureId,
                                     verdict: 'rejected',
                                     comment: args.comment,
                                     screenshotHash: args.screenshotHash,
                                     expectedVisualDescriptions: fixture.expectedVisualDescriptions,
-                                }, null, 2) }],
+                                }, null, 2)
+                            }],
                     };
                 }
             });
@@ -659,23 +540,23 @@ class ComponentExplorerMcpServer extends Disposable {
         this._mcp.registerTool('check_visuals', {
             description: 'Batch check visual review status for fixtures that have expectedVisualDescription. ' +
                 'Returns lists of approved, needs-review, and no-expectation fixtures.',
-            inputSchema: {
-                fixtureIdPattern: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
-                labelPattern: z.string().optional().describe('RegExp to filter fixtures by label'),
+            inputSchema: z.strictObject({
+                fixtureIdRegex: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelRegex: z.string().optional().describe('RegExp to filter fixtures by label'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             this._log('debug', { type: 'tool-call', tool: 'check_visuals', sessionName });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 const listResult = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
                 if (listResult.loadError) {
                     return { content: [{ type: 'text', text: `Error: Fixture loading failed: ${listResult.loadError}\nThe fixture list may be incomplete.` }], isError: true };
                 }
-                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdPattern, args.labelPattern);
+                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdRegex, args.labelRegex);
                 if ('error' in filtered) {
                     return { content: [{ type: 'text', text: filtered.error }], isError: true };
                 }
@@ -733,17 +614,17 @@ class ComponentExplorerMcpServer extends Disposable {
                 'Returns the expression result as JSON. The expression can return a Promise (it will be awaited). ' +
                 'Use this to inspect DOM state, computed styles, element dimensions, or component output. ' +
                 'Do NOT use this to modify the DOM — this tool is for read-only inspection and debugging only.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 expression: z.string().describe('JavaScript expression to evaluate. Can return a Promise. The result must be JSON-serializable.'),
                 fixtureId: z.string().optional().describe('If provided, renders this fixture before evaluating the expression'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
-            },
+            }),
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             this._log('debug', { type: 'tool-call', tool: 'evaluate_js', sessionName, hasFixtureId: !!args.fixtureId });
             this._log('trace', { type: 'tool-args', tool: 'evaluate_js', expressionLength: args.expression.length, fixtureId: args.fixtureId });
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 const result = await daemon.methods.evaluate({
                     sessionName,
@@ -770,9 +651,9 @@ class ComponentExplorerMcpServer extends Disposable {
             description: 'Force-reload the browser page used for rendering fixtures. ' +
                 'Only use this as a last resort if screenshots or evaluate_js return stale/broken results ' +
                 'that persist after source changes. Normal HMR updates should handle most cases automatically.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
-            },
+            }),
             annotations: { destructiveHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
@@ -790,9 +671,9 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerWatchAdd() {
         this._mcp.registerTool('watch_add', {
             description: 'Add fixtures to the watch list. Watched fixtures are automatically re-screenshotted when source changes.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureIds: z.array(z.string()).describe('Fixture IDs to add'),
-            },
+            }),
         }, async (args) => {
             this._watchList.add(args.fixtureIds);
             return {
@@ -806,9 +687,9 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerWatchRemove() {
         this._mcp.registerTool('watch_remove', {
             description: 'Remove fixtures from the watch list',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureIds: z.array(z.string()).describe('Fixture IDs to remove'),
-            },
+            }),
         }, async (args) => {
             this._watchList.remove(args.fixtureIds);
             return {
@@ -822,9 +703,9 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerWatchSet() {
         this._mcp.registerTool('watch_set', {
             description: 'Replace the watch list entirely',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 fixtureIds: z.array(z.string()).describe('Fixture IDs to watch'),
-            },
+            }),
         }, async (args) => {
             this._watchList.set(args.fixtureIds);
             return {
@@ -838,12 +719,12 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerWatchCompare() {
         const tool = this._mcp.registerTool('watch_compare', {
             description: 'Compare all watched fixtures across two sessions. Takes fresh screenshots from both sessions and reports which fixtures differ.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 baselineSessionName: z.string().optional().describe('Baseline session name (defaults to worktree session)'),
                 currentSessionName: z.string().optional().describe('Current session name (defaults to current session)'),
                 baselineSourceTreeId: z.string().optional().describe('Baseline source tree ID (defaults to latest known)'),
                 currentSourceTreeId: z.string().optional().describe('Current source tree ID (defaults to latest known)'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const ids = [...this._watchList.fixtureIds];
@@ -852,7 +733,7 @@ class ComponentExplorerMcpServer extends Disposable {
             }
             const baselineSessionName = args.baselineSessionName ?? this._defaultBaselineSessionName();
             const currentSessionName = args.currentSessionName ?? this._defaultCurrentSessionName();
-            return this._withSourceTreeRetry(async () => {
+            return this._withSourceTreeRetry(daemon, async () => {
                 const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
                 const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
                 const [baselineResult, currentResult] = await Promise.all([
@@ -908,10 +789,10 @@ class ComponentExplorerMcpServer extends Disposable {
                 'Pass the sourceTreeId you already observed — resolves immediately if it already differs, ' +
                 'otherwise waits for a source-change or ref-change event. ' +
                 'If fixtures are on the watch list, automatically re-screenshots them and reports which changed.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 sourceTreeId: z.string().describe('The sourceTreeId the client currently knows about. The call resolves once the source tree differs from this value.'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
@@ -945,7 +826,7 @@ class ComponentExplorerMcpServer extends Disposable {
                         this._updateSessionSourceTreeId(ev.sessionName, ev.sourceTreeId);
                     }
                     if (ev.type === 'ref-change') {
-                        const refreshResult = await Promise.race([this._refreshSessions(), timeout]);
+                        const refreshResult = await Promise.race([this._refreshSessions(daemon), timeout]);
                         if (refreshResult === 'timeout') {
                             return { content: [{ type: 'text', text: JSON.stringify({ timeout: true, sessionName, sourceTreeId: knownSourceTreeId }, null, 2) }] };
                         }
@@ -1002,8 +883,8 @@ class ComponentExplorerMcpServer extends Disposable {
         this._mcp.registerTool('sessions', {
             description: 'List active sessions with their names, URLs, and current sourceTreeIds',
             annotations: { readOnlyHint: true },
-        }, async () => this._withDaemon(async (_daemon) => {
-            await this._refreshSessions();
+        }, async () => this._withDaemon(async (daemon) => {
+            await this._refreshSessions(daemon);
             return {
                 content: [{ type: 'text', text: JSON.stringify(this._sessions, null, 2) }],
             };
@@ -1013,9 +894,9 @@ class ComponentExplorerMcpServer extends Disposable {
         this._mcp.registerTool('restart_session', {
             description: 'Restart a session by disposing its browser page and dev server, then recreating them. ' +
                 'Use this when a session appears stuck (e.g. after a timeout).',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 sessionName: z.string().optional().describe('Session name to restart (defaults to first session)'),
-            },
+            }),
             annotations: { destructiveHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
@@ -1033,10 +914,10 @@ class ComponentExplorerMcpServer extends Disposable {
                 'The ref can be a branch name, tag, commit SHA, or the special value "INDEX" to snapshot staged changes. ' +
                 'The daemon allocates a reusable worktree slot from a fixed pool (max configured in component-explorer.json). ' +
                 'Returns the updated session list on success.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 name: z.string().describe('Unique session name (e.g. "baseline", "bisect")'),
                 ref: z.string().describe('Git ref: branch, tag, commit SHA, or "INDEX" for staged changes'),
-            },
+            }),
         }, async (args) => this._withDaemon(async (daemon) => {
             this._log('info', { type: 'tool-call', tool: 'open_session', name: args.name, ref: args.ref });
             const result = await daemon.methods.openSession({ name: args.name, ref: args.ref });
@@ -1054,9 +935,9 @@ class ComponentExplorerMcpServer extends Disposable {
         this._mcp.registerTool('close_session', {
             description: 'Close a dynamic worktree session and release its worktree slot back to the pool. ' +
                 'Cannot close static sessions configured in component-explorer.json.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 name: z.string().describe('Session name to close'),
-            },
+            }),
             annotations: { destructiveHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             this._log('info', { type: 'tool-call', tool: 'close_session', name: args.name });
@@ -1077,10 +958,10 @@ class ComponentExplorerMcpServer extends Disposable {
                 'The worktree is checked out to the new ref and Vite\'s HMR handles the incremental update (no server restart). ' +
                 'Fails if the worktree has uncommitted changes — the error will list the dirty files. ' +
                 'The ref can be a branch, tag, commit SHA, or "INDEX" for staged changes.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 name: z.string().describe('Session name to update'),
                 ref: z.string().describe('New git ref: branch, tag, commit SHA, or "INDEX"'),
-            },
+            }),
         }, async (args) => this._withDaemon(async (daemon) => {
             this._log('info', { type: 'tool-call', tool: 'update_session_ref', name: args.name, ref: args.ref });
             const result = await daemon.methods.updateSessionRef({ name: args.name, ref: args.ref });
@@ -1095,33 +976,19 @@ class ComponentExplorerMcpServer extends Disposable {
     }
     _registerGetUrl() {
         this._mcp.registerTool('get_url', {
-            description: 'Get URL(s) for viewing fixtures. Returns the Component Explorer UI URL by default, ' +
-                'or the raw render URL for embedding/screenshots when useRawDirectRenderingWithoutExplorerUi is true.',
-            inputSchema: {
+            description: 'Get URL for viewing fixtures. Returns the full Component Explorer UI by default. ' +
+                'Use `embedded: true` for a minimal single-fixture view (requires fixtureId).',
+            inputSchema: z.strictObject({
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
-                fixtureId: z.string().optional().describe('Specific fixture ID. If omitted, returns URL for the explorer root or all fixtures.'),
-                useRawDirectRenderingWithoutExplorerUi: z.boolean().optional().describe('If true, returns the raw rendering URL (for embedding or screenshots) instead of the Explorer UI URL. ' +
-                    'The raw URL renders only the fixture without the explorer chrome. Default: false.'),
-            },
+                fixtureId: z.string().optional().describe('Specific fixture ID to view. In explorer mode, pre-selects this fixture. In embedded mode (required), shows only this fixture.'),
+                embedded: z.boolean().optional().describe('If true, returns an embedded single-fixture URL (minimal UI, requires fixtureId). Default: false (full explorer UI).'),
+            }),
             annotations: { readOnlyHint: true },
-        }, async (args) => {
+        }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
             let session = this._sessions.find(s => s.name === sessionName);
             if (!session) {
-                const daemon = await this._waitForDaemon();
-                if (daemon) {
-                    try {
-                        await this._refreshSessions();
-                    }
-                    catch (e) {
-                        if (isPipeConnectionError(e)) {
-                            this._handleDisconnect();
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
-                }
+                await this._refreshSessions(daemon);
                 session = this._sessions.find(s => s.name === sessionName);
                 if (!session) {
                     return {
@@ -1143,10 +1010,21 @@ class ComponentExplorerMcpServer extends Disposable {
                     isError: true,
                 };
             }
-            const useRaw = args.useRawDirectRenderingWithoutExplorerUi ?? false;
+            // Validate embedded mode requires fixtureId
+            if (args.embedded && !args.fixtureId) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'Error: embedded mode requires a fixtureId.',
+                        }],
+                    isError: true,
+                };
+            }
+            const mode = args.embedded ? 'embedded' : undefined;
             const url = buildExplorerUrl({
                 baseUrl,
-                rawRender: useRaw,
+                pathname: EXPLORER_ROUTE,
+                mode,
                 fixtureId: args.fixtureId,
             });
             const result = {
@@ -1156,42 +1034,164 @@ class ComponentExplorerMcpServer extends Disposable {
             if (args.fixtureId) {
                 result.fixtureId = args.fixtureId;
             }
-            if (useRaw) {
-                result.mode = 'raw-render';
-            }
-            else {
-                result.mode = 'explorer';
-                if (args.fixtureId) {
-                    result.note = 'Fixture selection in the Explorer UI is not URL-based. Navigate to the fixture manually in the tree view.';
-                }
-            }
+            result.mode = args.embedded ? 'embedded' : 'explorer';
             return {
                 content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
             };
-        });
+        }));
+    }
+    _registerCheckFixtureErrors() {
+        this._mcp.registerTool('check_fixture_errors', {
+            description: 'Render fixtures and check for errors. Each fixture is rendered and then disposed; ' +
+                'render exceptions appear as `error`, dispose exceptions as `disposeError`, and console / window ' +
+                'events from both phases are collected in `events` (each tagged with `phase: "render" | "dispose"`). ' +
+                'A fixture is considered errored if either the render or the dispose phase reports `hasError` ' +
+                '(i.e. an exception was thrown or an event of type `console.error` / `window.error` / `window.unhandledrejection` was captured). ' +
+                'Only errored fixtures are listed; successful fixtures are summarised via the `summary` counts. ' +
+                'Returns results directly if finished within ~10s, otherwise returns a taskId for polling via check_task.',
+            inputSchema: z.strictObject({
+                fixtureIdRegex: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelRegex: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+                sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
+                reloadBetweenFixtures: z.boolean().optional().describe('If true, reload the browser page between fixtures. Provides cleaner isolation but is slower. ' +
+                    'Default: false (the page is only reloaded after a fixture errors).'),
+                input: z.unknown().optional().describe('Arbitrary JSON object passed to every fixture as `RenderContext.input`. ' +
+                    'See `screenshot` for details.'),
+            }),
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            this._log('debug', { type: 'tool-call', tool: 'check_fixture_errors', sessionName, fixtureIdRegex: args.fixtureIdRegex, labelRegex: args.labelRegex });
+            return this._withSourceTreeRetry(daemon, async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const listResult = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
+                if (listResult.loadError) {
+                    return { content: [{ type: 'text', text: `Error: Fixture loading failed: ${listResult.loadError}\nThe fixture list may be incomplete.` }], isError: true };
+                }
+                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdRegex, args.labelRegex);
+                if ('error' in filtered) {
+                    return { content: [{ type: 'text', text: filtered.error }], isError: true };
+                }
+                const fixtures = filtered.fixtures;
+                const task = this._taskManager.startTask(async (report, signal) => {
+                    // Only errored fixtures are stored/reported; successful fixtures would just bloat the response.
+                    // The summary below still surfaces the total/ok/errored counts.
+                    const erroredResults = [];
+                    let okCount = 0;
+                    let processed = 0;
+                    report({ completed: 0, total: fixtures.length, partialResult: erroredResults });
+                    for (let i = 0; i < fixtures.length; i++) {
+                        if (signal.aborted) {
+                            break;
+                        }
+                        const fixture = fixtures[i];
+                        try {
+                            const result = await daemon.methods.screenshots.take({
+                                fixtureId: fixture.fixtureId,
+                                sessionName,
+                                sourceTreeId,
+                                includeImage: false,
+                                // Skip the reload before the very first fixture — the page is already fresh.
+                                reloadBeforeRender: args.reloadBetweenFixtures && i > 0,
+                                input: args.input,
+                                // Always dispose after rendering so teardown errors / events are observable for every fixture
+                                // (including the last one). Because we explicitly dispose here, the implicit
+                                // `previousDispose` at the start of the next render is a no-op and need not be inspected.
+                                disposeAfter: true,
+                            });
+                            const r = result;
+                            const renderEvents = (r.events ?? []).map(e => ({ phase: 'render', ...e }));
+                            const disposeEvents = (r.currentDispose?.events ?? []).map(e => ({ phase: 'dispose', ...e }));
+                            const events = [...renderEvents, ...disposeEvents];
+                            const disposeError = r.currentDispose?.errors[0];
+                            // Trust the upstream `hasError` flags so this stays in sync with the render-report rules
+                            // (exception OR an event of type console.error / window.error / window.unhandledrejection).
+                            const hasError = r.hasError || !!r.currentDispose?.hasError;
+                            if (hasError) {
+                                const entry = { fixtureId: fixture.fixtureId, hasError: true };
+                                if (r.error) {
+                                    entry.error = r.error;
+                                }
+                                if (disposeError) {
+                                    entry.disposeError = disposeError;
+                                }
+                                if (events.length > 0) {
+                                    entry.events = events;
+                                }
+                                erroredResults.push(entry);
+                            }
+                            else {
+                                okCount++;
+                            }
+                        }
+                        catch (e) {
+                            erroredResults.push({
+                                fixtureId: fixture.fixtureId,
+                                hasError: true,
+                                error: { message: e instanceof Error ? e.message : String(e) },
+                            });
+                        }
+                        processed++;
+                        report({ completed: i + 1, total: fixtures.length, partialResult: erroredResults });
+                    }
+                    return {
+                        fixtures: erroredResults,
+                        summary: { total: processed, ok: okCount, errored: erroredResults.length },
+                    };
+                });
+                const waited = await this._taskManager.waitForTask(task.id, 10_000);
+                if (!waited) {
+                    return { content: [{ type: 'text', text: 'Error: task disappeared' }], isError: true };
+                }
+                if (waited.done) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(waited.result, null, 2) }],
+                    };
+                }
+                const partial = waited.progress.partialResult;
+                this._taskLastReportedIndex.set(task.id, partial.length);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                taskId: task.id,
+                                status: 'running',
+                                progress: { completed: waited.progress.completed, total: waited.progress.total },
+                                elapsedMs: waited.elapsedMs,
+                                results: partial,
+                            }, null, 2),
+                        }],
+                };
+            });
+        }));
     }
     _registerCheckStability() {
         this._mcp.registerTool('check_stability', {
             description: 'Check rendering stability of fixtures. Each fixture is unmounted, re-mounted, and screenshotted 3 times (~3s per fixture). ' +
                 'Returns results directly if finished within ~10s, otherwise returns a taskId for polling via check_task. ' +
                 'When returning a taskId, includes partial results collected so far.',
-            inputSchema: {
-                fixtureIdPattern: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
-                labelPattern: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
+            inputSchema: z.strictObject({
+                fixtureIdRegex: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelRegex: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
-            },
+                reloadBetweenFixtures: z.boolean().optional().describe('If true, reload the browser page between fixtures. Provides cleaner isolation but is slower. ' +
+                    'Default: false (the page is only reloaded after a fixture errors).'),
+                input: z.unknown().optional().describe('Arbitrary JSON object passed to every fixture as `RenderContext.input`. ' +
+                    'See `screenshot` for details.'),
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
-            this._log('debug', { type: 'tool-call', tool: 'check_stability', sessionName, fixtureIdPattern: args.fixtureIdPattern, labelPattern: args.labelPattern });
-            return this._withSourceTreeRetry(async () => {
+            this._log('debug', { type: 'tool-call', tool: 'check_stability', sessionName, fixtureIdRegex: args.fixtureIdRegex, labelRegex: args.labelRegex });
+            return this._withSourceTreeRetry(daemon, async () => {
                 const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
                 const listResult = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
                 if (listResult.loadError) {
                     return { content: [{ type: 'text', text: `Error: Fixture loading failed: ${listResult.loadError}\nThe fixture list may be incomplete.` }], isError: true };
                 }
-                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdPattern, args.labelPattern);
+                const filtered = this._filterFixtures(listResult.fixtures, args.fixtureIdRegex, args.labelRegex);
                 if ('error' in filtered) {
                     return { content: [{ type: 'text', text: filtered.error }], isError: true };
                 }
@@ -1212,6 +1212,9 @@ class ComponentExplorerMcpServer extends Disposable {
                             sourceTreeId,
                             includeImage: false,
                             stabilityCheck: true,
+                            // Skip the reload before the very first fixture — the page is already fresh.
+                            reloadBeforeRender: args.reloadBetweenFixtures && i > 0,
+                            input: args.input,
                         });
                         const r = result;
                         results.push({
@@ -1256,9 +1259,9 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerCheckTask() {
         this._mcp.registerTool('check_task', {
             description: 'Check on a running task. Waits up to ~2s for completion; if still running, returns progress and new results since last check.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 taskId: z.string().describe('The task ID returned by a previous tool call'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => {
             const waited = await this._taskManager.waitForTask(args.taskId, 2_000);
@@ -1306,9 +1309,9 @@ class ComponentExplorerMcpServer extends Disposable {
     _registerCancelTask() {
         this._mcp.registerTool('cancel_task', {
             description: 'Cancel a running task',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 taskId: z.string().describe('The task ID to cancel'),
-            },
+            }),
         }, async (args) => {
             const task = this._taskManager.getTask(args.taskId);
             if (!task) {
@@ -1328,9 +1331,9 @@ class ComponentExplorerMcpServer extends Disposable {
             description: 'Retrieve a recently-taken screenshot image by its hash. ' +
                 'Keeps the last ~10 images in an LRU cache. ' +
                 'Useful for debugging when screenshot hashes behave unexpectedly.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 hash: z.string().describe('The screenshot hash to look up'),
-            },
+            }),
             annotations: { readOnlyHint: true },
         }, async (args) => {
             const image = this._imageLru.get(args.hash);
@@ -1354,9 +1357,9 @@ class ComponentExplorerMcpServer extends Disposable {
                 'Only use this tool when the user explicitly asks to show or hide the browser. ' +
                 'Do not call this tool automatically or as part of other workflows. ' +
                 'Note: changing visibility closes the current browser instance, so the next screenshot or evaluate_js call will relaunch it.',
-            inputSchema: {
+            inputSchema: z.strictObject({
                 visible: z.boolean().describe('true to show the browser window (headed mode), false to hide it (headless mode)'),
-            },
+            }),
             annotations: { destructiveHint: true },
         }, async (args) => this._withDaemon(async (daemon) => {
             await daemon.methods.setBrowserVisibility({ visible: args.visible });
@@ -1366,6 +1369,90 @@ class ComponentExplorerMcpServer extends Disposable {
         }));
     }
 }
+// ---------------------------------------------------------------------------
+// Client-local state
+// ---------------------------------------------------------------------------
+class ImageLruCache {
+    _maxSize;
+    _entries = [];
+    constructor(_maxSize = 10) {
+        this._maxSize = _maxSize;
+    }
+    put(hash, image) {
+        const idx = this._entries.findIndex(e => e.hash === hash);
+        if (idx !== -1) {
+            this._entries.splice(idx, 1);
+        }
+        this._entries.unshift({ hash, image });
+        if (this._entries.length > this._maxSize) {
+            this._entries.length = this._maxSize;
+        }
+    }
+    get(hash) {
+        const idx = this._entries.findIndex(e => e.hash === hash);
+        if (idx === -1) {
+            return undefined;
+        }
+        const [entry] = this._entries.splice(idx, 1);
+        this._entries.unshift(entry);
+        return entry.image;
+    }
+    keys() {
+        return this._entries.map(e => e.hash);
+    }
+}
+class WatchList {
+    _fixtureIds = new Set();
+    _hashes = new Map();
+    get fixtureIds() { return this._fixtureIds; }
+    add(ids) {
+        for (const id of ids) {
+            this._fixtureIds.add(id);
+        }
+    }
+    remove(ids) {
+        for (const id of ids) {
+            this._fixtureIds.delete(id);
+            this._hashes.delete(id);
+        }
+    }
+    set(ids) {
+        this._fixtureIds.clear();
+        this._hashes.clear();
+        for (const id of ids) {
+            this._fixtureIds.add(id);
+        }
+    }
+    getHash(fixtureId) {
+        return this._hashes.get(fixtureId);
+    }
+    setHash(fixtureId, hash) {
+        this._hashes.set(fixtureId, hash);
+    }
+    toJSON() {
+        return {
+            fixtureIds: [...this._fixtureIds],
+            hashes: Object.fromEntries(this._hashes),
+        };
+    }
+}
+function noDaemonError(hint) {
+    let text = 'Error: No daemon is currently running.';
+    if (hint) {
+        text += ` ${hint}`;
+    }
+    else {
+        text += ' Please start the Component Explorer daemon first by running:\n\n' +
+            '  component-explorer serve --project <config.json>\n\n' +
+            'Or start it in the background:\n\n' +
+            '  component-explorer serve --project <config.json> --background\n\n' +
+            'The daemon manages dev servers and enables fixture screenshots.';
+    }
+    return {
+        content: [{ type: 'text', text }],
+        isError: true,
+    };
+}
 
-export { ComponentExplorerMcpServer, DaemonConnection };
+export { ComponentExplorerMcpServer };
 //# sourceMappingURL=McpServer.js.map