@feng0531/dsh-execution-bus 0.2.12 → 0.4.0

package/README.md

@@ -4,9 +4,9 @@
 
 “萧何”是产品与模式显示名，执行总线是其技术功能；不新增人物 Agent，不进行角色扮演。仓库 dsh-execution-bus、npm 包名、execution_bus 工具名及 execution-bus-test 预设 ID 保持不变。历史版本发布说明保留当时名称。
 
-DSH 独立插件：`@feng0531/dsh-execution-bus` · 当前版本 **0.2.12**
+DSH 独立插件：`@feng0531/dsh-execution-bus` · 当前版本 **0.4.0**
 
-> 当前是早期可运行版本，不是完整生产验收版。已验证真实 DSH 组件和脚本模型驱动的内存会话；真实模型、桌面界面和 PTC 完整链路尚未验收。**不支持重启后恢复任务。**
+> 萧何模式从宿主已声明的 PTC 组合派生，保留日常工具，再叠加可选执行总线。已验证隔离的真实 Node PTC → 原 read + 总线调用，以及脚本模型内存会话；真实模型、桌面界面与实际沙箱仍未验收。**不支持重启后恢复任务。**
 
 ## 它解决什么问题？
 
@@ -92,7 +92,13 @@ flowchart TD
 
 包内提供标准 DSH bundle patch（预设组合补丁）。宿主正常加载后会收到“萧何 / Xiao He”预设定义，由既有设置 → Agent 预设 → **自定义**列表展示。建议选择它新建专门会话，不改默认选择或正在使用的普通会话。已有会话的切换受宿主空白会话检查约束。**实际桌面卡片展示尚未验收**，不能把注册表测试当作界面已通过。
 
-该预设只在自己的作用域注册 execution_bus，使用原生工具调用，不改其他会话的 PTC 模式。它没有 shell 行；宿主文件工具套件会声明 read/write/edit 等工具，但该模式的执行门禁（guard）只允许总线、read 和 Job 控制，写入/编辑即使可见也会拒绝。它不是进程级沙箱，读取边界仍由宿主权限决定；同一预设的会话共享有界队列容量，但请求结果按会话隔离。
+**0.3.0 起不再是只读验证模式。** 加载时读取宿主 `ptc` 预设的组合声明快照，保留原工具、平台表达式、禁用项和配置，只追加萧何总线与说明。不再强制 native 呈现或添加只读白名单；终端、写入、搜索、技能等能力是否可用，取决于原 PTC 配置和宿主服务。其他预设和默认模式不被修改，原 PTC 会话看不到新增总线。
+
+普通任务仍通过 `run_code` 调用原工具；**总线目前只支持 test 和 host.read，不接管任意命令、安装或全部工具**。例如更新插件应使用原终端能力并遵守宿主授权；专用插件管理工具若在源 PTC 中禁用，萧何不会擅自启用。命令受理、返回 Job ID 不等于执行完成。
+
+升级提示：预设 ID 保持兼容，但从旧版只读模式升级后能力范围扩大，使用者须审阅后加载；本次不自动升级日常配置。它不是进程沙箱，同一预设会话共享总线容量，结果按会话隔离。派生是加载时快照，不自动跟随源预设热编辑；源 PTC 更新后应按宿主正常流程重新加载派生行，旧会话遵循宿主版本保留规则。
+
+源组合中的相对模块名、include 子文件缺少公开基准地址信息，当前明确拒绝派生，不能称为兼容所有自定义 PTC。遇到该诊断应先将源组合整理成可解析的显式模块行，不能绕过或回退成只读工具集。缺失 ptc 声明时注册器最多等候约 5 秒后明确失败。
 
 **不要同时把包根入口作为全局工具插件加载**：那是手工集成入口，会使 execution_bus 全局可见，失去此预设的可见性隔离。仅安装 npm 包也不保证卡片立即出现，需要加载包声明的 bundle patch。项目发布不会自动安装到任何读者的宿主，卡片是否可用需要在目标实例实际检查。
 
@@ -109,7 +115,7 @@ flowchart TD
 2. 在你选定的隔离 DSH 配置依赖目录安装固定版本，不要在 DSH 程序安装目录执行：
 
    ```powershell
-   npm install --ignore-scripts @feng0531/dsh-execution-bus@0.2.12
+   npm install --ignore-scripts @feng0531/dsh-execution-bus@0.4.0
    ```
 
    这是 npm 目录示例。若目标配置使用 pnpm，应沿用其包管理器，不混用锁文件。遇到宿主 peer 版本冲突就停止，不用强制安装绕过。
@@ -178,7 +184,7 @@ flowchart TD
 
 ### 如果宿主使用 PTC 模式
 
-PTC 是 DSH 的程序化工具调用入口。在 `run_code` 内使用 `await tools.execution_bus(请求对象)`，而不是直接调用折叠后的工具名。执行总线不会解除 `run_code` 自身的时间预算；PTC 完整进程链路尚未验收。
+PTC 是 DSH 的程序化工具调用入口。在 `run_code` 内使用 `await tools.execution_bus(请求对象)`，而不是直接调用折叠后的工具名。执行总线不会解除 `run_code` 自身的时间预算。已有真实 Node PTC 隔离进程读文件和调用总线的验证，但尚未进行实际模型/桌面沙箱全链路验收。
 
 ## 如何理解任务状态？
 
@@ -204,6 +210,12 @@ stateDiagram-v2
 
 执行终态不会再改成另一个终态。取消与成功竞争时，若处理器最终正常返回，仍可能是成功。`delivery` 是另一个字段：`pending` 表示尚未走到返回标记，`returned` 只表示插件已走到工具返回路径，**不证明会话结果已经写入磁盘或模型已经消费**。
 
+## 调度与诊断
+
+0.4.0 起对已受理的排队请求按会话轮转，同一会话保持 FIFO；不抢占运行任务，也不保证队列满时为其他会话预留名额。执行结果仍由 core 唯一提交，宿主 Job 只负责任务展示、控制与生命周期关联。
+
+core 开发者可调用实例 `diagnostics()` 取得队列、运行数、保留结果字节及最近 128 条数值阶段轨迹。不含请求/会话 ID、输入、输出或错误文本，不写日志；诊断不增加模型调用工具，也不是跨重启审计记录。详见[优化范围与验证](<docs/OPTIMIZATION.md>)。
+
 ## 容量与重要限制
 
 默认并发 **2**，排队上限 **32**，最多保存 **256** 条任务记录，单结果最多 **64 KiB**，完成结果保留期 **1 小时**，在新请求和查询时惰性清理；不是一小时一到即定时删除。队列或记录满时拒绝新任务；宿主 Job 自身也有容量限制。
@@ -238,7 +250,7 @@ npm run test:install    # 临时目录安装，不操作日常 DSH
 
 - [协议和投递语义](<docs/protocol.md>)：字段、状态、重复处理与取消规则。
 - [宿主兼容性与源码调用链](<docs/host-compatibility.md>)：为什么可以等待，为什么不能跨重启恢复。
-- [验证记录](<docs/validation.md>)、[0.2.12 发布说明](<docs/releases/0.2.12.md>)：已验证与未验证范围。
+- [验证记录](<docs/validation.md>)、[0.4.0 发布说明](<docs/releases/0.4.0.md>)：已验证与未验证范围。
 - [维护者发布流程](<docs/RELEASING.md>)：标签 CI、安装包校验与正式发布门禁。
 
 ## 许可

package/THIRD_PARTY_NOTICES.md

@@ -1,5 +1,5 @@
 # 第三方说明
 
-本包没有捆绑 DSH、Cordis、TypeScript、测试依赖或宿主源码快照。DSH 与 Cordis 作为宿主 peer 使用，其独立包分别受原许可证约束，本项目非商业许可证不限制第三方已授予的权利。开发依赖不进入本项目 tgz。
+本包没有捆绑 DSH、Cordis、TypeScript、测试依赖或宿主源码快照。DSH 与 Cordis 作为宿主 peer 使用，其独立包分别受原许可证约束，本项目非商业许可证不限制第三方已授予的权利。开发依赖不进入本项目 tgz。js-yaml 为 MIT 许可的独立运行依赖，由包管理器按声明安装，不捆绑进 tgz；其源码和许可见 https://github.com/nodeca/js-yaml ，本项目许可不限制其原有权利。
 
 CI 与发布组织方式参考 dsh-vcs，并按本项目执行能力重新实现；本包不含 Monaco、React 或 SVN 实现。

package/cordis.patch.yml

@@ -1,25 +1,6 @@
-# Registers a selectable custom preset, not a global execution_bus tool.
+# Add a separate selectable preset, deriving the host's configured PTC declaration.
+# Does not patch preset-ptc, selectedDefault or global tools.
 - insert:
     - id: preset-execution-bus-test
-      name: '@deepseek-ai/dsh-agent-preset'
-      config:
-        id: execution-bus-test
-        name: 萧何 / Xiao He
-        description: 独立执行模式：请求排队、异步等待、进度和取消；当前支持受控验证与只读文件。不修改默认模式，禁止命令和写入执行；不支持重启恢复。
-        order: 20
-        plugins:
-          - id: execution-bus-persona
-            name: '@deepseek-ai/dsh-persona'
-            config:
-              prefix: >-
-                你正在萧何模式中；这是执行请求协调模式，不是人物角色扮演。只使用 execution_bus、只读文件和任务控制工具。
-                请求只提交一次并等待结果，不循环查询进度；同一逻辑操作重发沿用 requestId。
-                默认先用 test Handler 做延迟成功、失败和取消测试，读取真实文件须有用户要求。
-                cancelRequested 不代表已取消，unknown 不代表执行失败。禁止声称跨重启恢复或完整模型性能提升。
-              suffix: 'Your working directory is {{cwd}}.'
-          - id: execution-bus-file-tools
-            name: '@deepseek-ai/dsh-tool-fs'
-          - id: execution-bus-job-tools
-            name: '@deepseek-ai/dsh-tool-jobs'
-          - id: execution-bus-scoped-runtime
-            name: '@feng0531/dsh-execution-bus/test-mode'
+      name: '@feng0531/dsh-execution-bus/preset'
+      config: {}

package/dist/bus.d.ts

@@ -53,8 +53,35 @@ export declare class ExecutionBus {
     private entries;
     private handlers;
     private queue;
+    private readyOwners;
     private running;
     private closed;
+    private telemetry;
+    diagnostics(): {
+        phase: "open" | "cancelling" | "draining" | "closed";
+        queued: number;
+        running: number;
+        records: number;
+        retainedResultBytes: number;
+        counts: {
+            accepted?: number | undefined;
+            started?: number | undefined;
+            cancel_requested?: number | undefined;
+            terminal?: number | undefined;
+            returned?: number | undefined;
+            job_created?: number | undefined;
+            job_released?: number | undefined;
+            job_error?: number | undefined;
+            reused?: number | undefined;
+        };
+        traces: {
+            operation: number;
+            stage: import("./diagnostics.js").TraceStage;
+            elapsedMs: number;
+        }[];
+    };
+    private closing?;
+    private shutdownPhase;
     constructor(options?: {
         concurrency: number;
         queueLimit: number;

package/dist/bus.js

@@ -1,5 +1,6 @@
 import { randomUUID, createHash } from "node:crypto";
 import { assertJson } from "./json.js";
+import { Diagnostics } from "./diagnostics.js";
 export function object(v) {
     if (!v || typeof v !== "object" || Array.isArray(v))
         throw Error("INVALID_OBJECT");
@@ -58,8 +59,25 @@ export class ExecutionBus {
     entries = new Map();
     handlers = new Map();
     queue = [];
+    readyOwners = [];
     running = 0;
     closed = false;
+    telemetry = new Diagnostics();
+    diagnostics() {
+        return {
+            ...this.telemetry.snapshot(),
+            phase: this.shutdownPhase,
+            queued: this.queue.length,
+            running: this.running,
+            records: this.entries.size,
+            retainedResultBytes: [...this.entries.values()].reduce((sum, e) => sum +
+                (e.view.result === undefined
+                    ? 0
+                    : Buffer.byteLength(JSON.stringify(e.view.result))), 0),
+        };
+    }
+    closing;
+    shutdownPhase = "open";
     constructor(options = {
         concurrency: 2,
         queueLimit: 32,
@@ -119,16 +137,30 @@ export class ExecutionBus {
             type,
             payload,
         });
-        for (const f of e.listeners)
-            try {
-                // Observe promise rejection without awaiting or blocking task settlement.
-                void Promise.resolve(f(event)).catch(() => {
-                    /* Async observers are best-effort; never leak their error text. */
-                });
-            }
-            catch {
-                /* Observers cannot alter execution. */
+        // Snapshot and enqueue before invoking user code: nested cancellation cannot
+        // overtake the current event for later observers. Removed listeners are skipped.
+        e.notifications.push({ event, listeners: [...e.listeners] });
+        if (e.dispatching)
+            return;
+        e.dispatching = true;
+        try {
+            while (e.notifications.length) {
+                const batch = e.notifications.shift();
+                for (const listener of batch.listeners) {
+                    if (!e.listeners.has(listener))
+                        continue;
+                    try {
+                        void Promise.resolve(listener(batch.event)).catch(() => { });
+                    }
+                    catch { }
+                }
             }
+        }
+        finally {
+            e.dispatching = false;
+            if (terminal(e.view.state))
+                e.listeners.clear();
+        }
     }
     view(e) {
         return structuredClone(e.view);
@@ -170,6 +202,7 @@ export class ExecutionBus {
             const attached = this.attachment(e, onEvent, m.messageId);
             if (!previous)
                 e.messages.set(m.messageId, canonical(m));
+            this.telemetry.record(e.trace, "reused");
             return attached;
         }
         const handler = this.handlers.get(p.handler)?.handler;
@@ -182,6 +215,7 @@ export class ExecutionBus {
         let resolve;
         const done = new Promise((r) => (resolve = r));
         e = {
+            trace: this.telemetry.begin(),
             invoke,
             correlationId: m.messageId,
             owner: owner.sessionId,
@@ -199,13 +233,18 @@ export class ExecutionBus {
             done,
             resolve,
             listeners: new Set(),
+            notifications: [],
+            dispatching: false,
             sourceSequence: 0,
             created: Date.now(),
             messages: new Map([[m.messageId, canonical(m)]]),
         };
         this.entries.set(key, e);
+        this.telemetry.record(e.trace, "accepted");
         const attached = this.attachment(e, onEvent, m.messageId);
         this.queue.push(e);
+        if (!this.readyOwners.includes(e.owner))
+            this.readyOwners.push(e.owner);
         queueMicrotask(() => this.pump());
         return attached;
     }
@@ -235,6 +274,8 @@ export class ExecutionBus {
                     e.listeners.delete(listener);
             },
             returned: () => {
+                if (e.view.delivery !== "returned")
+                    this.telemetry.record(e.trace, "returned");
                 e.view.delivery = "returned";
             },
         };
@@ -268,10 +309,13 @@ export class ExecutionBus {
         if (terminal(e.view.state) || e.view.cancelRequested)
             return;
         e.view.cancelRequested = true;
+        this.telemetry.record(e.trace, "cancel_requested");
         e.controller.abort();
         this.emit(e, "cancel_requested", {});
         if (e.view.state === "queued") {
             this.queue = this.queue.filter((x) => x !== e);
+            if (!this.queue.some((entry) => entry.owner === e.owner))
+                this.readyOwners = this.readyOwners.filter((owner) => owner !== e.owner);
             this.finish(e, "cancelled");
         }
     }
@@ -302,19 +346,33 @@ export class ExecutionBus {
         }
         e.created = Date.now();
         e.view = { ...next, sequence: next.sequence - 1 };
-        this.emit(e, state, { state });
+        this.telemetry.record(e.trace, "terminal");
         e.resolve(snapshot);
-        e.listeners.clear();
+        this.emit(e, state, { state });
+        // A reentrant terminal notification may still be queued behind this batch.
+        if (!e.dispatching)
+            e.listeners.clear();
     }
     pump() {
         while (!this.closed &&
             this.running < this.options.concurrency &&
             this.queue.length) {
-            const e = this.queue.shift();
+            let index = -1;
+            while (this.readyOwners.length && index < 0) {
+                const owner = this.readyOwners.shift();
+                index = this.queue.findIndex((entry) => entry.owner === owner);
+                if (index >= 0 &&
+                    this.queue.some((entry, i) => i !== index && entry.owner === owner))
+                    this.readyOwners.push(owner);
+            }
+            if (index < 0)
+                index = 0;
+            const e = this.queue.splice(index, 1)[0];
             if (e.view.state !== "queued")
                 continue;
             this.running++;
             e.view.state = "running";
+            this.telemetry.record(e.trace, "started");
             this.emit(e, "started", {});
             void this.run(e).finally(() => {
                 this.running--;
@@ -372,12 +430,28 @@ export class ExecutionBus {
                     : "HANDLER_FAILED");
         }
     }
-    async close() {
+    close() {
+        if (this.closing)
+            return this.closing;
         this.closed = true;
-        for (const e of this.entries.values())
-            this.cancel(e);
-        await Promise.all([...this.entries.values()].map((e) => e.done));
-        this.handlers.clear();
-        this.entries.clear();
+        this.shutdownPhase = "cancelling";
+        let resolve, reject;
+        this.closing = new Promise((r, j) => {
+            resolve = r;
+            reject = j;
+        });
+        void (async () => {
+            const entries = [...this.entries.values()];
+            for (const e of entries)
+                this.cancel(e);
+            this.shutdownPhase = "draining";
+            await Promise.all(entries.map((e) => e.done));
+            this.handlers.clear();
+            this.entries.clear();
+            this.queue = [];
+            this.readyOwners = [];
+            this.shutdownPhase = "closed";
+        })().then(resolve, reject);
+        return this.closing;
     }
 }

package/dist/diagnostics.d.ts

@@ -0,0 +1,38 @@
+export type TraceStage = "accepted" | "started" | "cancel_requested" | "terminal" | "returned" | "job_created" | "job_released" | "job_error" | "reused";
+export interface Trace {
+    operation: number;
+    stage: TraceStage;
+    elapsedMs: number;
+}
+/** In-memory numeric metadata only: never accepts request/session strings, input, output or error text. */
+export declare class Diagnostics {
+    private next;
+    private events;
+    private counts;
+    begin(): {
+        operation: number;
+        at: number;
+    };
+    record(context: {
+        operation: number;
+        at: number;
+    }, stage: TraceStage): void;
+    snapshot(): {
+        counts: {
+            accepted?: number | undefined;
+            started?: number | undefined;
+            cancel_requested?: number | undefined;
+            terminal?: number | undefined;
+            returned?: number | undefined;
+            job_created?: number | undefined;
+            job_released?: number | undefined;
+            job_error?: number | undefined;
+            reused?: number | undefined;
+        };
+        traces: {
+            operation: number;
+            stage: TraceStage;
+            elapsedMs: number;
+        }[];
+    };
+}

package/dist/diagnostics.js

@@ -0,0 +1,26 @@
+import { performance } from "node:perf_hooks";
+/** In-memory numeric metadata only: never accepts request/session strings, input, output or error text. */
+export class Diagnostics {
+    next = 0;
+    events = [];
+    counts = {};
+    begin() {
+        return { operation: ++this.next, at: performance.now() };
+    }
+    record(context, stage) {
+        this.counts[stage] = (this.counts[stage] ?? 0) + 1;
+        this.events.push({
+            operation: context.operation,
+            stage,
+            elapsedMs: Math.max(0, performance.now() - context.at),
+        });
+        if (this.events.length > 128)
+            this.events.shift();
+    }
+    snapshot() {
+        return {
+            counts: { ...this.counts },
+            traces: this.events.map((e) => ({ ...e })),
+        };
+    }
+}

package/dist/execution.d.ts

@@ -0,0 +1,61 @@
+import type { JobRegistry, JobId } from "@deepseek-ai/dsh-jobs";
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { RecordView, Event } from "./bus.js";
+import { Diagnostics } from "./diagnostics.js";
+export interface ExecutionAttachment {
+    done: Promise<RecordView>;
+    cancel(): void;
+}
+/** One host projection of a logical execution. The core completion remains authoritative. */
+export declare class ExecutionHandle {
+    private jobs;
+    private owner;
+    private execution;
+    private telemetry;
+    readonly completion: Promise<RecordView>;
+    readonly settled: Promise<void>;
+    readonly job: JobId;
+    private progressHandle?;
+    private trace;
+    constructor(jobs: JobRegistry, owner: SessionId, execution: ExecutionAttachment, telemetry?: Diagnostics);
+    requestCancel(): void;
+    progress(event: Event): void;
+    private absent;
+    private waitAndClean;
+}
+export type ShutdownPhase = "open" | "stopping" | "draining" | "releasing" | "closed";
+/** Owns host projections and active deliveries, not a second execution state machine. */
+export declare class ExecutionOwner {
+    private handles;
+    private deliveries;
+    private closing?;
+    private telemetry;
+    create(key: string, jobs: JobRegistry, owner: SessionId, execution: ExecutionAttachment): ExecutionHandle;
+    diagnostics(): {
+        phase: ShutdownPhase;
+        activeProjections: number;
+        deliveries: number;
+        counts: {
+            accepted?: number | undefined;
+            started?: number | undefined;
+            cancel_requested?: number | undefined;
+            terminal?: number | undefined;
+            returned?: number | undefined;
+            job_created?: number | undefined;
+            job_released?: number | undefined;
+            job_error?: number | undefined;
+            reused?: number | undefined;
+        };
+        traces: {
+            operation: number;
+            stage: import("./diagnostics.js").TraceStage;
+            elapsedMs: number;
+        }[];
+    };
+    private currentPhase;
+    get phase(): ShutdownPhase;
+    get(key: string): ExecutionHandle | undefined;
+    add(key: string, handle: ExecutionHandle): void;
+    track<T>(delivery: Promise<T>): Promise<T>;
+    close(drainCore: () => Promise<void>): Promise<void>;
+}

package/dist/execution.js

@@ -0,0 +1,174 @@
+import { setTimeout as pause } from "node:timers/promises";
+import { Diagnostics } from "./diagnostics.js";
+/** One host projection of a logical execution. The core completion remains authoritative. */
+export class ExecutionHandle {
+    jobs;
+    owner;
+    execution;
+    telemetry;
+    completion;
+    settled;
+    job;
+    progressHandle;
+    trace;
+    constructor(jobs, owner, execution, telemetry = new Diagnostics()) {
+        this.jobs = jobs;
+        this.owner = owner;
+        this.execution = execution;
+        this.telemetry = telemetry;
+        this.trace = telemetry.begin();
+        this.completion = execution.done;
+        const outcome = this.completion.then((v) => ({
+            status: v.state === "succeeded"
+                ? "completed"
+                : v.state === "cancelled"
+                    ? "killed"
+                    : "failed",
+            detail: v.state,
+        }));
+        this.job = jobs.start({
+            kind: "execution-bus",
+            label: "萧何 / Xiao He",
+            owner,
+            run: (handle) => {
+                this.progressHandle = handle;
+                return { done: outcome, cancel: () => this.requestCancel() };
+            },
+        });
+        telemetry.record(this.trace, "job_created");
+        this.settled = this.waitAndClean();
+    }
+    requestCancel() {
+        this.execution.cancel();
+    }
+    progress(event) {
+        this.progressHandle?.updateProgress(event.type === "progress"
+            ? String(event.payload.percent) + "%"
+            : event.type);
+    }
+    absent(error) {
+        try {
+            return (error instanceof Error &&
+                error.message === "unknown job " + this.job &&
+                !this.jobs.list(this.owner).some((v) => v.id === this.job));
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitAndClean() {
+        try {
+            for (;;) {
+                const view = await this.jobs.wait(this.job, 60000, this.owner);
+                if (view.status !== "running" && view.status !== "stopping")
+                    break;
+            }
+            this.jobs.remove(this.job, this.owner);
+            this.telemetry.record(this.trace, "job_released");
+        }
+        catch (error) {
+            this.telemetry.record(this.trace, "job_error");
+            const removed = this.absent(error);
+            // Retain the original execution, including while its caller/owner is being disposed.
+            await this.completion;
+            if (removed)
+                this.telemetry.record(this.trace, "job_released");
+            if (!removed) {
+                for (let attempt = 0; attempt < 20; attempt++) {
+                    try {
+                        const view = this.jobs
+                            .list(this.owner)
+                            .find((v) => v.id === this.job && v.owner === this.owner);
+                        if (!view) {
+                            this.telemetry.record(this.trace, "job_released");
+                            break;
+                        }
+                        if (view.status !== "running" && view.status !== "stopping") {
+                            this.jobs.remove(this.job, this.owner);
+                            this.telemetry.record(this.trace, "job_released");
+                            break;
+                        }
+                    }
+                    catch {
+                        break;
+                    }
+                    await pause(10);
+                }
+                throw error;
+            }
+        }
+        finally {
+            this.progressHandle = undefined;
+        }
+    }
+}
+/** Owns host projections and active deliveries, not a second execution state machine. */
+export class ExecutionOwner {
+    handles = new Map();
+    deliveries = new Set();
+    closing;
+    telemetry = new Diagnostics();
+    create(key, jobs, owner, execution) {
+        if (this.phase !== "open")
+            throw Error("CLOSED");
+        if (this.handles.has(key))
+            throw Error("DUPLICATE_EXECUTION_HANDLE");
+        const handle = new ExecutionHandle(jobs, owner, execution, this.telemetry);
+        this.add(key, handle);
+        return handle;
+    }
+    diagnostics() {
+        return {
+            ...this.telemetry.snapshot(),
+            phase: this.phase,
+            activeProjections: this.handles.size,
+            deliveries: this.deliveries.size,
+        };
+    }
+    currentPhase = "open";
+    get phase() {
+        return this.currentPhase;
+    }
+    get(key) {
+        return this.handles.get(key);
+    }
+    add(key, handle) {
+        if (this.phase !== "open")
+            throw Error("CLOSED");
+        if (this.handles.has(key))
+            throw Error("DUPLICATE_EXECUTION_HANDLE");
+        this.handles.set(key, handle);
+        const release = () => {
+            if (this.handles.get(key) === handle)
+                this.handles.delete(key);
+        };
+        void handle.settled.then(release, release);
+    }
+    track(delivery) {
+        this.deliveries.add(delivery);
+        const release = () => this.deliveries.delete(delivery);
+        void delivery.then(release, release);
+        return delivery;
+    }
+    close(drainCore) {
+        if (this.closing)
+            return this.closing;
+        this.currentPhase = "stopping";
+        let resolve, reject;
+        this.closing = new Promise((r, j) => {
+            resolve = r;
+            reject = j;
+        });
+        void (async () => {
+            const core = drainCore();
+            this.currentPhase = "draining";
+            await core;
+            await Promise.allSettled([...this.deliveries]);
+            this.currentPhase = "releasing";
+            await Promise.allSettled([...this.handles.values()].map((h) => h.settled));
+            this.handles.clear();
+            this.currentPhase = "closed";
+        })().then(resolve, reject);
+        return this.closing;
+    }
+}