@actiondock/core 2.7.0 → 2.9.0

package/dist/execution/service.js

@@ -1,17 +1,21 @@
-import { randomUUID } from "node:crypto";
-import { ActionResolver } from "../catalog/action-resolver.js";
+import { existsSync } from "node:fs";
+import { parseActionRef } from "../catalog/resolve-action.js";
 import { computeDigest } from "../project/digest.js";
+import { loadActions, loadProjectConfig } from "../project/loader.js";
 import { InMemoryEventSink } from "../runtime/events.js";
 import { ActionRunner } from "../runtime/runner.js";
-import { ACTION_NOT_FOUND, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, RUN_REPOSITORY_UNAVAILABLE, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
+import { ActionDockError, ACTION_NOT_FOUND, EXECUTION_FAILED, IDEMPOTENCY_CONFLICT, RUN_REPOSITORY_UNAVAILABLE, UNHANDLED_EXECUTION_ERROR, describeActionLoadFailure, } from "../errors.js";
 import { resultStatusToRunStatus } from "../storage/types.js";
 /**
  * 统一执行协调服务实现。
  */
 export class DefaultExecutionService {
+    identity;
     packageId;
     storage;
     projectConfig;
+    projectRoot;
+    moduleLoader;
     eventSink;
     packageInstanceId;
     generationId;
@@ -22,86 +26,56 @@ export class DefaultExecutionService {
     logger;
     clock;
     process;
-    platform;
     actionResolver;
     activeRuns = new Map();
-    reservedSlots = 0;
-    isClosing = false;
-    ownsStorage;
-    ownsGlobalStorage;
     globalStorage;
+    actionInvoker;
+    isClosing = false;
+    reservedSlots = 0;
     constructor(options) {
-        this.platform = options.platform;
-        this.packageId = options.packageId;
-        this.packageInstanceId = options.packageInstanceId || this.packageId;
-        this.generationId = options.generationId || "1";
+        if (!options.identity) {
+            throw new Error("DefaultExecutionService requires 'identity' PackageIdentity option");
+        }
+        if (!options.storage) {
+            throw new Error("DefaultExecutionService requires 'storage' option");
+        }
+        this.identity = options.identity;
+        this.packageId = this.identity.id;
+        this.packageInstanceId = this.identity.instanceId;
+        this.generationId = this.identity.generation;
         this.hostSessionId = options.hostSessionId;
         this.projectConfig = options.projectConfig;
-        this.eventSink = options.eventSink || options.platform?.eventSink || new InMemoryEventSink();
+        this.projectRoot = options.projectRoot;
+        this.moduleLoader = options.moduleLoader;
+        this.eventSink = options.eventSink || new InMemoryEventSink();
         this.maxActiveRuns = options.maxActiveRuns || 32;
-        this.ownerId = options.ownerId || `host-${randomUUID().slice(0, 8)}`;
+        this.ownerId = options.ownerId || `host-${crypto.randomUUID().slice(0, 8)}`;
         this.actionResolver = options.actionResolver;
         this.logger = options.logger;
-        if (options.platform) {
-            this.clock = options.platform.clock;
-            this.process = options.platform.process;
-            this.storage =
-                options.storage ??
-                    options.platform.storage.createStorage(this.packageId, {
-                        projectRoot: options.projectRoot,
-                        customHome: options.customHome,
-                        // 执行服务属于数据目录持有者主路径，打开时收割遗留孤儿运行
-                        recoverOrphans: true,
-                    });
-        }
-        else {
-            this.clock = options.clock;
-            this.process = options.process;
-            if (!options.storage) {
-                throw new Error("ExecutionService requires either 'storage' or 'platform' option");
-            }
-            this.storage = options.storage;
-        }
-        const globalStorage = options.platform
-            ? (options.globalStorage ??
-                options.platform.storage.createGlobalStorage({ customHome: options.customHome, recoverOrphans: true }))
-            : options.globalStorage;
-        this.ownsStorage = !options.storage;
-        this.ownsGlobalStorage = !options.globalStorage && !!options.platform;
-        this.globalStorage = globalStorage;
+        this.actionInvoker = options.actionInvoker;
+        this.storage = options.storage;
+        this.globalStorage = options.globalStorage;
+        this.clock = options.clock;
+        this.process = options.process;
         this._runner = new ActionRunner({
-            packageId: this.packageId,
-            packageInstanceId: this.packageInstanceId,
-            generationId: this.generationId,
+            identity: this.identity,
             hostSessionId: this.hostSessionId,
             storage: this.storage,
-            globalStorage,
+            globalStorage: this.globalStorage,
             projectRoot: options.projectRoot,
             projectConfig: this.projectConfig,
             configOverrides: options.configOverrides,
             actions: options.actions,
             process: this.process,
             clock: this.clock,
-            platform: options.platform,
-            maxCallDepth: options.maxCallDepth,
-            maxSubRuns: options.maxSubRuns,
-            actionResolver: (ref, currentPkgId) => {
-                const parsed = typeof ref === "string" ? ActionResolver.parseRef(ref) : ref;
-                if (parsed.packageId && parsed.packageId !== this.packageId) {
-                    return undefined;
-                }
-                if (currentPkgId && currentPkgId !== this.packageId) {
-                    return undefined;
-                }
-                return this.actionResolver ? this.actionResolver(parsed) : undefined;
-            },
-            getStorageForPackage: options.getStorageForPackage,
-            packageContextResolver: options.packageContextResolver,
+            actionResolver: this.actionResolver,
             customHome: options.customHome,
+            actionInvoker: this.actionInvoker,
         });
     }
-    get runner() {
-        return this._runner;
+    setActionInvoker(invoker) {
+        this.actionInvoker = invoker;
+        this._runner.setActionInvoker(invoker);
     }
     registerAction(idOrAction, actionDef) {
         if (typeof idOrAction === "string") {
@@ -120,39 +94,20 @@ export class DefaultExecutionService {
     getActiveHandle(runId) {
         return this.activeRuns.get(runId)?.handle;
     }
-    setPackageContextResolver(resolver) {
-        this._runner.setPackageContextResolver(resolver);
-    }
-    async resolveTargetAction(ref) {
-        const parsed = typeof ref === "string" ? ActionResolver.parseRef(ref) : ref;
-        const actionId = parsed.actionId;
-        const targetPackageId = parsed.packageId || this.packageId;
-        let runner = this._runner;
-        if (targetPackageId !== this.packageId) {
-            const targetRunner = await this._runner.resolveTargetPackageRunner(targetPackageId);
-            if (!targetRunner)
-                return undefined;
-            runner = targetRunner;
-        }
-        const fromRunner = runner.getAction(actionId);
-        if (fromRunner)
-            return fromRunner;
-        if (this.actionResolver && targetPackageId === this.packageId) {
-            return this.actionResolver(parsed);
-        }
-        return undefined;
-    }
-    async execute(ref, input, options = {}) {
-        const ticket = await this.start(ref, input, options);
+    async execute(ref, input, context) {
+        const ticket = await this.start(ref, input, context);
         if (!ticket.result) {
             throw new Error(`Execution ticket for run '${ticket.runId}' has no result Promise`);
         }
         return ticket.result;
     }
+    async run(ref, input, context) {
+        return this.execute(ref, input, context);
+    }
     get activeRunsCount() {
         return this.activeRuns.size + this.reservedSlots;
     }
-    async start(ref, input, options = {}) {
+    async start(ref, input, context) {
         if (this.isClosing) {
             throw new Error("ExecutionService is closing: new tasks rejected");
         }
@@ -171,7 +126,7 @@ export class DefaultExecutionService {
         try {
             let parsedRef;
             try {
-                parsedRef = ActionResolver.parseRef(ref);
+                parsedRef = parseActionRef(ref);
             }
             catch {
                 parsedRef = typeof ref === "object" ? ref : { actionId: ref };
@@ -179,9 +134,9 @@ export class DefaultExecutionService {
             const targetActionId = parsedRef.actionId;
             const targetPackageId = parsedRef.packageId || this.packageId;
             const actionRef = `${targetPackageId}/${targetActionId}`;
-            const effectiveClock = options.platform?.clock ?? this.clock;
+            const effectiveClock = this.clock;
             // requestId 幂等检查与去重处理
-            const gateResult = await this.checkIdempotencyGate(input, options, actionRef, effectiveClock);
+            const gateResult = await this.checkIdempotencyGate(input, context, actionRef, effectiveClock);
             if (gateResult.ticket) {
                 releaseSlot();
                 return gateResult.ticket;
@@ -193,7 +148,7 @@ export class DefaultExecutionService {
                 return this.failTicketForMissingAction({
                     target,
                     input,
-                    options,
+                    context,
                     targetPackageId,
                     targetActionId,
                     designatedRunId,
@@ -205,36 +160,44 @@ export class DefaultExecutionService {
             }
             const controller = new AbortController();
             let onAbort;
-            if (options.signal && typeof options.signal.addEventListener === "function") {
-                if (options.signal.aborted) {
-                    controller.abort(options.signal.reason);
+            if (context.signal && typeof context.signal.addEventListener === "function") {
+                if (context.signal.aborted) {
+                    controller.abort(context.signal.reason);
                 }
                 else {
-                    onAbort = () => controller.abort(options.signal?.reason);
-                    options.signal.addEventListener("abort", onAbort, { once: true });
+                    onAbort = () => controller.abort(context.signal?.reason);
+                    context.signal.addEventListener("abort", onAbort, { once: true });
                 }
             }
-            const runId = designatedRunId || randomUUID();
-            const bridge = this.createEventBridge({ runId, options, effectiveClock });
-            this.registerResolvedAction(target.runner, targetPackageId, targetActionId, target.action);
+            const runId = designatedRunId || context.runId || crypto.randomUUID();
+            const bridge = this.createEventBridge({ runId, context, effectiveClock });
+            target.runner.registerAction(targetActionId, target.action);
             const handle = target.runner.start(targetActionId, input, {
                 runId,
-                rootRunId: options.rootRunId,
-                parentRunId: options.parentRunId,
-                hostSessionId: options.hostSessionId || this.hostSessionId,
-                maxCallDepth: options.maxCallDepth,
-                configOverrides: options.config,
+                rootRunId: context.rootRunId,
+                parentRunId: context.parentRunId,
+                callStack: context.callStack ? [...context.callStack] : undefined,
+                hostSessionId: context.hostSessionId || this.hostSessionId,
+                maxCallDepth: context.maxCallDepth,
+                configOverrides: context.config,
                 signal: controller.signal,
-                timeoutMs: options.timeoutMs,
+                timeoutMs: context.timeoutMs,
                 progress: bridge.progressReporter,
                 logger: bridge.executionLogger,
-                process: options.process || options.platform?.process || this.process,
-                platform: options.platform || this.platform,
-                packageInstanceId: options.packageInstanceId,
-                generationId: options.generationId,
-                tenantId: options.tenantId,
-                principalId: options.principalId,
-                owner: options.owner,
+                process: context.process || this.process,
+                packageInstanceId: context.package.instanceId,
+                generationId: context.package.generation,
+                tenantId: context.owner?.tenantId || context.tenantId,
+                principalId: context.owner?.principalId || context.principalId,
+                owner: context.owner
+                    ? {
+                        tenantId: context.owner.tenantId,
+                        principalId: context.owner.principalId,
+                        packageInstanceId: context.owner.packageInstanceId || context.package.instanceId,
+                        generationId: context.owner.generationId || context.package.generation,
+                    }
+                    : undefined,
+                actionInvoker: this.actionInvoker,
             });
             const activeItem = {
                 runId: handle.runId,
@@ -242,7 +205,7 @@ export class DefaultExecutionService {
                 controller,
                 status: "running",
                 startedAt: (effectiveClock?.now() ?? new Date()).toISOString(),
-                signal: options.signal,
+                signal: context.signal,
                 onAbort,
             };
             this.activeRuns.set(handle.runId, activeItem);
@@ -263,43 +226,35 @@ export class DefaultExecutionService {
     /**
      * 幂等门检查：digest 计算与冲突/重复分流（重复命中时直接返回已有票据）。
      */
-    async checkIdempotencyGate(input, options, actionRef, effectiveClock) {
-        if (!options.requestId) {
+    async checkIdempotencyGate(input, context, actionRef, effectiveClock) {
+        if (!context.requestId) {
             return {};
         }
         const digestPayload = {
             input,
-            config: options.config,
-            timeoutMs: options.timeoutMs,
+            config: context.config,
+            timeoutMs: context.timeoutMs,
         };
         const inputDigest = computeDigest(digestPayload);
-        const provisionalRunId = randomUUID();
+        const provisionalRunId = crypto.randomUUID();
         if (!this.storage.checkAndRecordIdempotency) {
             return {};
         }
         const idemp = this.storage.checkAndRecordIdempotency({
             ownerId: this.ownerId,
             actionRef,
-            requestId: options.requestId,
+            requestId: context.requestId,
             inputDigest,
             runId: provisionalRunId,
             createdAt: (effectiveClock?.now() ?? new Date()).toISOString(),
         });
         if (idemp.outcome === "conflict") {
-            const conflictError = {
-                code: IDEMPOTENCY_CONFLICT,
-                message: `Idempotency conflict for requestId '${options.requestId}': input parameters digest mismatch`,
-                details: {
-                    requestId: options.requestId,
-                    actionRef,
-                    expectedDigest: idemp.existingDigest,
-                    actualDigest: inputDigest,
-                },
-            };
-            const err = new Error(conflictError.message);
-            err.code = conflictError.code;
-            err.details = conflictError.details;
-            throw err;
+            throw new ActionDockError(IDEMPOTENCY_CONFLICT, `Idempotency conflict for requestId '${context.requestId}': input parameters digest mismatch`, {
+                requestId: context.requestId,
+                actionRef,
+                expectedDigest: idemp.existingDigest,
+                actualDigest: inputDigest,
+            });
         }
         if (idemp.outcome === "duplicate") {
             const existingRunId = idemp.runId;
@@ -337,42 +292,61 @@ export class DefaultExecutionService {
         return { designatedRunId: provisionalRunId };
     }
     /**
-     * 解析执行目标：确定目标 Runner 并解析目标 Action 定义。
+     * 解析执行目标：确定目标 Action 定义。
+     * 铁律 4：Runner 不找 Package，ExecutionService 仅执行本 Package 的 Action。
      */
     async resolveExecutionTarget(parsedRef, targetPackageId, targetActionId) {
-        let runnerToUse = this._runner;
+        const runnerToUse = this._runner;
         let resolveError;
         if (targetPackageId && targetPackageId !== this.packageId) {
-            const targetRunner = await this._runner.resolveTargetPackageRunner(targetPackageId);
-            if (targetRunner) {
-                runnerToUse = targetRunner;
+            resolveError = {
+                code: ACTION_NOT_FOUND,
+                message: `Package '${this.packageId}' cannot execute action for external package '${targetPackageId}'`,
+            };
+            return { runner: runnerToUse, action: undefined, resolveError };
+        }
+        let action = runnerToUse.getAction(targetActionId) || runnerToUse.getAction(`${targetPackageId}/${targetActionId}`);
+        if (!action) {
+            const resolution = await runnerToUse.resolveAction(parsedRef);
+            if (resolution.status === "found") {
+                action = resolution.action;
             }
             else {
-                resolveError = {
-                    code: ACTION_NOT_FOUND,
-                    message: `Target package '${targetPackageId}' not found or unresolvable`,
-                };
-            }
-        }
-        let action;
-        if (!resolveError) {
-            action = runnerToUse.getAction(targetActionId) || runnerToUse.getAction(`${targetPackageId}/${targetActionId}`);
-            if (!action) {
-                const resolution = await runnerToUse.resolveAction(parsedRef);
-                if (resolution.status === "found") {
-                    action = resolution.action;
-                }
-                else if (resolution.status === "load_failed") {
-                    resolveError = describeActionLoadFailure(resolution.error, {
-                        actionId: targetActionId,
-                        packageId: resolution.packageId,
-                        projectRoot: resolution.projectRoot,
-                    });
+                const targetAction = await this.actionResolver?.(targetActionId);
+                if (targetAction) {
+                    action = targetAction;
                 }
-                else {
-                    const targetAction = await this.resolveTargetAction(parsedRef);
-                    if (targetAction) {
-                        action = targetAction;
+                else if (this.projectRoot && existsSync(this.projectRoot)) {
+                    let config;
+                    try {
+                        config = this.projectConfig || loadProjectConfig(this.projectRoot);
+                    }
+                    catch (err) {
+                        resolveError = describeActionLoadFailure(err, {
+                            actionId: targetActionId,
+                            packageId: this.packageId,
+                            projectRoot: this.projectRoot,
+                        });
+                        return { runner: runnerToUse, action: undefined, resolveError };
+                    }
+                    let actionsMap;
+                    try {
+                        actionsMap = await loadActions(this.projectRoot, config.actionsDir, {
+                            loader: this.moduleLoader,
+                        });
+                    }
+                    catch (err) {
+                        resolveError = describeActionLoadFailure(err, {
+                            actionId: targetActionId,
+                            packageId: this.packageId,
+                            projectRoot: this.projectRoot,
+                        });
+                        return { runner: runnerToUse, action: undefined, resolveError };
+                    }
+                    const matched = actionsMap.get(targetActionId);
+                    if (matched) {
+                        action = matched;
+                        runnerToUse.registerAction(targetActionId, matched);
                     }
                     else {
                         resolveError = {
@@ -382,38 +356,55 @@ export class DefaultExecutionService {
                         };
                     }
                 }
+                else {
+                    resolveError = {
+                        code: ACTION_NOT_FOUND,
+                        message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
+                        details: resolution.reason ? { reason: resolution.reason } : undefined,
+                    };
+                }
             }
         }
         return { runner: runnerToUse, action, resolveError };
     }
     /**
-     * 注册解析成功的目标 Action 至目标 Runner（收敛为单一注册入口）。
+     * 解析指定 Action 定义（供 PackageRuntime 或内部使用）。
      */
-    registerResolvedAction(runner, targetPackageId, targetActionId, action) {
-        runner.registerAction(targetActionId, action);
+    async resolveAction(ref) {
+        let parsedRef;
+        try {
+            parsedRef = parseActionRef(ref);
+        }
+        catch {
+            parsedRef = typeof ref === "object" ? ref : { actionId: ref };
+        }
+        const targetActionId = parsedRef.actionId;
+        const targetPackageId = parsedRef.packageId || this.packageId;
+        const target = await this.resolveExecutionTarget(parsedRef, targetPackageId, targetActionId);
+        return target.action;
     }
     /**
      * 目标 Action 缺失时的失败票据：落库 failed 记录并补发 status 与 finish 事件。
      */
     failTicketForMissingAction(args) {
-        const { target, input, options, targetPackageId, targetActionId, designatedRunId, effectiveClock } = args;
-        const runId = designatedRunId || randomUUID();
+        const { target, input, context, targetPackageId, targetActionId, designatedRunId, effectiveClock } = args;
+        const runId = designatedRunId || context.runId || crypto.randomUUID();
         const now = (effectiveClock?.now() ?? new Date()).toISOString();
         const error = target.resolveError || {
             code: ACTION_NOT_FOUND,
             message: `Action '${targetActionId}' not found in package '${targetPackageId}'`,
         };
-        const rootRunId = options.rootRunId || options.parentRunId || runId;
+        const rootRunId = context.rootRunId || context.parentRunId || runId;
         const initialRun = {
             id: runId,
             rootRunId,
-            parentRunId: options.parentRunId,
+            parentRunId: context.parentRunId,
             packageId: targetPackageId,
-            packageInstanceId: options.packageInstanceId || target.runner.packageInstanceId || targetPackageId,
+            packageInstanceId: context.package.instanceId || target.runner.packageInstanceId,
             actionId: targetActionId,
-            generationId: options.generationId || target.runner.generationId || "1",
+            generationId: context.package.generation || target.runner.generationId,
             ownerId: this.ownerId,
-            hostSessionId: options.hostSessionId || this.hostSessionId,
+            hostSessionId: context.hostSessionId || this.hostSessionId,
             status: "failed",
             input,
             error,
@@ -424,10 +415,7 @@ export class DefaultExecutionService {
             target.runner.getStorage().createRun(initialRun);
         }
         catch (err) {
-            const repErr = new Error(`RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`);
-            repErr.code = RUN_REPOSITORY_UNAVAILABLE;
-            repErr.details = { originalError: err?.message };
-            throw repErr;
+            throw new ActionDockError(RUN_REPOSITORY_UNAVAILABLE, `RUN_REPOSITORY_UNAVAILABLE: Failed to initialize run record in repository: ${err?.message || String(err)}`, { originalError: err?.message });
         }
         this.eventSink.emit({
             runId,
@@ -464,13 +452,13 @@ export class DefaultExecutionService {
      * 创建执行事件桥：事件序列号分配、进度报告器与双写日志适配器。
      */
     createEventBridge(args) {
-        const { runId, options, effectiveClock } = args;
+        const { runId, context, effectiveClock } = args;
         let sequence = 0;
         const emitEvent = (payload) => {
             const evt = {
                 ...payload,
                 runId,
-                rootRunId: options.rootRunId || options.parentRunId || runId,
+                rootRunId: context.rootRunId || context.parentRunId || runId,
                 sequence: sequence++,
                 timestamp: (effectiveClock?.now() ?? new Date()).toISOString(),
             };
@@ -478,7 +466,7 @@ export class DefaultExecutionService {
         };
         const progressReporter = {
             report(current, total, message) {
-                options.progress?.report(current, total, message);
+                context.progress?.report(current, total, message);
                 emitEvent({
                     type: "progress",
                     current,
@@ -487,47 +475,21 @@ export class DefaultExecutionService {
                 });
             },
         };
+        const mkLevelLogger = (level) => (message, data) => {
+            this.logger?.[level](message, data);
+            context.logger?.[level](message, data);
+            emitEvent({
+                type: "log",
+                level,
+                message,
+                data: data,
+            });
+        };
         const executionLogger = {
-            debug: (message, data) => {
-                this.logger?.debug(message, data);
-                options.logger?.debug(message, data);
-                emitEvent({
-                    type: "log",
-                    level: "debug",
-                    message,
-                    data: data,
-                });
-            },
-            info: (message, data) => {
-                this.logger?.info(message, data);
-                options.logger?.info(message, data);
-                emitEvent({
-                    type: "log",
-                    level: "info",
-                    message,
-                    data: data,
-                });
-            },
-            warn: (message, data) => {
-                this.logger?.warn(message, data);
-                options.logger?.warn(message, data);
-                emitEvent({
-                    type: "log",
-                    level: "warn",
-                    message,
-                    data: data,
-                });
-            },
-            error: (message, data) => {
-                this.logger?.error(message, data);
-                options.logger?.error(message, data);
-                emitEvent({
-                    type: "log",
-                    level: "error",
-                    message,
-                    data: data,
-                });
-            },
+            debug: mkLevelLogger("debug"),
+            info: mkLevelLogger("info"),
+            warn: mkLevelLogger("warn"),
+            error: mkLevelLogger("error"),
         };
         return { emitEvent, progressReporter, executionLogger };
     }
@@ -566,26 +528,7 @@ export class DefaultExecutionService {
         });
     }
     async get(runId) {
-        const record = this.storage.getRun(runId);
-        if (record)
-            return record;
-        // 检查所有已解析的目标包 Runner 存储
-        const visited = new Set([this._runner]);
-        const queue = [this._runner];
-        while (queue.length > 0) {
-            const runner = queue.shift();
-            for (const [_, childRunner] of runner.getPackageRunners()) {
-                if (!visited.has(childRunner)) {
-                    visited.add(childRunner);
-                    queue.push(childRunner);
-                    const childRecord = childRunner.getStorage().getRun(runId);
-                    if (childRecord) {
-                        return childRecord;
-                    }
-                }
-            }
-        }
-        return undefined;
+        return this.storage.getRun(runId) ?? undefined;
     }
     async cancel(runId, reason) {
         const active = this.activeRuns.get(runId);
@@ -631,19 +574,7 @@ export class DefaultExecutionService {
             }
         }
         this.activeRuns.clear();
-        // 级联释放跨包子包 Runner 及其独立创建的存储连接（幂等，异常不阻断后续释放）
-        try {
-            await this._runner.dispose();
-        }
-        catch {
-            // 子包释放异常已在 dispose 内部隔离，此处仅需保障主流程继续
-        }
-        if (this.ownsStorage && this.storage && typeof this.storage.close === "function") {
-            await this.storage.close();
-        }
-        if (this.ownsGlobalStorage && this.globalStorage && typeof this.globalStorage.close === "function") {
-            await this.globalStorage.close();
-        }
+        await this._runner.dispose();
     }
 }
 export { DefaultExecutionService as ExecutionService };