@actiondock/core 2.13.0 → 2.14.0

package/dist/catalog/graph.d.ts

@@ -6,10 +6,6 @@ import { parseSemVer, type SemVer } from "../utils/index.js";
 import { type DiscoveredPackage, type PackageDiscoveryOptions } from "./discovery.js";
 export type { SemVer };
 export { parseSemVer };
-/**
- * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
- * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
- */
 export declare function areVersionsCompatible(v1: string, v2: string): boolean;
 /**
  * 版本冲突错误。
@@ -145,6 +141,8 @@ export declare class DefaultPackageGraph implements PackageGraph {
 export interface PackageGraphBuilderOptions {
     /** 预先发现的包集合，若未提供则通过 PackageDiscovery 自动发现 */
     packages?: DiscoveredPackage[];
+    /** 完整显式集合的依赖存在性与选定版本校验（Host 增量注册时不启用）。 */
+    validateDependencies?: boolean;
     /** 根工程根目录或根包标识（与 projectRoot 互为别名） */
     root?: string;
     /** 当前工程根目录绝对或相对物理路径 */

package/dist/catalog/graph.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
+import { ActionDockError, ACTION_PACKAGE_VERSION_CONFLICT, MANIFEST_DIGEST_MISMATCH, MANIFEST_NOT_FOUND, MANIFEST_READ_FAILED, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, INVALID_ARGUMENT, UNDECLARED_ACTION_DEPENDENCY, } from "../errors.js";
 import { computeManifestDigest, parseJsonWithoutDuplicates } from "../project/digest.js";
 import { loadLockfile } from "../project/lockfile.js";
 import { loadPlaybooks, loadProjectConfig } from "../project/loader.js";
@@ -10,30 +10,124 @@ import { createPackageIdentity } from "../runtime/identity.js";
 import { parseSemVer } from "../utils/index.js";
 import { PackageDiscovery } from "./discovery.js";
 export { parseSemVer };
-/**
- * 校验两个语义化版本范围是否兼容并能收敛为单一解析版本。
- * 遵循设计规范：直接或传递版本范围无法收敛时拒绝并抛出 ACTION_PACKAGE_VERSION_CONFLICT。
- */
-export function areVersionsCompatible(v1, v2) {
-    if (v1 === v2 || v1 === "*" || v2 === "*" || !v1 || !v2) {
-        return true;
+/** 有限版本契约：严格三段版本（允许 v/= 前缀）、^、~、*；不猜测其他范围。 */
+function parseVersionRange(value) {
+    const text = value.trim();
+    if (!text || text === "*")
+        return {};
+    const prefix = text[0];
+    const minimum = parseSemVer(prefix === "^" || prefix === "~" ? text.slice(1) : text);
+    if (!minimum)
+        return undefined;
+    if (prefix !== "^" && prefix !== "~")
+        return { minimum, exact: true };
+    const maximum = prefix === "~"
+        ? { major: minimum.major, minor: minimum.minor + 1, patch: 0 }
+        : minimum.major > 0 ? { major: minimum.major + 1, minor: 0, patch: 0 }
+            : minimum.minor > 0 ? { major: 0, minor: minimum.minor + 1, patch: 0 }
+                : { major: 0, minor: 0, patch: minimum.patch + 1 };
+    return { minimum, maximum };
+}
+function compareVersions(a, b) {
+    const core = a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+    if (core)
+        return core;
+    if (a.prerelease === b.prerelease)
+        return 0;
+    if (a.prerelease === undefined)
+        return 1;
+    if (b.prerelease === undefined)
+        return -1;
+    const left = a.prerelease.split(".");
+    const right = b.prerelease.split(".");
+    for (let i = 0; i < Math.max(left.length, right.length); i++) {
+        if (left[i] === undefined)
+            return -1;
+        if (right[i] === undefined)
+            return 1;
+        if (left[i] === right[i])
+            continue;
+        const numericLeft = /^\d+$/.test(left[i]);
+        const numericRight = /^\d+$/.test(right[i]);
+        if (numericLeft && numericRight)
+            return BigInt(left[i]) < BigInt(right[i]) ? -1 : 1;
+        if (numericLeft !== numericRight)
+            return numericLeft ? -1 : 1;
+        return left[i] < right[i] ? -1 : 1;
     }
-    const clean1 = v1.trim().replace(/^[\^~=]/, "");
-    const clean2 = v2.trim().replace(/^[\^~=]/, "");
-    const sem1 = parseSemVer(clean1);
-    const sem2 = parseSemVer(clean2);
-    if (!sem1 || !sem2) {
-        return v1 === v2;
+    return 0;
+}
+function satisfiesRange(version, range) {
+    if (range.exact)
+        return compareVersions(version, range.minimum) === 0;
+    if (range.minimum && compareVersions(version, range.minimum) < 0)
+        return false;
+    if (range.maximum && compareVersions(version, range.maximum) >= 0)
+        return false;
+    // 预发布版本仅在范围下界显式点名同一核心版本的预发布时纳入。
+    if (version.prerelease !== undefined) {
+        const min = range.minimum;
+        return Boolean(min?.prerelease && version.major === min.major && version.minor === min.minor && version.patch === min.patch);
     }
-    if (sem1.major !== sem2.major) {
+    return true;
+}
+export function areVersionsCompatible(v1, v2) {
+    const left = parseVersionRange(v1);
+    const right = parseVersionRange(v2);
+    if (!left || !right)
+        return false;
+    const candidate = !left.minimum ? right.minimum : !right.minimum ? left.minimum
+        : compareVersions(left.minimum, right.minimum) >= 0 ? left.minimum : right.minimum;
+    if (!candidate)
+        return true;
+    if (satisfiesRange(candidate, left) && satisfiesRange(candidate, right))
+        return true;
+    // 两个范围可以在预发布下界之后的稳定版本交汇，但不能改变精确版本。
+    const stable = { major: candidate.major, minor: candidate.minor, patch: candidate.patch };
+    return satisfiesRange(stable, left) && satisfiesRange(stable, right);
+}
+/**
+ * 判定给定的依赖规格是否为不支持的语义化版本范围形态（而非获取描述）。
+ *
+ * 规则：
+ * - 范围操作符开头：^, ~, <, >, =, *；
+ * - 复合范围操作符：|| 或 - 范围；
+ * - X 范围与通配：如 1.x, 1.2.x, 1.*, 1.2.*, v1.x 等；
+ * - 不完整两段或一段版本：如 1, 1.2, v1, v1.2 等；
+ * - 版本三段式开头但未被严格解析器支持的非法形态。
+ */
+function isUnsupportedVersionRange(spec) {
+    const text = spec.trim();
+    if (!text)
         return false;
+    if (/^[~^<>=*]/.test(text))
+        return true;
+    if (/\|\||\s+-\s+/.test(text))
+        return true;
+    if (/^v?\d+\.(?:[xX*]|\d+\.[xX*])(?:$|[-+])/.test(text))
+        return true;
+    if (/^v?\d+(?:\.\d+)?$/.test(text))
+        return true;
+    if (/^v?\d+\.\d+\.\d+/.test(text))
+        return true;
+    return false;
+}
+/** 获取描述不是版本约束；仅真实范围及锁定版本参与版本兼容校验。 */
+function dependencyVersionRequirements(spec, locked) {
+    const requirements = [];
+    const range = spec === undefined ? undefined : parseVersionRange(spec);
+    if (spec !== undefined && range)
+        requirements.push(spec);
+    else if (spec !== undefined && isUnsupportedVersionRange(spec)) {
+        throw new ActionDockError(INVALID_ARGUMENT, `Unsupported Action package version range '${spec}'; supported forms are exact versions, ^, ~ and *`);
     }
-    if (v1.startsWith("~") || v2.startsWith("~")) {
-        if (sem1.minor !== sem2.minor) {
-            return false;
-        }
+    const lockedVersion = locked?.resolved || locked?.version;
+    if (lockedVersion && parseSemVer(lockedVersion))
+        requirements.push(lockedVersion);
+    else if (lockedVersion) {
+        throw new ActionDockError(INVALID_ARGUMENT, `Invalid locked Action package version '${lockedVersion}'`);
     }
-    return true;
+    return requirements;
 }
 /**
  * 版本冲突错误。
@@ -280,6 +374,9 @@ export class PackageGraphBuilder {
      */
     buildFromPackages(nodes, generation) {
         for (const pkg of this.options.packages) {
+            if (nodes.has(pkg.id)) {
+                throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID '${pkg.id}' occurs more than once in explicit package graph`);
+            }
             const fields = createPackageNodeFields({
                 id: pkg.id,
                 root: pkg.root,
@@ -322,6 +419,39 @@ export class PackageGraphBuilder {
                 rootNode.isDirect = true;
             }
         }
+        if (this.options.validateDependencies) {
+            for (const node of nodes.values()) {
+                const lockfile = node.root ? loadLockfile(node.root) : null;
+                for (const [depId, spec] of Object.entries(node.manifest.dependencies || {})) {
+                    const dep = nodes.get(depId);
+                    if (!dep) {
+                        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${depId}' required by '${node.packageId}' is missing from explicit graph`);
+                    }
+                    for (const requirement of dependencyVersionRequirements(spec)) {
+                        if (!areVersionsCompatible(requirement, dep.version)) {
+                            throw new ActionPackageVersionConflictError(depId, [
+                                { requester: node.packageId, rangeOrVersion: requirement },
+                                { requester: depId, rangeOrVersion: dep.version },
+                            ]);
+                        }
+                    }
+                }
+                // 根锁文件也可能锁定传递依赖，不能只检查直接 dependencies。
+                for (const [depId, locked] of Object.entries(lockfile?.packages || {})) {
+                    const dep = nodes.get(depId);
+                    if (!dep)
+                        continue;
+                    for (const requirement of dependencyVersionRequirements(undefined, locked)) {
+                        if (!areVersionsCompatible(requirement, dep.version)) {
+                            throw new ActionPackageVersionConflictError(depId, [
+                                { requester: node.packageId, rangeOrVersion: requirement },
+                                { requester: depId, rangeOrVersion: dep.version },
+                            ]);
+                        }
+                    }
+                }
+            }
+        }
         linkDirectDependencies(nodes);
         computeTransitiveDependencies(nodes);
         const effectiveRootNode = rootIdentity ? nodes.get(rootIdentity.id) : undefined;
@@ -415,6 +545,13 @@ export class PackageGraphBuilder {
                     // 忽略扫描外部链接包异常
                 }
             }
+            const requesterLocks = new Map([[rootPackageId, lockfile]]);
+            const getRequesterLock = (requester) => {
+                if (!requesterLocks.has(requester)) {
+                    requesterLocks.set(requester, loadLockfile(nodes.get(requester).root));
+                }
+                return requesterLocks.get(requester);
+            };
             const versionRequirements = new Map();
             function recordRequirement(pkgId, requester, rangeOrVersion) {
                 const existing = versionRequirements.get(pkgId) || [];
@@ -429,10 +566,22 @@ export class PackageGraphBuilder {
                 existing.push({ requester, rangeOrVersion });
                 versionRequirements.set(pkgId, existing);
             }
+            const recordDependency = (pkgId, requester, spec) => {
+                const requesterLocked = getRequesterLock(requester)?.packages[pkgId];
+                for (const requirement of dependencyVersionRequirements(spec, requesterLocked)) {
+                    recordRequirement(pkgId, requester, requirement);
+                }
+                const rootLocked = lockfile?.packages[pkgId];
+                if (rootLocked && rootLocked !== requesterLocked) {
+                    for (const requirement of dependencyVersionRequirements(undefined, rootLocked)) {
+                        recordRequirement(pkgId, rootPackageId, requirement);
+                    }
+                }
+            };
             const queue = [];
             for (const [depId, spec] of Object.entries(rootManifest.dependencies || {})) {
                 rootNode.directDependencies.add(depId);
-                recordRequirement(depId, rootPackageId, spec);
+                recordDependency(depId, rootPackageId, spec);
                 queue.push({
                     pkgId: depId,
                     requester: rootPackageId,
@@ -460,7 +609,7 @@ export class PackageGraphBuilder {
                     continue;
                 }
                 let pkgDir = null;
-                const locked = lockfile?.packages?.[item.pkgId];
+                const locked = getRequesterLock(item.requester)?.packages[item.pkgId] || lockfile?.packages[item.pkgId];
                 if (packageRootsRecord?.[item.pkgId]) {
                     pkgDir = packageRootsRecord[item.pkgId];
                 }
@@ -474,7 +623,7 @@ export class PackageGraphBuilder {
                     }
                     candidateNames.push(item.rangeOrSpec);
                     candidateNames.push(item.pkgId);
-                    let cur = absProjectRoot;
+                    let cur = nodes.get(item.requester)?.root || absProjectRoot;
                     while (true) {
                         for (const candName of candidateNames) {
                             const candPath = join(cur, "node_modules", candName);
@@ -506,6 +655,9 @@ export class PackageGraphBuilder {
                     throw new ActionDockError(MANIFEST_READ_FAILED, `Failed to read manifest for '${item.pkgId}': ${err.message}`);
                 }
                 const depManifest = parseJsonWithoutDuplicates(manifestRaw);
+                if (depManifest.id !== item.pkgId) {
+                    throw new ActionDockError(PACKAGE_ID_CONFLICT, `Expected package '${item.pkgId}' at '${pkgDir}', found '${depManifest.id}'`);
+                }
                 const actualDigest = computeManifestDigest(depManifest);
                 if (locked?.manifestDigest && locked.manifestDigest !== actualDigest) {
                     throw new ActionDockError(MANIFEST_DIGEST_MISMATCH, `Manifest digest mismatch for package '${item.pkgId}': expected '${locked.manifestDigest}', got '${actualDigest}'. Re-resolution required.`);
@@ -538,15 +690,13 @@ export class PackageGraphBuilder {
                 };
                 nodes.set(item.pkgId, newNode);
                 for (const [subDepId, subSpec] of Object.entries(depManifest.dependencies || {})) {
-                    recordRequirement(subDepId, item.pkgId, subSpec);
-                    if (!nodes.has(subDepId)) {
-                        queue.push({
-                            pkgId: subDepId,
-                            requester: item.pkgId,
-                            rangeOrSpec: subSpec,
-                            isDirect: false,
-                        });
-                    }
+                    recordDependency(subDepId, item.pkgId, subSpec);
+                    queue.push({
+                        pkgId: subDepId,
+                        requester: item.pkgId,
+                        rangeOrSpec: subSpec,
+                        isDirect: false,
+                    });
                 }
             }
             if (scanLinked) {

package/dist/index.d.ts

@@ -5,7 +5,6 @@
  * 平台大对象驱动与解析器工具移至特定子路径导出（./server, ./project, ./registry,
  * ./profile, ./graph, ./package），严格杜绝在根导出泄露内部执行与平台上下文机制。
  */
-export { suppressExperimentalWarnings } from "./utils/warning.js";
 export { ACTIONDOCK_VERSION } from "./version.js";
 export { createActionDock, connectActionDock, } from "./service/factory.js";
 export type { ActionDockService, ActionDockService as ActionDock, DiscoveryPort, ExecutionPort, RunsPort, EventsPort, RunEventSubscriptionOptions, ConfigPort, StatePort, CreateActionDockOptions, ConnectActionDockOptions, RemoteServiceOptions, ConfigValueView, ListRunsOptions, RunReadOptions, StateScopeOptions, } from "./service/types.js";
@@ -23,6 +22,8 @@ export { startActionDockServer, } from "./server/server.js";
 export type { ServerOptions, ServerOptions as ActionDockServerOptions, ActionDockServerInstance, } from "./server/types.js";
 export { initProject } from "./project/init.js";
 export { loadProjectConfig, findProjectRoot, } from "./project/loader.js";
+export { inspectLocalPackageDirectory, validateLocalSkillPackages, isExplicitPath, } from "./project/skill-dir.js";
 export type { ProjectConfig, } from "./project/types.js";
+export type { LocalSkillDirectory, LocalPackageEntry, } from "./project/skill-dir.js";
 export type { PackageGraph, } from "./catalog/graph.js";
 export { ActionDockError, ProcessError, PACKAGE_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_NOT_FOUND, ACTION_LOAD_FAILED, ACTION_FAILED, ACTION_TIMEOUT, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, ACTION_CALL_CYCLE, UNDECLARED_ACTION_DEPENDENCY, INVALID_ACTION_REF, IDEMPOTENCY_CONFLICT, EXECUTION_FAILED, UNHANDLED_EXECUTION_ERROR, RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, STANDALONE_ASYNC_UNSUPPORTED, HOST_PROCESS_EXITED, EXECUTION_ABORTED, TIMEOUT, NETWORK_ERROR, CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND, STORAGE_BUSY, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR, PROCESS_CANCELLED, PROCESS_TIMEOUT, UNAUTHORIZED, NOT_FOUND, SERVER_ERROR, PACKAGE_FORBIDDEN, ACTION_FORBIDDEN, PLAYBOOK_NOT_FOUND, REQUEST_TOO_LARGE, ACTION_START_FAILED, ACTION_EXECUTION_ERROR, DATA_DIR_IN_USE, DATA_DIR_RECOVERY_REQUIRED, PROCESS_FAILED, MCP_TOOL_NAME_COLLISION, ACCESS_DENIED, INVALID_FLAT_ARGUMENT, INVALID_JSON, INVALID_JSON_LITERAL, INPUT_PATH_CONFLICT, FLAT_INPUT_LIMIT_EXCEEDED, INPUT_LIMIT_EXCEEDED, INPUT_POLICY_VIOLATION, INPUT_CONFLICT, INPUT_FILE_NOT_FOUND, INPUT_FILE_READ_FAILED, INVALID_ARGUMENT, PACKAGE_NOT_ALLOWED, INVALID_PACKAGE_ID, PATH_TRAVERSAL, AMBIGUOUS_STATE_KEY, RUN_NOT_FOUND, RUN_ALREADY_FINISHED, PROJECT_ROOT_NOT_FOUND, describeActionLoadFailure, createErrorEnvelope, resolveExecutionHint, } from "./errors.js";

package/dist/index.js

@@ -5,7 +5,6 @@
  * 平台大对象驱动与解析器工具移至特定子路径导出（./server, ./project, ./registry,
  * ./profile, ./graph, ./package），严格杜绝在根导出泄露内部执行与平台上下文机制。
  */
-export { suppressExperimentalWarnings } from "./utils/warning.js";
 // 1. 核心版本号单一事实源
 export { ACTIONDOCK_VERSION } from "./version.js";
 // 2. 统一服务门面与聚合契约接口
@@ -20,5 +19,6 @@ export { startActionDockServer, } from "./server/server.js";
 // 6. 核心工程辅助
 export { initProject } from "./project/init.js";
 export { loadProjectConfig, findProjectRoot, } from "./project/loader.js";
+export { inspectLocalPackageDirectory, validateLocalSkillPackages, isExplicitPath, } from "./project/skill-dir.js";
 // 8. 统一错误模型与核心标准错误码常量
 export { ActionDockError, ProcessError, PACKAGE_NOT_FOUND, ACTION_PACKAGE_VERSION_CONFLICT, ACTION_NOT_FOUND, ACTION_LOAD_FAILED, ACTION_FAILED, ACTION_TIMEOUT, ACTION_CANCELLED, INPUT_VALIDATION_FAILED, OUTPUT_VALIDATION_FAILED, INPUT_NOT_JSON, OUTPUT_NOT_JSON, ACTION_SUBRUN_LIMIT, ACTION_CALL_CYCLE, UNDECLARED_ACTION_DEPENDENCY, INVALID_ACTION_REF, IDEMPOTENCY_CONFLICT, EXECUTION_FAILED, UNHANDLED_EXECUTION_ERROR, RUN_REPOSITORY_UNAVAILABLE, RUN_PERSISTENCE_FAILED, STANDALONE_ASYNC_UNSUPPORTED, HOST_PROCESS_EXITED, EXECUTION_ABORTED, TIMEOUT, NETWORK_ERROR, CAPABILITY_UNAVAILABLE, STATE_KEY_NOT_FOUND, STORAGE_BUSY, PROJECT_BUSY, PROJECT_RECOVERY_REQUIRED, EVENT_BACKPRESSURE_LIMIT, EVENT_CURSOR_EXPIRED, PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR, PROCESS_CANCELLED, PROCESS_TIMEOUT, UNAUTHORIZED, NOT_FOUND, SERVER_ERROR, PACKAGE_FORBIDDEN, ACTION_FORBIDDEN, PLAYBOOK_NOT_FOUND, REQUEST_TOO_LARGE, ACTION_START_FAILED, ACTION_EXECUTION_ERROR, DATA_DIR_IN_USE, DATA_DIR_RECOVERY_REQUIRED, PROCESS_FAILED, MCP_TOOL_NAME_COLLISION, ACCESS_DENIED, INVALID_FLAT_ARGUMENT, INVALID_JSON, INVALID_JSON_LITERAL, INPUT_PATH_CONFLICT, FLAT_INPUT_LIMIT_EXCEEDED, INPUT_LIMIT_EXCEEDED, INPUT_POLICY_VIOLATION, INPUT_CONFLICT, INPUT_FILE_NOT_FOUND, INPUT_FILE_READ_FAILED, INVALID_ARGUMENT, PACKAGE_NOT_ALLOWED, INVALID_PACKAGE_ID, PATH_TRAVERSAL, AMBIGUOUS_STATE_KEY, RUN_NOT_FOUND, RUN_ALREADY_FINISHED, PROJECT_ROOT_NOT_FOUND, describeActionLoadFailure, createErrorEnvelope, resolveExecutionHint, } from "./errors.js";

package/dist/project/index.d.ts

@@ -3,6 +3,7 @@ export * from "./init.js";
 export * from "./loader.js";
 export * from "./lockfile.js";
 export * from "./manifest.js";
+export * from "./skill-dir.js";
 export { SNAPSHOT_TRACKED_FILES, type TransactionFileRecord, type TransactionMetadata, type ProjectTransaction, isProjectLockHeld, acquireProjectLock, runFrozenInstall, hasPendingTransactions, beginTransaction, recoverPendingTransactions, } from "./transactions.js";
 export * from "./types.js";
 export * from "./types-generator.js";

package/dist/project/index.js

@@ -3,6 +3,7 @@ export * from "./init.js";
 export * from "./loader.js";
 export * from "./lockfile.js";
 export * from "./manifest.js";
+export * from "./skill-dir.js";
 export { SNAPSHOT_TRACKED_FILES, isProjectLockHeld, acquireProjectLock, runFrozenInstall, hasPendingTransactions, beginTransaction, recoverPendingTransactions, } from "./transactions.js";
 export * from "./types.js";
 export * from "./types-generator.js";

package/dist/project/init.js

@@ -86,10 +86,10 @@ export function initProject(targetDir, options = {}) {
             node: ">=24.12.0",
         },
         dependencies: {
-            "@actiondock/sdk": "^2.13.0",
+            "@actiondock/sdk": "^2.14.0",
         },
         devDependencies: {
-            "@actiondock/testing": "^2.13.0",
+            "@actiondock/testing": "^2.14.0",
             "@types/node": "^22.13.0",
             "tsx": "^4.19.0",
             "typescript": "^5.7.0",

package/dist/project/skill-dir.d.ts

@@ -0,0 +1,56 @@
+import type { ProjectConfig } from "./types.js";
+/**
+ * 本地封闭包条目。
+ */
+export interface LocalPackageEntry {
+    packageId: string;
+    packageRoot: string;
+    projectConfig: ProjectConfig;
+}
+/**
+ * 本地技能 / 包目录发现视图。
+ */
+export interface LocalSkillDirectory {
+    type: "single" | "composite";
+    root: string;
+    packages: LocalPackageEntry[];
+}
+/**
+ * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
+ *
+ * 规则：
+ * - 以 .、/、~ 开头；
+ * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
+ * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
+ */
+export declare function isExplicitPath(p: string): boolean;
+/**
+ * 对明确的本地封闭包集合实施一致性校验。
+ *
+ * 校验规则：
+ * - 重复包标识防护：集合内不得存在相同 packageId；
+ * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
+ * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
+ *
+ * @param packages 封闭包条目集合
+ */
+export declare function validateLocalSkillPackages(packages: Array<{
+    packageId: string;
+    packageRoot: string;
+    projectConfig: ProjectConfig;
+}>): void;
+/**
+ * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
+ *
+ * 封闭包装配与校验规则：
+ * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
+ * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
+ * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
+ * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
+ * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
+ * - 若非候选技能目录，返回 null。
+ *
+ * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
+ * @param cwd 解析基准工作目录（默认为 process.cwd()）
+ */
+export declare function inspectLocalPackageDirectory(directoryPath: string, cwd?: string): LocalSkillDirectory | null;

package/dist/project/skill-dir.js

@@ -0,0 +1,214 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { ActionDockError, ACTION_NOT_FOUND, PACKAGE_NOT_FOUND, PACKAGE_ID_CONFLICT, } from "../errors.js";
+import { loadProjectConfig } from "./loader.js";
+import { PackageGraphBuilder } from "../catalog/graph.js";
+import { parseActionRef } from "../catalog/resolve-action.js";
+import { createPackageIdentity } from "../runtime/identity.js";
+/**
+ * 判定路径字符串是否为显式文件/目录路径形态（而非包标识符）。
+ *
+ * 规则：
+ * - 以 .、/、~ 开头；
+ * - 包含 / 或 \\，且不是 scoped 包（@scope/name 仅含一个 /）；
+ * - scoped 包若包含反斜杠或多于一个 /，亦视作路径。
+ */
+export function isExplicitPath(p) {
+    if (!p)
+        return false;
+    if (p.startsWith("@")) {
+        const slashCount = (p.match(/\//g) || []).length;
+        return slashCount > 1 || p.includes("\\");
+    }
+    return (p.startsWith(".") ||
+        p.startsWith("/") ||
+        p.startsWith("~") ||
+        p.includes("/") ||
+        p.includes("\\"));
+}
+/**
+ * 对明确的本地封闭包集合实施一致性校验。
+ *
+ * 校验规则：
+ * - 重复包标识防护：集合内不得存在相同 packageId；
+ * - 依赖存在性与版本兼容性：声明的直接依赖必须在集合内存在且满足语义版本约束（复用 PackageGraphBuilder）；
+ * - 跨包 uses 目标完整性：uses 声明引用的目标包与目标 Action 必须在集合内存在。
+ *
+ * @param packages 封闭包条目集合
+ */
+export function validateLocalSkillPackages(packages) {
+    if (!packages || packages.length === 0)
+        return;
+    // 1. 重复 packageId 校验
+    const seenIds = new Set();
+    for (const pkg of packages) {
+        if (seenIds.has(pkg.packageId)) {
+            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${pkg.packageId}' is declared more than once in skill packages`);
+        }
+        seenIds.add(pkg.packageId);
+    }
+    // 2. 构造包发现视图并交由 PackageGraphBuilder 校验依赖与版本
+    const discovered = packages.map((pkg) => ({
+        id: pkg.packageId,
+        root: pkg.packageRoot,
+        manifest: pkg.projectConfig,
+        identity: createPackageIdentity({
+            id: pkg.packageId,
+            instanceId: `${pkg.packageId}:${pkg.packageRoot}`,
+            generation: "skill-local",
+        }),
+        isCurrentProject: true,
+    }));
+    const builder = new PackageGraphBuilder({
+        packages: discovered,
+        validateDependencies: true,
+    });
+    builder.buildSync();
+    // 3. uses 声明目标存在性校验
+    const pkgMap = new Map();
+    for (const pkg of packages) {
+        pkgMap.set(pkg.packageId, pkg.projectConfig);
+    }
+    const validateUseRef = (rawRef, caller, currentPkg) => {
+        if (typeof rawRef !== "string" || !rawRef.trim())
+            return;
+        const trimmed = rawRef.trim();
+        // 先按完整包身份识别裸包引用，包括 scoped 包。
+        if (pkgMap.has(trimmed)) {
+            return;
+        }
+        // 裸 scoped 包只有一个斜杠，不能按限定动作拆分。
+        if (trimmed.startsWith("@") && (trimmed.match(/\//g) || []).length === 1) {
+            throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
+        }
+        // 限定动作与包级通配符复用统一引用解析器。
+        if (trimmed.includes("/")) {
+            const ref = parseActionRef(trimmed);
+            const targetPkgId = ref.packageId;
+            const targetActionId = ref.actionId;
+            const targetPkg = pkgMap.get(targetPkgId);
+            if (!targetPkg) {
+                throw new ActionDockError(PACKAGE_NOT_FOUND, `Package '${targetPkgId}' referenced by uses in '${caller}' was not found in skill directory`);
+            }
+            if (targetActionId !== "*") {
+                const hasAction = Boolean(targetPkg.actions && targetPkg.actions[targetActionId]);
+                if (!hasAction) {
+                    throw new ActionDockError(ACTION_NOT_FOUND, `Action '${targetActionId}' referenced by uses in '${caller}' was not found in package '${targetPkgId}'`);
+                }
+            }
+            return;
+        }
+        // 本包短动作引用。
+        if (currentPkg.actions && currentPkg.actions[trimmed]) {
+            return;
+        }
+        // 目标不存在。
+        throw new ActionDockError(PACKAGE_NOT_FOUND, `Package or action '${trimmed}' referenced by uses in '${caller}' was not found in skill directory`);
+    };
+    for (const pkg of packages) {
+        const pkgUses = pkg.projectConfig.uses;
+        if (Array.isArray(pkgUses)) {
+            for (const ref of pkgUses) {
+                validateUseRef(ref, `package '${pkg.packageId}'`, pkg.projectConfig);
+            }
+        }
+        if (pkg.projectConfig.actions && typeof pkg.projectConfig.actions === "object") {
+            for (const [actionId, actionEntry] of Object.entries(pkg.projectConfig.actions)) {
+                if (actionEntry && Array.isArray(actionEntry.uses)) {
+                    for (const ref of actionEntry.uses) {
+                        validateUseRef(ref, `action '${pkg.packageId}/${actionId}'`, pkg.projectConfig);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * 探测指定路径是否为本地 Skill / 包目录（支持单包根目录与 packages/* 复合套件布局）。
+ *
+ * 封闭包装配与校验规则：
+ * - 边界安全防护：packages 目录、各子包目录与 actiondock.json 清单真实路径必须在 Skill 根边界内，禁止越界符号链接；
+ * - 单包布局：目录根部存在 actiondock.json，解析为包含单一包的 LocalSkillDirectory；
+ * - 复合布局：目录根部存在 packages/ 目录，遍历其直接子目录，收集包含 actiondock.json 的子包；
+ * - 集合一致性校验：通过 validateLocalSkillPackages 严格核查依赖闭包、版本兼容与 uses 目标；
+ * - 异常透传：坏清单或权限异常原样抛出，严禁静默回退 Registry；
+ * - 若非候选技能目录，返回 null。
+ *
+ * @param directoryPath 待检查的目录路径（相对路径将基于 cwd 解析）
+ * @param cwd 解析基准工作目录（默认为 process.cwd()）
+ */
+export function inspectLocalPackageDirectory(directoryPath, cwd) {
+    if (!directoryPath || typeof directoryPath !== "string") {
+        return null;
+    }
+    const absDir = resolve(cwd || process.cwd(), directoryPath);
+    if (!existsSync(absDir)) {
+        return null;
+    }
+    try {
+        const stat = statSync(absDir);
+        if (!stat.isDirectory()) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    // 单包布局：根目录包含 actiondock.json
+    const rootManifest = join(absDir, "actiondock.json");
+    if (existsSync(rootManifest)) {
+        const config = loadProjectConfig(absDir);
+        const packages = [
+            {
+                packageId: config.id,
+                packageRoot: absDir,
+                projectConfig: config,
+            },
+        ];
+        validateLocalSkillPackages(packages);
+        return {
+            type: "single",
+            root: absDir,
+            packages,
+        };
+    }
+    // 复合 Skill 布局：存在 packages/ 目录且包含至少一个有效子包
+    const packagesDir = join(absDir, "packages");
+    if (existsSync(packagesDir)) {
+        const pStat = statSync(packagesDir);
+        if (pStat.isDirectory()) {
+            const entries = readdirSync(packagesDir, { withFileTypes: true });
+            const packages = [];
+            const seenIds = new Set();
+            entries.sort((a, b) => a.name.localeCompare(b.name));
+            for (const entry of entries) {
+                const subDir = join(packagesDir, entry.name);
+                const sStat = statSync(subDir);
+                if (sStat.isDirectory()) {
+                    const subManifest = join(subDir, "actiondock.json");
+                    if (existsSync(subManifest)) {
+                        const childConfig = loadProjectConfig(subDir);
+                        if (seenIds.has(childConfig.id)) {
+                            throw new ActionDockError(PACKAGE_ID_CONFLICT, `Package ID conflict: package '${childConfig.id}' is declared more than once in skill directory '${absDir}'`);
+                        }
+                        seenIds.add(childConfig.id);
+                        packages.push({
+                            packageId: childConfig.id,
+                            packageRoot: subDir,
+                            projectConfig: childConfig,
+                        });
+                    }
+                }
+            }
+            if (packages.length > 0) {
+                validateLocalSkillPackages(packages);
+                return {
+                    type: "composite",
+                    root: absDir,
+                    packages,
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/project/types.d.ts

@@ -75,6 +75,8 @@ export interface ActionDockManifest {
     actions?: Record<string, ActionManifestEntry>;
     /** 声明的 Playbooks 集合（唯一事实源） */
     playbooks?: Record<string, PlaybookManifestEntry>;
+    /** 包级静态依赖引用，与 Action 的 uses 共用引用语义。 */
+    uses?: string[];
     /** 跨包外部依赖映射（逻辑包 ID 到 npm 包名） */
     dependencies?: Record<string, string>;
     /** 框架导出与分发边界文件列表 */

package/dist/registry/registry.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
+import { inspectLocalPackageDirectory, isExplicitPath } from "../project/skill-dir.js";
 import { getActionDockHome, getPackageSlug } from "../utils/index.js";
 import { ActionDockError, MANIFEST_NOT_FOUND, REGISTRY_CORRUPTED } from "../errors.js";
 import { withRegistryLock } from "./lock.js";
@@ -399,31 +400,42 @@ export function resolvePackageRoot(packageIdOrPath, cwd, customHome) {
     const resolvedPath = resolve(baseDir, packageIdOrPath);
     // 检查 packageIdOrPath 是否为磁盘上现存的目录或文件路径
     if (existsSync(resolvedPath)) {
+        let info;
         try {
-            const info = statSync(resolvedPath);
+            info = statSync(resolvedPath);
+        }
+        catch (err) {
+            if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") {
+                throw err;
+            }
+        }
+        if (info) {
             const targetDir = info.isDirectory() ? resolvedPath : dirname(resolvedPath);
+            // 普通开发包根目录：直接包含 actiondock.json 清单。
+            // 普通清单根目录定位与封闭 Skill 执行校验分离，不能被当成只含一个包的 Skill 闭包拒绝。
             if (existsSync(join(targetDir, "actiondock.json"))) {
+                loadProjectConfig(targetDir);
                 return targetDir;
             }
-            const parentRoot = findProjectRoot(targetDir);
-            if (parentRoot) {
-                return parentRoot;
+            // 复合技能布局：根目录下存在 packages/ 目录且包含有效子包。
+            const localSkill = inspectLocalPackageDirectory(targetDir);
+            if (localSkill) {
+                return localSkill.root;
+            }
+            // 具体文件查找所属工程根目录：仅当 packageIdOrPath 指向具体文件（非目录）时，
+            // 才尝试向上查找所属工程根目录；目录形态绝不向上回退，防止显式目录越界命中父级工程。
+            if (!info.isDirectory()) {
+                const parentRoot = findProjectRoot(targetDir);
+                if (parentRoot) {
+                    loadProjectConfig(parentRoot);
+                    return parentRoot;
+                }
             }
-        }
-        catch {
-            // stat 失败（如并发删除）：忽略并继续走标识符解析路径
         }
     }
     // 显式路径形态但未解析成功的场景：
     // scoped package 标识符（如 @team/tools）虽含 '/' 但属于包 ID 而非文件路径
-    const isScopedPackage = packageIdOrPath.startsWith("@");
-    const isExplicitPath = !isScopedPackage &&
-        (packageIdOrPath.startsWith(".") ||
-            packageIdOrPath.startsWith("/") ||
-            packageIdOrPath.startsWith("~") ||
-            packageIdOrPath.includes("/") ||
-            packageIdOrPath.includes("\\"));
-    if (isExplicitPath) {
+    if (isExplicitPath(packageIdOrPath)) {
         // 显式路径不存在或不是 ActionDock 项目时必须失败，禁止静默回退
         return null;
     }

package/dist/runtime/standalone-commands.js

@@ -29,7 +29,7 @@ export async function handleList(ctx, subArgs) {
     const effectiveIntent = intent || (positionalPatterns.length > 0 ? positionalPatterns.join("|") : undefined);
     const actions = await ctx.service.discovery.listActions();
     const list = actions.map((a) => ({
-        id: a.id,
+        id: ctx.options.multiPackage && a.packageId && !a.id.includes("/") ? `${a.packageId}/${a.id}` : a.id,
         description: a.description || "",
     }));
     const filterRes = filterWithFallbackInfo(list, effectiveIntent, [(a) => a.id, (a) => a.description], !noFallback);
@@ -66,7 +66,7 @@ export async function handleDescribe(ctx, subArgs) {
         });
     }
     const payload = buildActionDescribePayload(action, {
-        packageId: ctx.options.packageId,
+        packageId: action.packageId || ctx.options.packageId,
     });
     if (isJson) {
         ctx.writeOut(JSON.stringify(payload, null, 2));
@@ -274,6 +274,9 @@ function isServiceCapabilityError(err) {
         code === "TARGET_CAPABILITY_UNAVAILABLE");
 }
 export async function handleConfig(ctx, subArgs) {
+    if (ctx.options.multiPackage) {
+        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
+    }
     const sub = subArgs[0] || "list";
     if (!ctx.service.management) {
         ctx.writeErr("Error: management port is not enabled on this service");
@@ -350,6 +353,9 @@ function decodeStateKeyArg(key) {
     }
 }
 export async function handleState(ctx, subArgs) {
+    if (ctx.options.multiPackage) {
+        return ctx.emitError(subArgs.includes("--json"), "CAPABILITY_UNAVAILABLE", "Multi-package entries do not support config/state management; configure actions using --config and --data-dir.", ExitCode.INVALID_ARGUMENT);
+    }
     const sub = subArgs[0] || "list";
     let namespace;
     let isAll = false;

package/dist/runtime/standalone.d.ts

@@ -24,6 +24,8 @@ export interface InvocationControl {
 export interface StandaloneDispatcherOptions {
     /** 所属 Package ID */
     packageId: string;
+    /** 多包入口使用完全限定发现标识，不以展示名操作配置和状态。 */
+    multiPackage?: boolean;
     /** 版本号 */
     version: string;
     /** 描述信息 */

package/dist/storage/sqlite-driver.d.ts

@@ -1,4 +1,3 @@
-import "../utils/warning.js";
 import type { DatabaseSync } from "node:sqlite";
 import { normalizeSqliteParams } from "./params.js";
 import type { SqliteDriver, SqliteStatement } from "./types.js";

package/dist/storage/sqlite-driver.js

@@ -1,4 +1,3 @@
-import "../utils/warning.js";
 import { normalizeSqliteParams } from "./params.js";
 import { ActionDockError, ASYNC_TRANSACTION_UNSUPPORTED, STORAGE_CLOSED } from "../errors.js";
 // 基于原生 ESM Top-Level Await 在模块评估期动态加载，确保警告静默拦截器优先就绪且保持纯正 ESM 架构

package/dist/utils/index.d.ts

@@ -104,4 +104,3 @@ export declare function assertPathWithinRoot(rootDir: string, targetPath: string
  * Backwards-compatible alias for assertPathWithinRoot targeting project roots.
  */
 export declare function assertWithinProjectRoot(projectRoot: string, subDir: string, fieldName: string): void;
-export { suppressExperimentalWarnings } from "./warning.js";

package/dist/utils/index.js

@@ -281,4 +281,3 @@ export function assertWithinProjectRoot(projectRoot, subDir, fieldName) {
     }
     assertPathWithinRoot(projectRoot, subDir, fieldName);
 }
-export { suppressExperimentalWarnings } from "./warning.js";

package/dist/utils/semver.d.ts

@@ -6,10 +6,11 @@ export interface SemVer {
     minor: number;
     patch: number;
     prerelease?: string;
+    build?: string;
 }
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生

package/dist/utils/semver.js

@@ -1,19 +1,25 @@
 /**
  * 解析基础 SemVer 版本字符串（单一事实源）。
- * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀；
+ * 仅接受可选 v/= 前缀的严格三段式语义化版本，可携带预发布后缀与构建元数据；
  * 其余形态（两段式、非数值等）返回 null，由调用方自行兜底。
  *
  * 本模块不依赖任何 Node 内建与 core 领域模块，可在无 loader 的原生
  * Node 直接以 .ts 形态导入（工程脚本域复用此处单一事实源）。
  */
 export function parseSemVer(v) {
-    const match = v.trim().replace(/^[v=]/, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    const match = v.trim().replace(/^[v=]/, "").match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/);
     if (!match)
         return null;
+    const [major, minor, patch] = match.slice(1, 4).map(Number);
+    if (![major, minor, patch].every(Number.isSafeInteger))
+        return null;
+    if (match[4]?.split(".").some((id) => /^\d+$/.test(id) && id.length > 1 && id.startsWith("0")))
+        return null;
     return {
-        major: parseInt(match[1], 10),
-        minor: parseInt(match[2], 10),
-        patch: parseInt(match[3], 10),
+        major,
+        minor,
+        patch,
         prerelease: match[4],
+        ...(match[5] === undefined ? {} : { build: match[5] }),
     };
 }

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export declare const ACTIONDOCK_VERSION = "2.13.0";
+export declare const ACTIONDOCK_VERSION = "2.14.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 /**
  * ActionDock 核心版本号单一事实源。
  */
-export const ACTIONDOCK_VERSION = "2.13.0";
+export const ACTIONDOCK_VERSION = "2.14.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actiondock/core",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "ActionDock Core Engine - Project loader, runtime execution, SQLite storage, standalone builder, and skill exporter",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,11 +41,6 @@
       "types": "./dist/package/index.d.ts",
       "import": "./dist/package/index.js",
       "default": "./dist/package/index.js"
-    },
-    "./warning": {
-      "types": "./dist/utils/warning.d.ts",
-      "import": "./dist/utils/warning.js",
-      "default": "./dist/utils/warning.js"
     }
   },
   "files": [
@@ -64,7 +59,7 @@
     "test": "node ../../scripts/run-tests.ts"
   },
   "dependencies": {
-    "@actiondock/sdk": "^2.13.0",
+    "@actiondock/sdk": "^2.14.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "undici": "^7.29.1"

package/dist/utils/warning.d.ts

@@ -1 +0,0 @@
-export declare function suppressExperimentalWarnings(): void;

package/dist/utils/warning.js

@@ -1,52 +0,0 @@
-/**
- * 全局禁用 Node.js 所有的 ExperimentalWarning 实验性特性警告。
- * 跨所有 Node.js 运行版本，不区分具体特性（如 SQLite、类型擦除等），
- * 在进程级别统一静默全部实验性警告，同时完整保留废弃警告与运行期异常。
- *
- * 逃生通道：当环境变量 ACTIONDOCK_SILENCE_WARNINGS 显式设置为 "0" 时，放弃静默以供深度调试排查。
- */
-const kExperimentalWarningSuppressed = Symbol.for("actiondock.experimental_warning_suppressed");
-export function suppressExperimentalWarnings() {
-    // 逃生通道：支持开发者显式禁用静默逻辑，确保排障透明度
-    if (process.env.ACTIONDOCK_SILENCE_WARNINGS === "0") {
-        return;
-    }
-    const globalObj = globalThis;
-    if (globalObj[kExperimentalWarningSuppressed]) {
-        return;
-    }
-    globalObj[kExperimentalWarningSuppressed] = true;
-    // 1. 拦截 process.emitWarning 源头
-    const originalEmitWarning = process.emitWarning;
-    if (typeof originalEmitWarning === "function") {
-        process.emitWarning = function (warning, ...args) {
-            if (typeof warning === "string") {
-                const type = typeof args[0] === "string" ? args[0] : args[0]?.type || args[1];
-                if (type === "ExperimentalWarning") {
-                    return;
-                }
-            }
-            else if (warning) {
-                const warnObj = warning;
-                if (warnObj.name === "ExperimentalWarning" || warnObj.type === "ExperimentalWarning") {
-                    return;
-                }
-            }
-            return Reflect.apply(originalEmitWarning, process, [warning, ...args]);
-        };
-    }
-    // 2. 包装进程级 warning 事件分发器，作为双层防护
-    const originalListeners = process.listeners("warning");
-    process.removeAllListeners("warning");
-    process.on("warning", (warning) => {
-        const warnObj = warning;
-        if (warnObj.name === "ExperimentalWarning" || warnObj.type === "ExperimentalWarning") {
-            return;
-        }
-        for (const listener of originalListeners) {
-            listener.call(process, warning);
-        }
-    });
-}
-// 模块被引入时立即自执行
-suppressExperimentalWarnings();