@actiondock/core 2.10.0 → 2.12.0

package/dist/process/input-dispatcher.js

@@ -1,4 +1,22 @@
-import { CONTROL_REVOKED, INPUT_CLOSED, INPUT_OUTCOME_UNKNOWN, PROCESS_QUARANTINED, QUEUE_FULL, ProcessError, } from "../errors.js";
+import { ActionDockError, CONTROL_REVOKED, INPUT_CLOSED, INPUT_OUTCOME_UNKNOWN, INVALID_STATE, PROCESS_QUARANTINED, ProcessError, } from "../errors.js";
+/**
+ * 断言进程仍处于可交互(非隔离、非终态)状态。
+ */
+function assertProcessOperable(proc) {
+    if (proc.info.control === "quarantined") {
+        throw new ProcessError(PROCESS_QUARANTINED, "Process is in quarantined state");
+    }
+    const state = proc.info.state;
+    if (state === "exited" || state === "failed" || state === "lost") {
+        throw new ProcessError(INPUT_CLOSED, `Process is no longer operable (state: ${state})`);
+    }
+}
+/**
+ * 进程是否已进入不可交互的终态。
+ */
+function isProcessTerminal(proc) {
+    return proc.info.control === "quarantined" || proc.info.control === "closed";
+}
 /**
  * 输入调度器。
  *
@@ -11,74 +29,47 @@ import { CONTROL_REVOKED, INPUT_CLOSED, INPUT_OUTCOME_UNKNOWN, PROCESS_QUARANTIN
  */
 export class InputDispatcher {
     host;
-    arbiter;
-    constructor(host, arbiter) {
+    constructor(host) {
         this.host = host;
-        this.arbiter = arbiter;
     }
     /**
-     * 入队写入操作：同步阶段完成授权校验、输入通道校验、队列容量检查与字节预扣；
+     * 入队写入操作：同步阶段完成授权校验与输入通道校验；
      * 异步阶段落盘排队收据并推送队列，随后触发串行调度。
      *
      * 返回的 Promise 在收据成功入队后 resolve（state 为 queued）；
-     * 落盘或推送失败时回滚字节预扣并原样抛出。
+     * 落盘或推送失败时原样抛出。
      */
     async enqueueWrite(proc, input) {
-        // 入队前校验授权与控制状态
-        this.arbiter.validateOperation(proc, input.token);
+        // 入队前校验进程仍处于可交互状态
+        assertProcessOperable(proc);
         if (proc.inputClosed) {
             throw new ProcessError(INPUT_CLOSED, "Input stream is closed");
         }
         const rawBytes = input.data;
-        const dataSize = rawBytes.byteLength;
-        // 待写入队列容量检查：在任何 await 前同步原子校验并预占配额
-        if (proc.pendingInputBytes + dataSize > this.host.maxPendingQueueBytesPerProcess) {
-            throw new ProcessError(QUEUE_FULL, "Process pending input queue limit exceeded", {
-                limit: this.host.maxPendingQueueBytesPerProcess,
-            });
-        }
-        const totalHostPending = this.host.countHostPendingInputBytes();
-        if (totalHostPending + dataSize > this.host.maxPendingQueueBytesPerHost) {
-            throw new ProcessError(QUEUE_FULL, "Host pending input queue limit exceeded", {
-                limit: this.host.maxPendingQueueBytesPerHost,
-            });
-        }
-        // 同步占位预扣队列配额，杜绝并发 await 窗口穿透
-        proc.pendingInputBytes += dataSize;
-        let pendingBytesCommitted = false;
-        try {
-            const receipt = {
-                requestId: input.requestId,
-                state: "queued",
-            };
-            await this.host.persistReceipt(input.key, receipt, input.payloadHash);
-            proc.inputQueue.push({
-                type: "write",
-                requestId: input.requestId,
-                token: input.token,
-                bytes: rawBytes,
-                receipt,
-                key: input.key,
-                payloadHash: input.payloadHash,
-                cancelEpoch: proc.cancelEpoch,
-            });
-            pendingBytesCommitted = true;
-            // 异步调度推进
-            queueMicrotask(() => void this.dispatchNext(proc));
-            return { ...receipt };
-        }
-        finally {
-            if (!pendingBytesCommitted) {
-                proc.pendingInputBytes = Math.max(0, proc.pendingInputBytes - dataSize);
-            }
-        }
+        const receipt = {
+            requestId: input.requestId,
+            state: "queued",
+        };
+        await this.host.persistReceipt(input.key, receipt, input.payloadHash);
+        proc.inputQueue.push({
+            type: "write",
+            requestId: input.requestId,
+            bytes: rawBytes,
+            receipt,
+            key: input.key,
+            payloadHash: input.payloadHash,
+            cancelEpoch: proc.cancelEpoch,
+        });
+        // 异步调度推进
+        queueMicrotask(() => void this.dispatchNext(proc));
+        return { ...receipt };
     }
     /**
      * 入队控制指令：异步阶段落盘排队收据并推送队列，随后触发串行调度。
      */
     async enqueueControl(proc, input) {
-        // 入队前校验授权与控制状态
-        this.arbiter.validateOperation(proc, input.token);
+        // 入队前校验进程仍处于可交互状态
+        assertProcessOperable(proc);
         const receipt = {
             requestId: input.requestId,
             state: "queued",
@@ -87,7 +78,6 @@ export class InputDispatcher {
         proc.inputQueue.push({
             type: "control",
             requestId: input.requestId,
-            token: input.token,
             action: input.action,
             receipt,
             key: input.key,
@@ -114,7 +104,6 @@ export class InputDispatcher {
             void this.host.persistReceipt(op.key, op.receipt, op.payloadHash);
         }
         proc.inputQueue = [];
-        proc.pendingInputBytes = 0;
     }
     /**
      * 串行调度执行输入队列操作。
@@ -130,11 +119,8 @@ export class InputDispatcher {
         try {
             while (proc.inputQueue.length > 0) {
                 const op = proc.inputQueue[0];
-                // dispatch 前校验 token、epoch 与授权（经控制权仲裁器委托复核）
-                if (proc.info.control !== "held" ||
-                    !proc.currentGrant ||
-                    proc.currentGrant.token !== op.token ||
-                    new Date(proc.currentGrant.expiresAt).getTime() <= Date.now() ||
+                // dispatch 前校验进程状态与取消纪元
+                if (isProcessTerminal(proc) ||
                     op.cancelEpoch !== proc.cancelEpoch) {
                     if (op.cancelEpoch === proc.cancelEpoch) {
                         op.receipt.state = "failed";
@@ -143,9 +129,6 @@ export class InputDispatcher {
                         await this.host.persistReceipt(op.key, op.receipt, op.payloadHash);
                     }
                     proc.inputQueue.shift();
-                    if (op.bytes && op.cancelEpoch === proc.cancelEpoch) {
-                        proc.pendingInputBytes -= op.bytes.byteLength;
-                    }
                     continue;
                 }
                 op.receipt.state = "dispatching";
@@ -153,7 +136,7 @@ export class InputDispatcher {
                 if (op.type === "write" && op.bytes) {
                     try {
                         if (!proc.handle) {
-                            throw new Error("Missing driver handle");
+                            throw new ActionDockError(INVALID_STATE, "Missing driver handle");
                         }
                         await proc.handle.write(op.bytes);
                         // 写入返回后校验取消纪元与队首位置：已被 stop 或 quarantine 接管则放弃过期结算
@@ -174,15 +157,14 @@ export class InputDispatcher {
                         op.receipt.errorCode = INPUT_OUTCOME_UNKNOWN;
                         await this.host.persistReceipt(op.key, op.receipt, op.payloadHash);
                         proc.inputQueue.shift();
-                        proc.pendingInputBytes -= op.bytes.byteLength;
-                        await this.host.quarantineProcess(proc.owner, proc.info.id, op.token, "Write failed with uncertain outcome");
+                        await this.host.quarantineProcess(proc.owner, proc.info.id, "Write failed with uncertain outcome");
                         break;
                     }
                 }
                 else if (op.type === "control" && op.action) {
                     try {
                         if (!proc.handle) {
-                            throw new Error("Missing driver handle");
+                            throw new ActionDockError(INVALID_STATE, "Missing driver handle");
                         }
                         if (op.action.type === "input-eof") {
                             if (proc.handle.sendInputEOF) {
@@ -228,9 +210,6 @@ export class InputDispatcher {
                 }
                 await this.host.persistReceipt(op.key, op.receipt, op.payloadHash);
                 proc.inputQueue.shift();
-                if (op.bytes) {
-                    proc.pendingInputBytes -= op.bytes.byteLength;
-                }
             }
         }
         finally {

package/dist/process/managed-record.d.ts

@@ -1,8 +1,7 @@
-import type { ControlGrant, Limits, OperationReceipt, ProcessControlAction, ProcessInfo } from "@actiondock/sdk";
+import type { Limits, OperationReceipt, ProcessControlAction, ProcessInfo } from "@actiondock/sdk";
 import type { ProcessDriverHandle, ProcessHandle } from "./driver.js";
 import type { ProcessRequestKey } from "./metadata-store.js";
 import type { ProcessOutputLog } from "./output-log.js";
-import type { EvictedOutputTombstone } from "./terminal-output-cache.js";
 /**
  * 受管进程归属所有者身份。
  */
@@ -18,7 +17,6 @@ export interface ProcessOwner {
 export interface QueuedOperation {
     type: "write" | "control";
     requestId: string;
-    token: string;
     bytes?: Uint8Array;
     action?: ProcessControlAction;
     /** 入队时进程的取消纪元，用于 stop 与 dispatch 竞态判定 */
@@ -27,24 +25,11 @@ export interface QueuedOperation {
     key: ProcessRequestKey;
     payloadHash: string;
 }
-/**
- * 排队等待获取控制权的调用者条目。
- */
-export interface AcquireWaiter {
-    requestId: string;
-    waitMs: number;
-    ttlMs: number;
-    runId?: string;
-    timer?: ReturnType<typeof setTimeout>;
-    onAbort?: () => void;
-    resolve: (grant: ControlGrant) => void;
-    reject: (err: unknown) => void;
-}
 /**
  * 进程管理器内部维护的活跃受管进程记录。
  *
- * 该结构为进程管理器、控制权仲裁器与输入调度器的共享事实源：
- * 控制权与输入队列相关字段经仲裁器与调度器协作推进，禁止绕过二者直接改写。
+ * 该结构为进程管理器与输入调度器的共享事实源：
+ * 输入队列相关字段经调度器协作推进，禁止绕过调度器直接改写。
  */
 export interface ManagedProcessRecord {
     info: ProcessInfo;
@@ -53,25 +38,12 @@ export interface ManagedProcessRecord {
     handle?: ProcessHandle & ProcessDriverHandle;
     outputLog: ProcessOutputLog;
     outputUnavailable?: boolean;
-    outputTombstone?: EvictedOutputTombstone;
-    controlEpoch: number;
     /** 取消纪元：stop 接管输入队列时递增，用于让挂起中的 dispatch 放弃过期结算 */
     cancelEpoch: number;
-    currentGrant?: {
-        token: string;
-        epoch: number;
-        ttlMs: number;
-        expiresAt: string;
-        runId?: string;
-        requestId: string;
-    };
-    ttlTimer?: ReturnType<typeof setTimeout>;
     idleTimer?: ReturnType<typeof setTimeout>;
     lifetimeTimer?: ReturnType<typeof setTimeout>;
     drainTimer?: ReturnType<typeof setTimeout>;
     inputQueue: QueuedOperation[];
-    pendingInputBytes: number;
-    acquireWaiters: AcquireWaiter[];
     inputClosed: boolean;
     isDispatching: boolean;
     effectiveLimits: Required<Limits>;

package/dist/process/metadata-store.d.ts

@@ -1,4 +1,3 @@
-import type { SqliteDriver } from "../storage/types.js";
 /**
  * 受管进程运行状态。
  */
@@ -163,43 +162,3 @@ export declare class MemoryProcessMetadataStore implements ProcessMetadataStore
     initializeHost(hostEpoch: string): Promise<number>;
     clear(): void;
 }
-/**
- * SQLite 存储选项。
- */
-export interface SqliteProcessMetadataStoreOptions {
-    dbPath?: string;
-    driver?: SqliteDriver;
-}
-/**
- * 基于 SQLite 的受管进程元数据持久化存储实现。
- */
-export declare class SqliteProcessMetadataStore implements ProcessMetadataStore {
-    private driver;
-    private statementCache;
-    private isClosed;
-    constructor(options?: SqliteProcessMetadataStoreOptions);
-    private initTables;
-    /**
-     * 旧库结构迁移：逐列探测并补充新增字段，重复执行安全（幂等）。
-     */
-    private migrateSchema;
-    /**
-     * 枚举指定表的全部列定义。
-     */
-    private listTableColumns;
-    private getStatement;
-    saveProcess(process: StoredProcessRecord): Promise<void>;
-    getProcess(processId: string): Promise<StoredProcessRecord | undefined>;
-    listProcesses(owner: ProcessOwnerFilter, pageToken?: string, limit?: number): Promise<{
-        processes: ProcessInfo[];
-        nextPageToken?: string;
-    }>;
-    updateProcessState(processId: string, patch: Partial<ProcessInfo>): Promise<void>;
-    recordRequest(key: ProcessRequestKey, receipt: OperationReceipt, payloadHash?: string): Promise<void>;
-    getRequest(key: ProcessRequestKey): Promise<{
-        receipt: OperationReceipt;
-        payloadHash?: string;
-    } | undefined>;
-    initializeHost(hostEpoch: string): Promise<number>;
-    close(): void;
-}

package/dist/process/metadata-store.js

@@ -1,6 +1,4 @@
-import { chmodSync, existsSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { createDefaultSqliteDriver } from "../storage/driver.js";
+import { ActionDockError, PROCESS_NOT_FOUND } from "../errors.js";
 /**
  * 解析分页游标偏移量。
  */
@@ -69,7 +67,7 @@ export class MemoryProcessMetadataStore {
     async updateProcessState(processId, patch) {
         const target = this.processes.get(processId);
         if (!target) {
-            throw new Error(`Process '${processId}' not found`);
+            throw new ActionDockError(PROCESS_NOT_FOUND, `Process '${processId}' not found`);
         }
         const ctrl = patch.controlState !== undefined ? patch.controlState : patch.control;
         const updated = {
@@ -123,340 +121,3 @@ export class MemoryProcessMetadataStore {
         this.requests.clear();
     }
 }
-/**
- * 将数据库行反序列化为进程模型。
- */
-function mapRowToStoredProcess(row) {
-    return {
-        processId: row.process_id,
-        tenantId: row.tenant_id,
-        principalId: row.principal_id,
-        packageInstanceId: row.package_instance_id,
-        generationId: row.generation_id,
-        hostEpoch: row.host_epoch,
-        state: row.state,
-        controlState: row.control_state ?? undefined,
-        control: row.control_state ?? undefined,
-        ioConfig: row.io_config_json ? JSON.parse(row.io_config_json) : undefined,
-        capabilities: row.capabilities_json ? JSON.parse(row.capabilities_json) : undefined,
-        createdAt: row.created_at,
-        exitCode: row.exit_code !== null && row.exit_code !== undefined ? Number(row.exit_code) : undefined,
-        exitSignal: row.exit_signal ?? undefined,
-        endReason: row.end_reason ?? undefined,
-        outputClosed: Boolean(row.output_closed),
-        outputEndReason: row.output_end_reason ?? undefined,
-        inputClosed: Boolean(row.input_closed),
-        effectiveLimits: row.effective_limits_json ? JSON.parse(row.effective_limits_json) : undefined,
-        startRequestId: row.start_request_id ?? undefined,
-    };
-}
-/**
- * 基于 SQLite 的受管进程元数据持久化存储实现。
- */
-export class SqliteProcessMetadataStore {
-    driver;
-    statementCache = new Map();
-    isClosed = false;
-    constructor(options = {}) {
-        const dbPath = options.dbPath || ":memory:";
-        if (dbPath !== ":memory:") {
-            const dir = dirname(dbPath);
-            if (!existsSync(dir)) {
-                try {
-                    mkdirSync(dir, { recursive: true, mode: 0o700 });
-                    chmodSync(dir, 0o700);
-                }
-                catch {
-                    // 忽略系统权限配置失败
-                }
-            }
-        }
-        this.driver = options.driver ?? createDefaultSqliteDriver(dbPath);
-        if (dbPath !== ":memory:" && existsSync(dbPath)) {
-            try {
-                chmodSync(dbPath, 0o600);
-            }
-            catch {
-                // 忽略文件权限配置异常
-            }
-        }
-        this.initTables();
-    }
-    initTables() {
-        this.driver.exec("PRAGMA journal_mode = WAL;");
-        this.driver.exec("PRAGMA synchronous = NORMAL;");
-        this.driver.exec(`
-      CREATE TABLE IF NOT EXISTS managed_processes (
-        process_id TEXT PRIMARY KEY,
-        tenant_id TEXT NOT NULL,
-        principal_id TEXT NOT NULL,
-        package_instance_id TEXT NOT NULL,
-        generation_id TEXT NOT NULL,
-        host_epoch TEXT NOT NULL,
-        state TEXT NOT NULL,
-        control_state TEXT,
-        io_config_json TEXT,
-        capabilities_json TEXT,
-        created_at TEXT NOT NULL,
-        exit_code INTEGER,
-        exit_signal TEXT,
-        end_reason TEXT,
-        output_closed INTEGER NOT NULL DEFAULT 0,
-        output_end_reason TEXT,
-        input_closed INTEGER NOT NULL DEFAULT 0,
-        effective_limits_json TEXT,
-        start_request_id TEXT
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_processes_owner_created
-        ON managed_processes(tenant_id, principal_id, package_instance_id, generation_id, created_at DESC, process_id ASC);
-
-      CREATE INDEX IF NOT EXISTS idx_processes_host_state
-        ON managed_processes(host_epoch, state);
-
-      CREATE INDEX IF NOT EXISTS idx_processes_start_req
-        ON managed_processes(start_request_id);
-
-      CREATE TABLE IF NOT EXISTS process_requests (
-        host_epoch TEXT NOT NULL,
-        scope TEXT NOT NULL,
-        process_id TEXT NOT NULL DEFAULT '',
-        request_id TEXT NOT NULL,
-        receipt_json TEXT NOT NULL,
-        payload_hash TEXT,
-        created_at TEXT NOT NULL,
-        PRIMARY KEY (host_epoch, scope, process_id, request_id)
-      );
-    `);
-        this.migrateSchema();
-    }
-    /**
-     * 旧库结构迁移：逐列探测并补充新增字段，重复执行安全（幂等）。
-     */
-    migrateSchema() {
-        const columns = new Set();
-        for (const row of this.listTableColumns("managed_processes")) {
-            columns.add(String(row.name));
-        }
-        if (!columns.has("input_closed")) {
-            this.driver.exec("ALTER TABLE managed_processes ADD COLUMN input_closed INTEGER NOT NULL DEFAULT 0;");
-        }
-    }
-    /**
-     * 枚举指定表的全部列定义。
-     */
-    listTableColumns(tableName) {
-        try {
-            const stmt = this.driver.prepare(`PRAGMA table_info(${tableName})`);
-            return stmt.all() ?? [];
-        }
-        catch {
-            return [];
-        }
-    }
-    getStatement(sql) {
-        let stmt = this.statementCache.get(sql);
-        if (!stmt) {
-            stmt = this.driver.prepare(sql);
-            this.statementCache.set(sql, stmt);
-        }
-        return stmt;
-    }
-    async saveProcess(process) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const stmt = this.getStatement(`
-      INSERT INTO managed_processes (
-        process_id, tenant_id, principal_id, package_instance_id, generation_id,
-        host_epoch, state, control_state, io_config_json, capabilities_json,
-        created_at, exit_code, exit_signal, end_reason, output_closed,
-        output_end_reason, input_closed, effective_limits_json, start_request_id
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(process_id) DO UPDATE SET
-        tenant_id = excluded.tenant_id,
-        principal_id = excluded.principal_id,
-        package_instance_id = excluded.package_instance_id,
-        generation_id = excluded.generation_id,
-        host_epoch = excluded.host_epoch,
-        state = excluded.state,
-        control_state = excluded.control_state,
-        io_config_json = excluded.io_config_json,
-        capabilities_json = excluded.capabilities_json,
-        created_at = excluded.created_at,
-        exit_code = excluded.exit_code,
-        exit_signal = excluded.exit_signal,
-        end_reason = excluded.end_reason,
-        output_closed = excluded.output_closed,
-        output_end_reason = excluded.output_end_reason,
-        input_closed = excluded.input_closed,
-        effective_limits_json = excluded.effective_limits_json,
-        start_request_id = excluded.start_request_id
-    `);
-        const createdAt = process.createdAt ?? new Date().toISOString();
-        const ctrlState = process.controlState ?? process.control ?? null;
-        const ioConfigJson = process.ioConfig !== undefined ? JSON.stringify(process.ioConfig) : null;
-        const capabilitiesJson = process.capabilities !== undefined ? JSON.stringify(process.capabilities) : null;
-        const effectiveLimitsJson = process.effectiveLimits !== undefined ? JSON.stringify(process.effectiveLimits) : null;
-        const outputClosed = process.outputClosed ? 1 : 0;
-        const inputClosed = process.inputClosed ? 1 : 0;
-        stmt.run(process.processId, process.tenantId, process.principalId, process.packageInstanceId, process.generationId, process.hostEpoch, process.state, ctrlState, ioConfigJson, capabilitiesJson, createdAt, process.exitCode !== undefined && process.exitCode !== null ? process.exitCode : null, process.exitSignal !== undefined ? process.exitSignal : null, process.endReason !== undefined ? process.endReason : null, outputClosed, process.outputEndReason !== undefined ? process.outputEndReason : null, inputClosed, effectiveLimitsJson, process.startRequestId !== undefined ? process.startRequestId : null);
-    }
-    async getProcess(processId) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const stmt = this.getStatement("SELECT * FROM managed_processes WHERE process_id = ?");
-        const row = stmt.get(processId);
-        if (!row) {
-            return undefined;
-        }
-        return mapRowToStoredProcess(row);
-    }
-    async listProcesses(owner, pageToken, limit) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const actualLimit = typeof limit === "number" && limit > 0 ? limit : 50;
-        const offset = parsePageToken(pageToken);
-        const stmt = this.getStatement(`
-      SELECT * FROM managed_processes
-      WHERE tenant_id = ? AND principal_id = ? AND package_instance_id = ? AND generation_id = ?
-      ORDER BY created_at DESC, process_id ASC
-      LIMIT ? OFFSET ?
-    `);
-        const rows = stmt.all(owner.tenantId, owner.principalId, owner.packageInstanceId, owner.generationId, actualLimit + 1, offset);
-        const hasMore = rows.length > actualLimit;
-        const resultRows = hasMore ? rows.slice(0, actualLimit) : rows;
-        const processes = resultRows.map(mapRowToStoredProcess);
-        const nextPageToken = hasMore ? String(offset + actualLimit) : undefined;
-        return { processes, nextPageToken };
-    }
-    async updateProcessState(processId, patch) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const sets = [];
-        const params = [];
-        if (patch.state !== undefined) {
-            sets.push("state = ?");
-            params.push(patch.state);
-        }
-        const ctrl = patch.controlState !== undefined ? patch.controlState : patch.control;
-        if (ctrl !== undefined) {
-            sets.push("control_state = ?");
-            params.push(ctrl);
-        }
-        if (patch.exitCode !== undefined) {
-            sets.push("exit_code = ?");
-            params.push(patch.exitCode !== null ? patch.exitCode : null);
-        }
-        if (patch.exitSignal !== undefined) {
-            sets.push("exit_signal = ?");
-            params.push(patch.exitSignal);
-        }
-        if (patch.endReason !== undefined) {
-            sets.push("end_reason = ?");
-            params.push(patch.endReason);
-        }
-        if (patch.outputClosed !== undefined) {
-            sets.push("output_closed = ?");
-            params.push(patch.outputClosed ? 1 : 0);
-        }
-        if (patch.outputEndReason !== undefined) {
-            sets.push("output_end_reason = ?");
-            params.push(patch.outputEndReason);
-        }
-        if (patch.inputClosed !== undefined) {
-            sets.push("input_closed = ?");
-            params.push(patch.inputClosed ? 1 : 0);
-        }
-        if (patch.effectiveLimits !== undefined) {
-            sets.push("effective_limits_json = ?");
-            params.push(patch.effectiveLimits !== null ? JSON.stringify(patch.effectiveLimits) : null);
-        }
-        if (patch.ioConfig !== undefined) {
-            sets.push("io_config_json = ?");
-            params.push(patch.ioConfig !== null ? JSON.stringify(patch.ioConfig) : null);
-        }
-        if (patch.capabilities !== undefined) {
-            sets.push("capabilities_json = ?");
-            params.push(patch.capabilities !== null ? JSON.stringify(patch.capabilities) : null);
-        }
-        if (patch.hostEpoch !== undefined) {
-            sets.push("host_epoch = ?");
-            params.push(patch.hostEpoch);
-        }
-        if (sets.length === 0) {
-            return;
-        }
-        params.push(processId);
-        const sql = `UPDATE managed_processes SET ${sets.join(", ")} WHERE process_id = ?`;
-        const stmt = this.getStatement(sql);
-        const res = stmt.run(...params);
-        if (res.changes === 0) {
-            throw new Error(`Process '${processId}' not found`);
-        }
-    }
-    async recordRequest(key, receipt, payloadHash) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const stmt = this.getStatement(`
-      INSERT INTO process_requests (
-        host_epoch, scope, process_id, request_id, receipt_json, payload_hash, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(host_epoch, scope, process_id, request_id) DO UPDATE SET
-        receipt_json = excluded.receipt_json,
-        payload_hash = excluded.payload_hash,
-        created_at = excluded.created_at
-    `);
-        const processId = key.processId ?? "";
-        const receiptJson = JSON.stringify(receipt);
-        const createdAt = new Date().toISOString();
-        stmt.run(key.hostEpoch, key.scope, processId, key.requestId, receiptJson, payloadHash ?? null, createdAt);
-    }
-    async getRequest(key) {
-        if (this.isClosed) {
-            throw new Error("SqliteProcessMetadataStore is closed");
-        }
-        const stmt = this.getStatement(`
-      SELECT receipt_json, payload_hash FROM process_requests
-      WHERE host_epoch = ? AND scope = ? AND process_id = ? AND request_id = ?
-    `);
-        const processId = key.processId ?? "";
-        const row = stmt.get(key.hostEpoch, key.scope, processId, key.requestId);
-        if (!row) {
-            return undefined;
-        }
-        return {
-            receipt: JSON.parse(row.receipt_json),
-            payloadHash: row.payload_hash ?? undefined,
-        };
-    }
-    async initializeHost(hostEpoch) {
-        if (this.isClosed) {
-            return 0;
-        }
-        const stmt = this.getStatement(`
-      UPDATE managed_processes
-      SET state = 'lost',
-          control_state = 'closed',
-          end_reason = 'host-lost',
-          output_closed = 1,
-          output_end_reason = 'host-lost'
-      WHERE host_epoch != ?
-        AND state IN ('starting', 'running', 'stopping')
-    `);
-        const res = stmt.run(hostEpoch);
-        return res.changes;
-    }
-    close() {
-        if (this.isClosed) {
-            return;
-        }
-        this.isClosed = true;
-        this.statementCache.clear();
-        this.driver.close();
-    }
-}