@vscode/component-explorer-cli 0.2.1-162 → 0.2.1-164

package/dist/daemon/DaemonService.js

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 import '../vscode-observables/observables/dist/observableInternal/index.js';
 import { observableValue } from '../vscode-observables/observables/dist/observableInternal/observables/observableValue.js';
 import '../vscode-observables/observables/dist/observableInternal/debugLocation.js';
@@ -7,8 +6,8 @@ import { derived } from '../vscode-observables/observables/dist/observableIntern
 import { waitForState } from '../vscode-observables/observables/dist/observableInternal/utils/utilsCancellation.js';
 import '../vscode-observables/observables/dist/observableInternal/utils/utils.js';
 import '../vscode-observables/observables/dist/observableInternal/observables/observableFromEvent.js';
-import { createApiFactory } from '../js-component-explorer/packages/simple-api/dist/chunk-FJ7AVNQE.js';
-import { AsyncStream } from '../js-component-explorer/packages/simple-api/dist/chunk-TTRCY65Z.js';
+import { nt as defaultInterfaceTarget } from '../external/linkrpc/typescript/packages/linkrpc/dist/chunks/src-DYVSK_tz.js';
+import { daemonRpcInterface } from '../js-component-explorer/packages/common/dist/daemonRpc.js';
 import { ExplorerSession } from '../explorerSession.js';
 import '../config.js';
 import { RelativePath } from '../path.js';
@@ -21,7 +20,6 @@ import { FileApprovalStore } from './approvalStore.js';
 import { VisualCache } from '../visualCache.js';
 import { contentHash } from '../screenshotCache.js';
 import { WorktreePool } from '../WorktreePool.js';
-import { pluginProtocolVersionText, daemonApiVersionText } from './version.js';
 export { isCompatibleVersion, parseVersion } from './version.js';
 import { ViteServerConfig } from '../server/serverConfig.js';
 
@@ -108,7 +106,6 @@ class DaemonService {
     _worktreePool;
     approvals;
     visualCache;
-    api;
     constructor(_config, _pipeName, _logger, _browserFactory, approvalStorePath, idleTimeoutMs) {
         this._config = _config;
         this._pipeName = _pipeName;
@@ -120,350 +117,265 @@ class DaemonService {
         if (_config.worktreePool) {
             this._worktreePool = new WorktreePool(_config.worktreePool.maxSlots, _config.repo.worktreeRootPath());
         }
-        this.api = this._buildApi();
     }
     static async create(config, logger, pipeName, options) {
         const browserFactory = new PlaywrightBrowserPageFactory(options?.headed ?? false, 30_000, logger);
         const approvalStorePath = config.screenshotDir.join(new RelativePath('approvals.json'));
         const idleTimeoutMs = options?.idleTimeoutMs ?? 5 * 60 * 1000; // 5 minutes default
         const svc = new DaemonService(config, pipeName, logger, browserFactory, approvalStorePath, idleTimeoutMs);
-        for (const sessionConfig of config.sessions) {
-            svc._sessionConfigs.set(sessionConfig.name, sessionConfig);
-            await svc._setupSession(sessionConfig);
+        try {
+            for (const sessionConfig of config.sessions) {
+                svc._sessionConfigs.set(sessionConfig.name, sessionConfig);
+                await svc._setupSession(sessionConfig);
+            }
+        }
+        catch (error) {
+            await svc.dispose();
+            throw error;
         }
         return svc;
     }
     // -- API definition ------------------------------------------------------
-    _buildApi() {
-        const { createApi, createMethod } = createApiFactory();
-        return createApi({
-            fixtures: createApi({
-                list: createMethod({
-                    args: {
-                        sessionName: z.string(),
-                        sourceTreeId: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                    const session = this.getSession(args.sessionName);
-                    const result = await session.explorer.listFixtures();
-                    this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                    return result;
-                }),
-            }),
-            screenshots: createApi({
-                take: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        sourceTreeId: z.string(),
-                        sessionName: z.string(),
-                        includeImage: z.boolean().optional(),
-                        stabilityCheck: z.boolean().optional(),
-                        reloadBeforeRender: z.boolean().optional(),
-                        input: z.unknown().optional(),
-                        disposeAfter: z.boolean().optional(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    const session = this.getSession(args.sessionName);
-                    this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                    if (args.stabilityCheck) {
-                        const result = await session.explorer.screenshotFixtureStabilityCheck(args.fixtureId, {
-                            reloadBeforeRender: args.reloadBeforeRender,
-                            input: args.input,
-                            disposeAfter: args.disposeAfter,
-                        });
-                        this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                        const hashes = result.screenshots.map(s => contentHash(s.image));
-                        const isStable = hashes[0] === hashes[1] && hashes[1] === hashes[2];
-                        const stabilityScreenshots = result.screenshots.map((s, i) => ({
-                            hash: hashes[i],
-                            delayMs: s.delayMs,
-                            image: (args.includeImage ?? true)
-                                ? Buffer.from(s.image).toString('base64')
-                                : undefined,
-                        }));
-                        return {
-                            hash: hashes[hashes.length - 1],
-                            sourceTreeId: args.sourceTreeId,
-                            image: (args.includeImage ?? true)
-                                ? Buffer.from(result.screenshots[result.screenshots.length - 1].image).toString('base64')
-                                : undefined,
-                            hasError: result.hasError,
-                            error: result.error,
-                            events: result.events.length > 0 ? result.events : undefined,
-                            output: result.output,
-                            isStable,
-                            stabilityScreenshots,
-                            previousDispose: result.previousDispose,
-                            currentDispose: result.currentDispose,
-                        };
-                    }
-                    const result = await session.explorer.screenshotFixture(args.fixtureId, {
+    registerRpc(connection, context) {
+        const registration = connection.register(defaultInterfaceTarget(daemonRpcInterface), {
+            fixturesList: async (args) => {
+                this._activityTracker.reportActivity();
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                const session = this.getSession(args.sessionName);
+                const result = await session.explorer.listFixtures();
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                return result;
+            },
+            screenshotsTake: async (args) => {
+                this._activityTracker.reportActivity();
+                const session = this.getSession(args.sessionName);
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                if (args.stabilityCheck) {
+                    const result = await session.explorer.screenshotFixtureStabilityCheck(args.fixtureId, {
                         reloadBeforeRender: args.reloadBeforeRender,
                         input: args.input,
                         disposeAfter: args.disposeAfter,
                     });
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                    const hashes = result.screenshots.map(s => contentHash(s.image));
+                    const isStable = hashes[0] === hashes[1] && hashes[1] === hashes[2];
+                    const stabilityScreenshots = result.screenshots.map((s, i) => ({
+                        hash: hashes[i],
+                        delayMs: s.delayMs,
+                        image: (args.includeImage ?? true)
+                            ? Buffer.from(s.image).toString('base64')
+                            : undefined,
+                    }));
                     return {
-                        hash: result.image ? contentHash(result.image) : undefined,
+                        hash: hashes[hashes.length - 1],
                         sourceTreeId: args.sourceTreeId,
-                        image: (args.includeImage ?? true) && result.image
-                            ? Buffer.from(result.image).toString('base64')
+                        image: (args.includeImage ?? true)
+                            ? Buffer.from(result.screenshots[result.screenshots.length - 1].image).toString('base64')
                             : undefined,
                         hasError: result.hasError,
                         error: result.error,
-                        events: result.events?.length > 0 ? result.events : undefined,
+                        events: result.events.length > 0 ? result.events : undefined,
                         output: result.output,
+                        isStable,
+                        stabilityScreenshots,
                         previousDispose: result.previousDispose,
                         currentDispose: result.currentDispose,
                     };
-                }),
-                takeBatch: createMethod({
-                    args: {
-                        fixtureIds: z.array(z.string()),
-                        sourceTreeId: z.string(),
-                        sessionName: z.string(),
-                        includeImages: z.boolean().optional(),
-                        reloadBetweenFixtures: z.boolean().optional(),
-                        input: z.unknown().optional(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    const session = this.getSession(args.sessionName);
+                }
+                const result = await session.explorer.screenshotFixture(args.fixtureId, {
+                    reloadBeforeRender: args.reloadBeforeRender,
+                    input: args.input,
+                    disposeAfter: args.disposeAfter,
+                });
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                return {
+                    hash: result.image ? contentHash(result.image) : undefined,
+                    sourceTreeId: args.sourceTreeId,
+                    image: (args.includeImage ?? true) && result.image
+                        ? Buffer.from(result.image).toString('base64')
+                        : undefined,
+                    hasError: result.hasError,
+                    error: result.error,
+                    events: result.events?.length > 0 ? result.events : undefined,
+                    output: result.output,
+                    previousDispose: result.previousDispose,
+                    currentDispose: result.currentDispose,
+                };
+            },
+            screenshotsTakeBatch: async (args) => {
+                this._activityTracker.reportActivity();
+                const session = this.getSession(args.sessionName);
+                this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
+                const includeImages = args.includeImages ?? false;
+                this._logger.trace(`takeBatch: ${args.fixtureIds.length} fixtures, session=${args.sessionName}`);
+                const startTime = Date.now();
+                const screenshots = [];
+                for (let i = 0; i < args.fixtureIds.length; i++) {
+                    const fixtureId = args.fixtureIds[i];
+                    const result = await session.explorer.screenshotFixture(fixtureId, {
+                        reloadOnError: true,
+                        // Reload between fixtures (skip before the first one — the page is already fresh)
+                        reloadBeforeRender: args.reloadBetweenFixtures && i > 0,
+                        input: args.input,
+                    });
                     this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                    const includeImages = args.includeImages ?? false;
-                    this._logger.trace(`takeBatch: ${args.fixtureIds.length} fixtures, session=${args.sessionName}`);
-                    const startTime = Date.now();
-                    const screenshots = [];
-                    for (let i = 0; i < args.fixtureIds.length; i++) {
-                        const fixtureId = args.fixtureIds[i];
-                        const result = await session.explorer.screenshotFixture(fixtureId, {
-                            reloadOnError: true,
-                            // Reload between fixtures (skip before the first one — the page is already fresh)
-                            reloadBeforeRender: args.reloadBetweenFixtures && i > 0,
-                            input: args.input,
-                        });
-                        this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
-                        screenshots.push({
-                            fixtureId,
-                            hash: result.image ? contentHash(result.image) : undefined,
-                            image: includeImages && result.image
-                                ? Buffer.from(result.image).toString('base64')
-                                : undefined,
-                            hasError: result.hasError,
-                            error: result.error,
-                            events: result.events.length > 0 ? result.events : undefined,
-                            output: result.output,
-                        });
-                    }
-                    this._logger.trace(`takeBatch: done in ${Date.now() - startTime}ms`);
-                    return { sourceTreeId: args.sourceTreeId, screenshots };
-                }),
-                compare: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        baselineSessionName: z.string(),
-                        baselineSourceTreeId: z.string(),
-                        currentSessionName: z.string(),
-                        currentSourceTreeId: z.string(),
-                        includeImages: z.boolean().optional(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    const baselineSession = this.getSession(args.baselineSessionName);
-                    const currentSession = this.getSession(args.currentSessionName);
-                    this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
-                    this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
-                    const [baselineResult, baselineListResult] = await Promise.all([
-                        baselineSession.explorer.screenshotFixture(args.fixtureId),
-                        baselineSession.explorer.listFixtures(),
-                    ]);
-                    this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
-                    const [currentResult, currentListResult] = await Promise.all([
-                        currentSession.explorer.screenshotFixture(args.fixtureId),
-                        currentSession.explorer.listFixtures(),
-                    ]);
-                    this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
-                    const baselineHash = baselineResult.image ? contentHash(baselineResult.image) : undefined;
-                    const currentHash = currentResult.image ? contentHash(currentResult.image) : undefined;
-                    const includeImages = args.includeImages ?? false;
-                    const currentFixture = currentListResult.fixtures.find(f => f.fixtureId === args.fixtureId);
-                    const baselineFixture = baselineListResult.fixtures.find(f => f.fixtureId === args.fixtureId);
-                    const labels = currentFixture?.labels;
-                    const labelsChanged = baselineFixture && !arraysEqual(baselineFixture.labels, currentFixture?.labels ?? []);
-                    return {
-                        match: baselineHash === currentHash,
-                        baselineHash,
-                        currentHash,
-                        baselineImage: includeImages && baselineResult.image
-                            ? Buffer.from(baselineResult.image).toString('base64') : undefined,
-                        currentImage: includeImages && currentResult.image
-                            ? Buffer.from(currentResult.image).toString('base64') : undefined,
-                        baselineHasError: baselineResult.hasError,
-                        baselineError: baselineResult.error,
-                        baselineEvents: baselineResult.events.length > 0 ? baselineResult.events : undefined,
-                        baselineOutput: baselineResult.output,
-                        currentHasError: currentResult.hasError,
-                        currentError: currentResult.error,
-                        currentEvents: currentResult.events.length > 0 ? currentResult.events : undefined,
-                        currentOutput: currentResult.output,
-                        labels,
-                        labelsBefore: labelsChanged ? baselineFixture.labels : undefined,
-                        approval: (baselineHash !== undefined && currentHash !== undefined && baselineHash !== currentHash)
-                            ? this.approvals.lookup({
-                                fixtureId: args.fixtureId,
-                                originalHash: baselineHash,
-                                modifiedHash: currentHash,
-                            }) ?? undefined
+                    screenshots.push({
+                        fixtureId,
+                        hash: result.image ? contentHash(result.image) : undefined,
+                        image: includeImages && result.image
+                            ? Buffer.from(result.image).toString('base64')
                             : undefined,
-                    };
-                }),
-            }),
-            approvals: createApi({
-                approve: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        originalHash: z.string(),
-                        modifiedHash: z.string(),
-                        comment: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    this.approvals.approve(args);
-                }),
-                revoke: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        originalHash: z.string(),
-                        modifiedHash: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    this.approvals.revoke(args);
-                }),
-                list: createMethod({
-                    args: { fixtureId: z.string().optional() },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    return this.approvals.list(args.fixtureId);
-                }),
-                lookup: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        originalHash: z.string(),
-                        modifiedHash: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    return this.approvals.lookup(args) ?? null;
-                }),
-            }),
-            visualReview: createApi({
-                getStatus: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        expectedVisualDescriptions: z.array(z.string()),
-                        screenshotHash: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    return this.visualCache.getReviewStatus(args.fixtureId, args.expectedVisualDescriptions, args.screenshotHash);
-                }),
-                approve: createMethod({
-                    args: {
-                        fixtureId: z.string(),
-                        expectedVisualDescriptions: z.array(z.string()),
-                        screenshotHash: z.string(),
-                        comment: z.string(),
-                    },
-                }, async (args) => {
-                    this._activityTracker.reportActivity();
-                    this.visualCache.approve(args.fixtureId, args.expectedVisualDescriptions, args.screenshotHash, args.comment);
-                }),
-            }),
-            evaluate: createMethod({
-                args: {
-                    sessionName: z.string(),
-                    sourceTreeId: z.string(),
-                    expression: z.string(),
-                    fixtureId: z.string().optional(),
-                },
-            }, async (args) => {
+                        hasError: result.hasError,
+                        error: result.error,
+                        events: result.events.length > 0 ? result.events : undefined,
+                        output: result.output,
+                    });
+                }
+                this._logger.trace(`takeBatch: done in ${Date.now() - startTime}ms`);
+                return { sourceTreeId: args.sourceTreeId, screenshots };
+            },
+            screenshotsCompare: async (args) => {
+                this._activityTracker.reportActivity();
+                const baselineSession = this.getSession(args.baselineSessionName);
+                const currentSession = this.getSession(args.currentSessionName);
+                this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
+                this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
+                const [baselineResult, baselineListResult] = await Promise.all([
+                    baselineSession.explorer.screenshotFixture(args.fixtureId),
+                    baselineSession.explorer.listFixtures(),
+                ]);
+                this.assertSourceTreeId(args.baselineSessionName, args.baselineSourceTreeId);
+                const [currentResult, currentListResult] = await Promise.all([
+                    currentSession.explorer.screenshotFixture(args.fixtureId),
+                    currentSession.explorer.listFixtures(),
+                ]);
+                this.assertSourceTreeId(args.currentSessionName, args.currentSourceTreeId);
+                const baselineHash = baselineResult.image ? contentHash(baselineResult.image) : undefined;
+                const currentHash = currentResult.image ? contentHash(currentResult.image) : undefined;
+                const includeImages = args.includeImages ?? false;
+                const currentFixture = currentListResult.fixtures.find(f => f.fixtureId === args.fixtureId);
+                const baselineFixture = baselineListResult.fixtures.find(f => f.fixtureId === args.fixtureId);
+                const labels = currentFixture?.labels;
+                const labelsChanged = baselineFixture && !arraysEqual(baselineFixture.labels, currentFixture?.labels ?? []);
+                return {
+                    match: baselineHash === currentHash,
+                    baselineHash,
+                    currentHash,
+                    baselineImage: includeImages && baselineResult.image
+                        ? Buffer.from(baselineResult.image).toString('base64') : undefined,
+                    currentImage: includeImages && currentResult.image
+                        ? Buffer.from(currentResult.image).toString('base64') : undefined,
+                    baselineHasError: baselineResult.hasError,
+                    baselineError: baselineResult.error,
+                    baselineEvents: baselineResult.events.length > 0 ? baselineResult.events : undefined,
+                    baselineOutput: baselineResult.output,
+                    currentHasError: currentResult.hasError,
+                    currentError: currentResult.error,
+                    currentEvents: currentResult.events.length > 0 ? currentResult.events : undefined,
+                    currentOutput: currentResult.output,
+                    labels,
+                    labelsBefore: labelsChanged ? baselineFixture.labels : undefined,
+                    approval: (baselineHash !== undefined && currentHash !== undefined && baselineHash !== currentHash)
+                        ? this.approvals.lookup({
+                            fixtureId: args.fixtureId,
+                            originalHash: baselineHash,
+                            modifiedHash: currentHash,
+                        }) ?? undefined
+                        : undefined,
+                };
+            },
+            approvalsApprove: async (args) => {
+                this._activityTracker.reportActivity();
+                this.approvals.approve(args);
+            },
+            approvalsRevoke: async (args) => {
+                this._activityTracker.reportActivity();
+                this.approvals.revoke(args);
+            },
+            approvalsList: async (args) => {
+                this._activityTracker.reportActivity();
+                return this.approvals.list(args.fixtureId);
+            },
+            approvalsLookup: async (args) => {
+                this._activityTracker.reportActivity();
+                return this.approvals.lookup(args) ?? null;
+            },
+            visualReviewGetStatus: async (args) => {
+                this._activityTracker.reportActivity();
+                return this.visualCache.getReviewStatus(args.fixtureId, args.expectedVisualDescriptions, args.screenshotHash);
+            },
+            visualReviewApprove: async (args) => {
+                this._activityTracker.reportActivity();
+                this.visualCache.approve(args.fixtureId, args.expectedVisualDescriptions, args.screenshotHash, args.comment);
+            },
+            evaluate: async (args) => {
                 this._activityTracker.reportActivity();
                 const session = this.getSession(args.sessionName);
                 this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                 const result = await session.explorer.evaluateJs(args.expression, args.fixtureId);
                 this.assertSourceTreeId(args.sessionName, args.sourceTreeId);
                 return { result };
-            }),
-            setBrowserVisibility: createMethod({
-                args: { visible: z.boolean() },
-            }, async (args, ctx) => {
+            },
+            setBrowserVisibility: async (args) => {
                 this._activityTracker.reportActivity();
-                this._logger.debug(`Set browser visibility: ${args.visible} (client=${ctx.clientName})`);
+                this._logger.debug(`Set browser visibility: ${args.visible} (client=${context.clientName})`);
                 await this._browserFactory.setHeaded(args.visible);
                 for (const session of this._sessions.values()) {
                     session.explorer.closePage();
                 }
                 return { visible: args.visible };
-            }),
-            events: createMethod({ args: {} }, async () => {
-                return AsyncStream.fromIterable(this.eventStream());
-            }),
-            sessions: createMethod({ args: {} }, async (_args, ctx) => {
+            },
+            events: async (_args, _ctx, stream) => {
+                const iterator = this.eventStream()[Symbol.asyncIterator]();
+                const onAbort = () => { void iterator.return?.(); };
+                stream.signal.addEventListener('abort', onAbort, { once: true });
+                try {
+                    while (!stream.signal.aborted) {
+                        const next = await iterator.next();
+                        if (next.done) {
+                            break;
+                        }
+                        await stream.send(next.value);
+                    }
+                }
+                finally {
+                    stream.signal.removeEventListener('abort', onAbort);
+                    await iterator.return?.();
+                }
+            },
+            sessions: async () => {
                 this._activityTracker.reportActivity();
-                this._logger.trace(`API: sessions (client=${ctx.clientName}, eventListeners=${this._eventListeners.size})`);
+                this._logger.trace(`API: sessions (client=${context.clientName}, eventListeners=${this._eventListeners.size})`);
                 return this.getSessionInfos();
-            }),
-            version: createMethod({ args: {} }, async () => {
-                this._activityTracker.reportActivity();
-                return {
-                    daemonApiVersion: daemonApiVersionText,
-                    pluginProtocolVersion: pluginProtocolVersionText,
-                };
-            }),
-            restartSession: createMethod({
-                args: { sessionName: z.string() },
-            }, async (args, ctx) => {
+            },
+            restartSession: async (args) => {
                 this._activityTracker.reportActivity();
-                this._logger.debug(`Restart session "${args.sessionName}" requested (client=${ctx.clientName})`);
+                this._logger.debug(`Restart session "${args.sessionName}" requested (client=${context.clientName})`);
                 await this._restartSession(args.sessionName);
                 return this.getSessionInfos();
-            }),
-            openSession: createMethod({
-                args: {
-                    name: z.string(),
-                    ref: z.string(),
-                },
-            }, async (args, ctx) => {
+            },
+            openSession: async (args) => {
                 this._activityTracker.reportActivity();
-                this._logger.log(`Open session "${args.name}" @ ${args.ref} requested (client=${ctx.clientName})`);
+                this._logger.log(`Open session "${args.name}" @ ${args.ref} requested (client=${context.clientName})`);
                 return this._openDynamicSession(args.name, args.ref);
-            }),
-            closeSession: createMethod({
-                args: { name: z.string() },
-            }, async (args, ctx) => {
+            },
+            closeSession: async (args) => {
                 this._activityTracker.reportActivity();
-                this._logger.log(`Close session "${args.name}" requested (client=${ctx.clientName})`);
+                this._logger.log(`Close session "${args.name}" requested (client=${context.clientName})`);
                 return this._closeDynamicSession(args.name);
-            }),
-            updateSessionRef: createMethod({
-                args: {
-                    name: z.string(),
-                    ref: z.string(),
-                },
-            }, async (args, ctx) => {
+            },
+            updateSessionRef: async (args) => {
                 this._activityTracker.reportActivity();
-                this._logger.log(`Update session ref "${args.name}" → ${args.ref} requested (client=${ctx.clientName})`);
+                this._logger.log(`Update session ref "${args.name}" → ${args.ref} requested (client=${context.clientName})`);
                 return this._updateDynamicSessionRef(args.name, args.ref);
-            }),
-            shutdown: createMethod({ args: {} }, async (_args, ctx) => {
-                this._logger.debug(`Shutdown requested via API (client=${ctx.clientName})`);
-                this.requestShutdown();
-            }),
+            },
+            shutdown: async () => {
+                this._logger.debug(`Shutdown requested via API (client=${context.clientName})`);
+                // Let LinkRPC serialize the reply before shutting down its transport.
+                setImmediate(() => this.requestShutdown());
+            },
         });
+        return registration;
     }
     // -- Session access ------------------------------------------------------
     getSession(name) {
@@ -551,6 +463,9 @@ class DaemonService {
                 let resolve;
                 let done = false;
                 const listener = (event) => {
+                    if (done) {
+                        return;
+                    }
                     if (event.type !== 'log') {
                         self._logger.trace(`Event stream: ${event.type}`);
                     }
@@ -568,6 +483,9 @@ class DaemonService {
                 self._activityTracker.setActive(true);
                 self._logger.debug(`Event stream opened (listeners: ${self._eventListeners.size})`);
                 const onShutdown = () => {
+                    if (done) {
+                        return;
+                    }
                     done = true;
                     cleanup();
                     if (resolve) {
@@ -578,9 +496,16 @@ class DaemonService {
                 };
                 self._shutdownResolvers.push(onShutdown);
                 const cleanup = () => {
+                    if (!self._eventListeners.has(listener)) {
+                        return;
+                    }
                     self._eventListeners.delete(listener);
                     self._eventListenerCount.set(self._eventListeners.size, undefined);
                     self._activityTracker.setActive(false);
+                    const shutdownIndex = self._shutdownResolvers.indexOf(onShutdown);
+                    if (shutdownIndex >= 0) {
+                        self._shutdownResolvers.splice(shutdownIndex, 1);
+                    }
                     self._logger.debug(`Event stream closed (listeners: ${self._eventListeners.size})`);
                 };
                 return {
@@ -676,10 +601,11 @@ class DaemonService {
     // -- Shutdown ------------------------------------------------------------
     requestShutdown() {
         this._shutdownRequested = true;
-        for (const resolve of this._shutdownResolvers) {
+        const resolvers = this._shutdownResolvers;
+        this._shutdownResolvers = [];
+        for (const resolve of resolvers) {
             resolve();
         }
-        this._shutdownResolvers = [];
     }
     async dispose() {
         this.requestShutdown();
@@ -733,8 +659,6 @@ class DaemonService {
             daemonConfig: this._pipeName ? {
                 pipeName: this._pipeName,
                 sessionName,
-                daemonApiVersion: daemonApiVersionText,
-                pluginProtocolVersion: pluginProtocolVersionText,
             } : undefined,
         };
     }
@@ -991,5 +915,5 @@ function arraysEqual(a, b) {
     return true;
 }
 
-export { ActivityTracker, DaemonService, SourceTreeChangedError, daemonApiVersionText, pluginProtocolVersionText };
+export { ActivityTracker, DaemonService, SourceTreeChangedError };
 //# sourceMappingURL=DaemonService.js.map