@actiondock/core 2.6.0 → 2.8.0

package/dist/input/utf8.d.ts

@@ -0,0 +1,19 @@
+import type { InputValidationSource } from "./flat-errors.js";
+/**
+ * 校验并严格解码字节序列为合法 UTF-8 字符串。
+ * 使用 TextDecoder("utf-8", { fatal: true }) 拦截非法编码字节并抛出结构化 INVALID_JSON 异常。
+ *
+ * @param bytes 待解码的原始字节数据
+ * @param source 输入校验来源（默认为 full-json-inline）
+ * @returns 解码后的 UTF-8 文本
+ * @throws InputError 当包含非法 UTF-8 字节序列时抛出 INVALID_JSON 异常
+ */
+export declare function decodeUtf8Strict(bytes: Uint8Array | Buffer, source?: InputValidationSource): string;
+/**
+ * 仅剥离输入字符串起始处的恰好一个 U+FEFF BOM。
+ * 若存在双重 BOM（\uFEFF\uFEFF），仅剥离首个，第二个保留给后续 JSON 解析器以触发 SYNTAX_ERROR。
+ *
+ * @param text 原始输入文本
+ * @returns 剥离首个 BOM 后的文本
+ */
+export declare function stripBom(text: string): string;

package/dist/input/utf8.js

@@ -0,0 +1,36 @@
+import { mapInputValidationFailure } from "./validation-mapper.js";
+/**
+ * 校验并严格解码字节序列为合法 UTF-8 字符串。
+ * 使用 TextDecoder("utf-8", { fatal: true }) 拦截非法编码字节并抛出结构化 INVALID_JSON 异常。
+ *
+ * @param bytes 待解码的原始字节数据
+ * @param source 输入校验来源（默认为 full-json-inline）
+ * @returns 解码后的 UTF-8 文本
+ * @throws InputError 当包含非法 UTF-8 字节序列时抛出 INVALID_JSON 异常
+ */
+export function decodeUtf8Strict(bytes, source = "full-json-inline") {
+    try {
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        return decoder.decode(bytes);
+    }
+    catch (err) {
+        throw mapInputValidationFailure(source, {
+            valid: false,
+            code: "INVALID_UTF8",
+            reason: `Invalid UTF-8 encoding: ${err instanceof Error ? err.message : String(err)}`,
+        });
+    }
+}
+/**
+ * 仅剥离输入字符串起始处的恰好一个 U+FEFF BOM。
+ * 若存在双重 BOM（\uFEFF\uFEFF），仅剥离首个，第二个保留给后续 JSON 解析器以触发 SYNTAX_ERROR。
+ *
+ * @param text 原始输入文本
+ * @returns 剥离首个 BOM 后的文本
+ */
+export function stripBom(text) {
+    if (text.charCodeAt(0) === 0xfeff) {
+        return text.slice(1);
+    }
+    return text;
+}

package/dist/input/validation-mapper.d.ts

@@ -0,0 +1,27 @@
+import { InputError, type InputValidationSource } from "./flat-errors.js";
+import type { ActionInputValidationResult, JsonValueValidationResult } from "../json/value-validator.js";
+/**
+ * 校验失败结构化输入描述。
+ */
+export type ValidationFailureInput = Exclude<ActionInputValidationResult, {
+    valid: true;
+}> | Exclude<JsonValueValidationResult, {
+    valid: true;
+}> | {
+    valid: false;
+    kind?: "json-value" | "input-policy";
+    code: string;
+    reason: string;
+    path?: string;
+    property?: string;
+    [key: string]: unknown;
+};
+/**
+ * 将校验失败结果根据输入来源映射为统一结构化异常。
+ * 遵循技术设计文档第 19 节 Mapping Table 规范。
+ *
+ * @param source 输入校验来源
+ * @param result 校验失败结果对象
+ * @returns 映射后的结构化输入异常
+ */
+export declare function mapInputValidationFailure(source: InputValidationSource, result: ActionInputValidationResult | JsonValueValidationResult | ValidationFailureInput): InputError;

package/dist/input/validation-mapper.js

@@ -0,0 +1,144 @@
+import { INPUT_NOT_JSON, INPUT_VALIDATION_FAILED, } from "../errors.js";
+import { InputError, invalidJson, invalidJsonLiteral, flatInputLimitExceeded, inputLimitExceeded, inputPolicyViolation, } from "./flat-errors.js";
+/**
+ * 将校验失败结果根据输入来源映射为统一结构化异常。
+ * 遵循技术设计文档第 19 节 Mapping Table 规范。
+ *
+ * @param source 输入校验来源
+ * @param result 校验失败结果对象
+ * @returns 映射后的结构化输入异常
+ */
+export function mapInputValidationFailure(source, result) {
+    const failure = result;
+    const code = failure.code;
+    const reason = failure.reason;
+    const path = failure.path;
+    const isPolicyViolation = failure.kind === "input-policy" || code === "FORBIDDEN_PROPERTY";
+    switch (source) {
+        case "flat-json-literal": {
+            if (code === "SYNTAX_ERROR") {
+                return invalidJsonLiteral(reason || "Invalid JSON literal syntax", {
+                    reason: "SYNTAX_ERROR",
+                    path,
+                });
+            }
+            if (code === "NON_FINITE_NUMBER") {
+                return invalidJsonLiteral(reason || "Non-finite number in JSON literal", {
+                    reason: "NON_FINITE_NUMBER",
+                    path,
+                });
+            }
+            if (code === "MAX_JSON_DEPTH") {
+                return invalidJsonLiteral(reason || "Max JSON depth limit exceeded in JSON literal", {
+                    reason: "MAX_JSON_DEPTH",
+                    path,
+                });
+            }
+            return invalidJsonLiteral(reason || "Invalid JSON literal value", {
+                reason: "INVALID_JSON_VALUE",
+                path,
+            });
+        }
+        case "full-json-inline":
+        case "full-json-file":
+        case "full-json-stdin": {
+            const cliSource = source === "full-json-inline"
+                ? "inline-json"
+                : source === "full-json-file"
+                    ? "file"
+                    : "stdin";
+            if (code === "SYNTAX_ERROR") {
+                return invalidJson(reason || "Invalid JSON syntax", {
+                    reason: "SYNTAX_ERROR",
+                    source: cliSource,
+                    path,
+                });
+            }
+            if (code === "INVALID_UTF8") {
+                return invalidJson(reason || "Invalid UTF-8 encoding in JSON input", {
+                    reason: "INVALID_UTF8",
+                    source: cliSource,
+                    path,
+                });
+            }
+            if (code === "NON_FINITE_NUMBER") {
+                return invalidJson(reason || "Number is non-finite or NaN", {
+                    reason: "NON_FINITE_NUMBER",
+                    source: cliSource,
+                    path,
+                });
+            }
+            if (code === "MAX_JSON_DEPTH") {
+                return invalidJson(reason || "Max JSON depth limit exceeded", {
+                    reason: "MAX_JSON_DEPTH",
+                    source: cliSource,
+                    path,
+                });
+            }
+            return invalidJson(reason || "Invalid JSON value", {
+                reason: "INVALID_JSON_VALUE",
+                source: cliSource,
+                path,
+            });
+        }
+        case "flat-materialized": {
+            if (code === "MAX_JSON_DEPTH") {
+                return flatInputLimitExceeded(reason || "Materialized JSON depth limit exceeded", {
+                    reason: "MAX_MATERIALIZED_JSON_DEPTH",
+                    path,
+                });
+            }
+            if (code === "MAX_MATERIALIZED_BYTES") {
+                return flatInputLimitExceeded(reason || "Materialized input size exceeds limit", {
+                    reason: "MAX_MATERIALIZED_BYTES",
+                    path,
+                });
+            }
+            return flatInputLimitExceeded(reason || "Materialized input validation failed", {
+                reason: "INVALID_JSON_VALUE",
+                path,
+            });
+        }
+        case "cli-pre-target": {
+            if (isPolicyViolation) {
+                const property = failure.property;
+                return inputPolicyViolation(reason || `Forbidden property "${property}" is not allowed in Action input`, {
+                    reason: "FORBIDDEN_PROPERTY",
+                    property,
+                    path,
+                });
+            }
+            if (code === "MAX_JSON_DEPTH") {
+                return inputLimitExceeded(reason || "Max JSON depth limit exceeded", {
+                    reason: "MAX_JSON_DEPTH",
+                    path,
+                });
+            }
+            if (code === "NON_FINITE_NUMBER") {
+                return invalidJson(reason || "Number is non-finite or NaN", {
+                    reason: "NON_FINITE_NUMBER",
+                    path,
+                });
+            }
+            return invalidJson(reason || "Invalid JSON value in Action input", {
+                reason: "INVALID_JSON_VALUE",
+                path,
+            });
+        }
+        case "runtime": {
+            if (isPolicyViolation) {
+                return new InputError(INPUT_VALIDATION_FAILED, reason || "Action input contains forbidden property", [reason || "Forbidden property in input"]);
+            }
+            return new InputError(INPUT_NOT_JSON, reason || "Input is not a valid JSON value", {
+                reason: code,
+                path,
+            });
+        }
+        default: {
+            return new InputError(INPUT_NOT_JSON, reason || "Input validation failed", {
+                reason: code,
+                path,
+            });
+        }
+    }
+}

package/dist/invocation/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./policy.js";

package/dist/invocation/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./policy.js";

package/dist/invocation/policy.d.ts

@@ -0,0 +1,157 @@
+import { type ErrorCode } from "../errors.js";
+import type { PackageGraph } from "../catalog/graph.js";
+/**
+ * 调用治理策略初始化选项。
+ */
+export interface InvocationPolicyOptions {
+    /** 最大调用嵌套深度限制（默认 16） */
+    maxCallDepth?: number;
+    /** 单个根任务下最大并发活跃子任务数（默认 64） */
+    maxSubRuns?: number;
+}
+/**
+ * 根调用可见性上下文。
+ */
+export interface RootVisibilityContext {
+    /** 宿主公开暴露的包标识集合 */
+    hostPublicPackageIds: ReadonlySet<string>;
+    /** 包依赖拓扑图 */
+    graph?: PackageGraph;
+}
+/**
+ * 调用方声明规范契约。
+ */
+export interface CallerActionInfo {
+    packageId: string;
+    actionId: string;
+    declaredUses?: string[];
+}
+/**
+ * 目标 Action 规范契约。
+ */
+export interface TargetActionInfo {
+    packageId: string;
+    actionId: string;
+}
+/**
+ * 调用治理策略错误描述。
+ */
+export interface PolicyError {
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * 环路检测结果。
+ */
+export interface CycleCheckResult {
+    callKey: string;
+    error?: PolicyError;
+}
+/**
+ * 全局统一调用治理策略服务（InvocationPolicy）。
+ *
+ * 铁律 5 单一事实源：统一负责 root visibility、caller -> callee authorization、
+ * uses 检查、max call depth、cycle detection、subrun quota 与 lineage policy。
+ * 彻底消除 Host、ExecutionService 与 ActionRunner 中分散重复的检查逻辑。
+ */
+export declare class InvocationPolicy {
+    readonly maxCallDepth: number;
+    readonly maxSubRuns: number;
+    private readonly activeSubRunsPerRoot;
+    private visibilityContext?;
+    constructor(options?: InvocationPolicyOptions);
+    /**
+     * 设置路由可见性上下文。
+     */
+    setVisibilityContext(context?: RootVisibilityContext): void;
+    /**
+     * 严格断言根调用可见性（Root Visibility Assertion）。
+     * 若不可见则抛出 ActionDockError(UNDECLARED_ACTION_DEPENDENCY, ...)。
+     */
+    assertRootVisibility(resolved: {
+        package: {
+            id: string;
+        };
+        ref: {
+            actionId: string;
+        };
+    }, context?: RootVisibilityContext): void;
+    /**
+     * 根调用可见性判定与鉴权（Root Visibility Policy）。
+     *
+     * 判定规则：
+     * - 宿主公开注册的包（直接依赖包或显式声明包）允许根调用；
+     * - 传递依赖包必须经由可见 Playbook 委托授权，否则拦截并返回 UNDECLARED_ACTION_DEPENDENCY。
+     *
+     * @param targetPackageId 目标包标识
+     * @param targetActionId 目标 Action 标识
+     * @param context 路由可见性上下文
+     * @returns 若拦截返回标准 RuntimeError，通过则返回 undefined
+     */
+    checkRootVisibility(targetPackageId: string, targetActionId: string, context: RootVisibilityContext): PolicyError | undefined;
+    /**
+     * 调用方至目标动作 uses 依赖声明授权校验（Caller -> Callee Authorization & Uses Policy）。
+     *
+     * 判定规则：
+     * - 同包内部 Action 互调自然合法，豁免 uses 声明；
+     * - 跨包调用必须在调用方 Action 的 uses 声明列表中显式声明目标（完全限定名、通配符或包名），
+     *   或经由 PackageGraph.canCascadeCall 裁决通过；未声明直接拦截。
+     *
+     * @param caller 调用方 Action 标识与声明上下文
+     * @param target 目标 Action 标识
+     * @param graph 可选的包依赖拓扑图
+     * @returns 若鉴权未通过返回标准 RuntimeError，通过则返回 undefined
+     */
+    checkUsesAuthorization(caller: CallerActionInfo, target: TargetActionInfo, graph?: PackageGraph): PolicyError | undefined;
+    /**
+     * 调用嵌套最大深度限制校验（Max Call Depth Policy）。
+     *
+     * 超限时返回标准 ACTION_CALL_CYCLE 错误。
+     *
+     * @param callStack 当前已累积的调用栈切片
+     * @param targetActionId 欲调用的目标 Action 标识
+     * @param maxDepthOverride 临时执行覆盖的最大深度限制
+     * @returns 超限错误或 undefined
+     */
+    checkCallDepth(callStack: readonly string[], targetActionId: string, maxDepthOverride?: number): PolicyError | undefined;
+    /**
+     * 调用链环路死锁检测（Cycle Detection Policy）。
+     *
+     * 计算目标调用键并在历史调用栈中执行检测，杜绝 A -> B -> A 形成死锁。
+     * 命中环路时返回 ACTION_CALL_CYCLE 错误。
+     *
+     * @param callStack 当前已累积的调用栈切片
+     * @param targetActionId 欲调用的目标 Action 标识
+     * @param targetPackageId 目标 Action 所属包标识
+     * @param currentPackageId 当前执行发起方包标识
+     * @returns 包含规范化 callKey 与可选错误的结构体
+     */
+    checkCycle(callStack: readonly string[], targetActionId: string, targetPackageId?: string, currentPackageId?: string): CycleCheckResult;
+    /**
+     * 并发活跃子任务配额检查（Sub-Run Quota Policy）。
+     *
+     * 针对同源 rootRunId 限制派生的并发子任务上限，防止资源耗尽。
+     *
+     * @param rootRunId 根运行标识符
+     * @returns 超限错误或 undefined
+     */
+    checkSubRunQuota(rootRunId: string): PolicyError | undefined;
+    /**
+     * 申请子任务并发配额槽位。
+     *
+     * @param rootRunId 根运行标识符
+     * @returns 是否成功获取槽位（若已达上限返回 false）
+     */
+    acquireSubRun(rootRunId: string): boolean;
+    /**
+     * 释放已申请的子任务并发配额槽位。
+     *
+     * @param rootRunId 根运行标识符
+     */
+    releaseSubRun(rootRunId: string): void;
+    /**
+     * 获取指定根运行当前的活跃并发子任务计数。
+     */
+    getActiveSubRuns(rootRunId: string): number;
+}

package/dist/invocation/policy.js

@@ -0,0 +1,231 @@
+import { ACTION_CALL_CYCLE, ACTION_SUBRUN_LIMIT, UNDECLARED_ACTION_DEPENDENCY, ActionDockError, } from "../errors.js";
+import { isUsesDeclared } from "../catalog/graph.js";
+/**
+ * 全局统一调用治理策略服务（InvocationPolicy）。
+ *
+ * 铁律 5 单一事实源：统一负责 root visibility、caller -> callee authorization、
+ * uses 检查、max call depth、cycle detection、subrun quota 与 lineage policy。
+ * 彻底消除 Host、ExecutionService 与 ActionRunner 中分散重复的检查逻辑。
+ */
+export class InvocationPolicy {
+    maxCallDepth;
+    maxSubRuns;
+    activeSubRunsPerRoot = new Map();
+    visibilityContext;
+    constructor(options = {}) {
+        this.maxCallDepth = options.maxCallDepth ?? 16;
+        this.maxSubRuns = options.maxSubRuns ?? 64;
+    }
+    /**
+     * 设置路由可见性上下文。
+     */
+    setVisibilityContext(context) {
+        this.visibilityContext = context;
+    }
+    /**
+     * 严格断言根调用可见性（Root Visibility Assertion）。
+     * 若不可见则抛出 ActionDockError(UNDECLARED_ACTION_DEPENDENCY, ...)。
+     */
+    assertRootVisibility(resolved, context) {
+        const ctx = context ?? this.visibilityContext;
+        if (!ctx) {
+            return;
+        }
+        const error = this.checkRootVisibility(resolved.package.id, resolved.ref.actionId, ctx);
+        if (error) {
+            throw new ActionDockError(error.code, error.message, error.details);
+        }
+    }
+    /**
+     * 根调用可见性判定与鉴权（Root Visibility Policy）。
+     *
+     * 判定规则：
+     * - 宿主公开注册的包（直接依赖包或显式声明包）允许根调用；
+     * - 传递依赖包必须经由可见 Playbook 委托授权，否则拦截并返回 UNDECLARED_ACTION_DEPENDENCY。
+     *
+     * @param targetPackageId 目标包标识
+     * @param targetActionId 目标 Action 标识
+     * @param context 路由可见性上下文
+     * @returns 若拦截返回标准 RuntimeError，通过则返回 undefined
+     */
+    checkRootVisibility(targetPackageId, targetActionId, context) {
+        const isPublic = context.hostPublicPackageIds.has(targetPackageId);
+        if (isPublic) {
+            return undefined;
+        }
+        if (context.graph && !context.graph.canRootCall(targetPackageId, targetActionId)) {
+            return {
+                code: UNDECLARED_ACTION_DEPENDENCY,
+                message: `Root call to action '${targetPackageId}/${targetActionId}' is not allowed: package '${targetPackageId}' is not declared as a direct dependency in actiondock.json and is not delegated by a visible playbook`,
+                details: { target: `${targetPackageId}/${targetActionId}` },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * 调用方至目标动作 uses 依赖声明授权校验（Caller -> Callee Authorization & Uses Policy）。
+     *
+     * 判定规则：
+     * - 同包内部 Action 互调自然合法，豁免 uses 声明；
+     * - 跨包调用必须在调用方 Action 的 uses 声明列表中显式声明目标（完全限定名、通配符或包名），
+     *   或经由 PackageGraph.canCascadeCall 裁决通过；未声明直接拦截。
+     *
+     * @param caller 调用方 Action 标识与声明上下文
+     * @param target 目标 Action 标识
+     * @param graph 可选的包依赖拓扑图
+     * @returns 若鉴权未通过返回标准 RuntimeError，通过则返回 undefined
+     */
+    checkUsesAuthorization(caller, target, graph) {
+        // 同包调用完全自由开放，不作限制
+        if (!caller.packageId || !target.packageId || caller.packageId === target.packageId) {
+            return undefined;
+        }
+        const targetRef = `${target.packageId}/${target.actionId}`;
+        const callerNode = graph?.getNode(caller.packageId);
+        const shortActionId = caller.actionId.includes("/")
+            ? caller.actionId.split("/").pop()
+            : caller.actionId;
+        const usesList = caller.declaredUses ||
+            callerNode?.manifest?.actions?.[shortActionId]?.uses ||
+            callerNode?.manifest?.actions?.[caller.actionId]?.uses ||
+            [];
+        const isAllowed = graph
+            ? graph.canCascadeCall(caller.packageId, caller.actionId, target.packageId, target.actionId)
+            : usesList.some((u) => isUsesDeclared(u, target.packageId, target.actionId));
+        if (!isAllowed) {
+            return {
+                code: UNDECLARED_ACTION_DEPENDENCY,
+                message: `Undeclared cross-package dependency: Action '${caller.packageId}/${caller.actionId}' does not declare dependency on '${targetRef}' in 'uses'`,
+                details: {
+                    caller: `${caller.packageId}/${caller.actionId}`,
+                    target: targetRef,
+                    declaredUses: usesList,
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * 调用嵌套最大深度限制校验（Max Call Depth Policy）。
+     *
+     * 超限时返回标准 ACTION_CALL_CYCLE 错误。
+     *
+     * @param callStack 当前已累积的调用栈切片
+     * @param targetActionId 欲调用的目标 Action 标识
+     * @param maxDepthOverride 临时执行覆盖的最大深度限制
+     * @returns 超限错误或 undefined
+     */
+    checkCallDepth(callStack, targetActionId, maxDepthOverride) {
+        const limit = maxDepthOverride ?? this.maxCallDepth;
+        if (callStack.length >= limit) {
+            return {
+                code: ACTION_CALL_CYCLE,
+                message: `Maximum call depth of ${limit} exceeded: ${callStack.join(" -> ")} -> ${targetActionId}`,
+                details: {
+                    reason: "depth_exceeded",
+                    maxDepth: limit,
+                    callStack: [...callStack],
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * 调用链环路死锁检测（Cycle Detection Policy）。
+     *
+     * 计算目标调用键并在历史调用栈中执行检测，杜绝 A -> B -> A 形成死锁。
+     * 命中环路时返回 ACTION_CALL_CYCLE 错误。
+     *
+     * @param callStack 当前已累积的调用栈切片
+     * @param targetActionId 欲调用的目标 Action 标识
+     * @param targetPackageId 目标 Action 所属包标识
+     * @param currentPackageId 当前执行发起方包标识
+     * @returns 包含规范化 callKey 与可选错误的结构体
+     */
+    checkCycle(callStack, targetActionId, targetPackageId, currentPackageId) {
+        const isExternal = Boolean(targetPackageId && currentPackageId && targetPackageId !== currentPackageId);
+        const callKey = targetPackageId
+            ? `${targetPackageId}/${targetActionId}`
+            : targetActionId;
+        let hasCycle = false;
+        if (isExternal) {
+            hasCycle = callStack.includes(callKey);
+        }
+        else {
+            hasCycle =
+                callStack.includes(callKey) ||
+                    callStack.includes(targetActionId) ||
+                    (targetPackageId ? callStack.includes(`${targetPackageId}/${targetActionId}`) : false);
+        }
+        if (hasCycle) {
+            return {
+                callKey,
+                error: {
+                    code: ACTION_CALL_CYCLE,
+                    message: `Cycle detected in action invocation: ${callStack.join(" -> ")} -> ${callKey}`,
+                    details: {
+                        reason: "cycle_detected",
+                        callStack: [...callStack],
+                        target: callKey,
+                    },
+                },
+            };
+        }
+        return { callKey };
+    }
+    /**
+     * 并发活跃子任务配额检查（Sub-Run Quota Policy）。
+     *
+     * 针对同源 rootRunId 限制派生的并发子任务上限，防止资源耗尽。
+     *
+     * @param rootRunId 根运行标识符
+     * @returns 超限错误或 undefined
+     */
+    checkSubRunQuota(rootRunId) {
+        const current = this.activeSubRunsPerRoot.get(rootRunId) || 0;
+        if (current >= this.maxSubRuns) {
+            return {
+                code: ACTION_SUBRUN_LIMIT,
+                message: `Maximum concurrent sub-runs (${this.maxSubRuns}) reached for root run '${rootRunId}'`,
+                details: {
+                    limit: this.maxSubRuns,
+                },
+            };
+        }
+        return undefined;
+    }
+    /**
+     * 申请子任务并发配额槽位。
+     *
+     * @param rootRunId 根运行标识符
+     * @returns 是否成功获取槽位（若已达上限返回 false）
+     */
+    acquireSubRun(rootRunId) {
+        const current = this.activeSubRunsPerRoot.get(rootRunId) || 0;
+        if (current >= this.maxSubRuns) {
+            return false;
+        }
+        this.activeSubRunsPerRoot.set(rootRunId, current + 1);
+        return true;
+    }
+    /**
+     * 释放已申请的子任务并发配额槽位。
+     *
+     * @param rootRunId 根运行标识符
+     */
+    releaseSubRun(rootRunId) {
+        const current = this.activeSubRunsPerRoot.get(rootRunId) || 1;
+        if (current <= 1) {
+            this.activeSubRunsPerRoot.delete(rootRunId);
+        }
+        else {
+            this.activeSubRunsPerRoot.set(rootRunId, current - 1);
+        }
+    }
+    /**
+     * 获取指定根运行当前的活跃并发子任务计数。
+     */
+    getActiveSubRuns(rootRunId) {
+        return this.activeSubRunsPerRoot.get(rootRunId) || 0;
+    }
+}