@actiondock/core 2.10.0 → 2.11.0

package/dist/process/process-executor.js

@@ -1,296 +0,0 @@
-import { PROCESS_CANCELLED, PROCESS_OUTPUT_LIMIT, PROCESS_SPAWN_ERROR, PROCESS_TIMEOUT, UNSUPPORTED_CAPABILITY, ProcessError, } from "../errors.js";
-import { NodeProcessDriver, killProcessGroup } from "./process-driver.js";
-import { RunExecutor } from "./run-executor.js";
-export { killProcessGroup };
-/**
- * 基于 NodeProcessDriver 实现的兼容命令执行器。
- * 核心 OS 进程派生与生命周期管理统一由 NodeProcessDriver 承担，不再重复派生与调度。
- */
-export class NodeProcessExecutor {
-    driver;
-    gracePeriodMs;
-    constructor(options) {
-        if (typeof options === "number") {
-            this.gracePeriodMs = options;
-            this.driver = new NodeProcessDriver();
-        }
-        else {
-            this.gracePeriodMs = options?.gracePeriodMs ?? 500;
-            this.driver =
-                options?.driver ??
-                    new NodeProcessDriver({
-                        spawnFn: options?.spawnFn,
-                    });
-        }
-    }
-    /**
-     * 执行外部系统命令，完整支持标准输入管道、超时控制、取消信号、输出容量截断及错误拦截。
-     *
-     * @param command 执行命令
-     * @param args 参数列表
-     * @param options 执行选项
-     * @param internal 内部专用参数：envAlreadyResolved 为 true 时 options.env 视为已完整解析
-     */
-    async exec(command, args = [], options = {}, internal) {
-        const startTime = Date.now();
-        const maxOutputBytes = options.maxOutputBytes ?? 10 * 1024 * 1024;
-        const encoding = options.encoding || "utf8";
-        const processId = `exec-${crypto.randomUUID()}`;
-        return new Promise(async (resolve, reject) => {
-            let settled = false;
-            let timedOut = false;
-            let cancelled = false;
-            let outputLimitExceeded = false;
-            let error;
-            let writeErr;
-            const stdoutChunks = [];
-            const stderrChunks = [];
-            let totalBytes = 0;
-            let timeoutTimer;
-            let graceTimer;
-            let abortHandler;
-            let handle;
-            /** 子进程是否已退出：grace 宽限期 SIGKILL 升级前的存活二闪确认依据 */
-            let childExited = false;
-            const finish = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (timeoutTimer) {
-                    clearTimeout(timeoutTimer);
-                    timeoutTimer = undefined;
-                }
-                // 结算时同步清理 grace 宽限定时器：子进程已退出（或已故障），
-                // 后续 SIGKILL 升级不再必要，且可避免定时器泄漏与 pid 复用误杀
-                if (graceTimer) {
-                    clearTimeout(graceTimer);
-                    graceTimer = undefined;
-                }
-                if (options.signal && abortHandler) {
-                    options.signal.removeEventListener("abort", abortHandler);
-                }
-                if (!result.ok && options.throwOnError) {
-                    const errMsg = result.error?.message || result.stderr || `Process exited with code ${result.exitCode}`;
-                    reject(new Error(errMsg));
-                }
-                else {
-                    resolve(result);
-                }
-            };
-            const terminateChild = (sig = "SIGTERM") => {
-                const pid = handle?.pid;
-                if (pid) {
-                    killProcessGroup(pid, sig, this.driver.spawnFn);
-                }
-                if (timeoutTimer) {
-                    clearTimeout(timeoutTimer);
-                    timeoutTimer = undefined;
-                }
-                if (sig === "SIGKILL") {
-                    if (graceTimer) {
-                        clearTimeout(graceTimer);
-                        graceTimer = undefined;
-                    }
-                }
-                else if (!graceTimer) {
-                    graceTimer = setTimeout(() => {
-                        graceTimer = undefined;
-                        // 宽限期到时二次确认子进程句柄仍存活：已退出则跳过 SIGKILL，
-                        // 杜绝对已复用 pid 的无关进程组误杀
-                        if (childExited) {
-                            return;
-                        }
-                        const targetPid = handle?.pid;
-                        if (targetPid) {
-                            killProcessGroup(targetPid, "SIGKILL", this.driver.spawnFn);
-                        }
-                    }, this.gracePeriodMs);
-                    graceTimer.unref?.();
-                }
-            };
-            const callbacks = {
-                onOutput: (stream, data) => {
-                    if (outputLimitExceeded)
-                        return;
-                    const chunk = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-                    totalBytes += chunk.length;
-                    if (totalBytes > maxOutputBytes) {
-                        outputLimitExceeded = true;
-                        if (!error) {
-                            error = {
-                                code: PROCESS_OUTPUT_LIMIT,
-                                message: `Process output exceeded limit of ${maxOutputBytes} bytes`,
-                            };
-                        }
-                        terminateChild("SIGTERM");
-                        return;
-                    }
-                    if (stream === "stdout")
-                        stdoutChunks.push(chunk);
-                    else if (stream === "stderr")
-                        stderrChunks.push(chunk);
-                },
-                onExit: (exit) => {
-                    childExited = true;
-                    const durationMs = Date.now() - startTime;
-                    const stdoutBuf = Buffer.concat(stdoutChunks);
-                    const stderrBuf = Buffer.concat(writeErr
-                        ? [...stderrChunks, Buffer.from(`\n[stdin write failed: ${writeErr.message}]`)]
-                        : stderrChunks);
-                    const stdoutStr = stdoutBuf.toString(encoding);
-                    const stderrStr = stderrBuf.toString(encoding);
-                    const ok = exit.code === 0 && !timedOut && !cancelled && !error;
-                    finish({
-                        ok,
-                        exitCode: exit.code,
-                        signal: exit.signal || undefined,
-                        stdout: stdoutStr.trim(),
-                        stderr: stderrStr.trim(),
-                        raw: new Uint8Array(stdoutBuf),
-                        timedOut,
-                        cancelled,
-                        durationMs,
-                        error,
-                    });
-                },
-                onError: (err) => {
-                    childExited = true;
-                    const durationMs = Date.now() - startTime;
-                    const spawnError = error || {
-                        code: PROCESS_SPAWN_ERROR,
-                        message: err.message || "Failed to spawn process",
-                    };
-                    const stdoutBuf = Buffer.concat(stdoutChunks);
-                    const stderrBuf = Buffer.concat(writeErr
-                        ? [...stderrChunks, Buffer.from(`\n[stdin write failed: ${writeErr.message}]`)]
-                        : stderrChunks);
-                    finish({
-                        ok: false,
-                        exitCode: null,
-                        signal: undefined,
-                        stdout: stdoutBuf.toString(encoding).trim(),
-                        stderr: stderrBuf.toString(encoding).trim() || spawnError.message,
-                        raw: new Uint8Array(stdoutBuf),
-                        timedOut,
-                        cancelled,
-                        durationMs,
-                        error: spawnError,
-                    });
-                },
-            };
-            const effectiveEnv = internal?.envAlreadyResolved
-                ? { inherit: "none", set: options.env }
-                : options.env
-                    ? { inherit: "allowlisted", set: options.env }
-                    : undefined;
-            const spec = {
-                executable: command,
-                args,
-                cwd: options.cwd,
-                env: effectiveEnv,
-                io: { mode: "pipe" },
-            };
-            if (options.signal) {
-                abortHandler = () => {
-                    cancelled = true;
-                    if (!error) {
-                        error = {
-                            code: PROCESS_CANCELLED,
-                            message: "Process was cancelled by AbortSignal",
-                        };
-                    }
-                    terminateChild("SIGTERM");
-                };
-                if (options.signal.aborted) {
-                    abortHandler();
-                }
-                else {
-                    options.signal.addEventListener("abort", abortHandler, { once: true });
-                }
-            }
-            if (options.timeoutMs && options.timeoutMs > 0) {
-                timeoutTimer = setTimeout(() => {
-                    timedOut = true;
-                    if (!error) {
-                        error = {
-                            code: PROCESS_TIMEOUT,
-                            message: `Process timed out after ${options.timeoutMs}ms`,
-                        };
-                    }
-                    terminateChild("SIGTERM");
-                }, options.timeoutMs);
-            }
-            try {
-                const observer = {
-                    output: (stream, data) => callbacks.onOutput(stream, data),
-                    exited: (exit) => callbacks.onExit(exit),
-                    outputClosed: (reason) => callbacks.onOutputClosed?.(reason),
-                    fault: (err) => callbacks.onError(err),
-                };
-                handle = (await this.driver.spawn(spec, observer));
-                if (cancelled || timedOut || outputLimitExceeded) {
-                    terminateChild("SIGTERM");
-                }
-            }
-            catch (spawnErr) {
-                callbacks.onError(spawnErr);
-                return;
-            }
-            if (options.input !== undefined && options.input !== null && handle) {
-                const inputBytes = typeof options.input === "string"
-                    ? new TextEncoder().encode(options.input)
-                    : options.input;
-                handle
-                    .write(inputBytes)
-                    .then(() => handle?.sendInputEOF?.())
-                    .catch((err) => {
-                    writeErr = err;
-                });
-            }
-        });
-    }
-    async spawn(command, args = [], options = {}) {
-        return this.exec(command, args, options);
-    }
-    async run(input, call) {
-        const runExecutor = new RunExecutor(this.driver);
-        return runExecutor.execute(input, call);
-    }
-    async start(_input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process start; use ProcessManager with NodeProcessDriver");
-    }
-    async inspect(_id, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process inspect");
-    }
-    async list(_input, _call) {
-        return { processes: [] };
-    }
-    async acquire(_id, _input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process acquire");
-    }
-    async renew(_id, _token, _ttlMs, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process renew");
-    }
-    async release(_id, _token, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process release");
-    }
-    async write(_id, _input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process write");
-    }
-    async operation(_id, _requestId, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process operation");
-    }
-    async read(_id, _input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process read");
-    }
-    async control(_id, _input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process control");
-    }
-    async stop(_id, _input, _call) {
-        throw new ProcessError(UNSUPPORTED_CAPABILITY, "NodeProcessExecutor does not support managed process stop");
-    }
-}
-/**
- * 兼容原有类名导出。
- */
-export { NodeProcessExecutor as ExecaProcessExecutor };

package/dist/profile/client-health.d.ts

@@ -1,14 +0,0 @@
-import type { RemoteHealthResult } from "./types.js";
-import { type RemoteClientRequestOptions } from "./client-transport.js";
-/**
- * 远端健康检查域端点。
- */
-/**
- * 探测指定远端 ActionDock 服务的健康状态与网络延迟。
- *
- * @param serverUrl 目标服务端地址
- * @param token 鉴权 Token（可选）
- * @param timeoutMs 探测超时时间（默认 5000ms）
- * @param options 传输与安全控制选项
- */
-export declare function checkRemoteHealth(serverUrl: string, token?: string, timeoutMs?: number, options?: RemoteClientRequestOptions): Promise<RemoteHealthResult>;

package/dist/profile/client-query.d.ts

@@ -1,30 +0,0 @@
-import { type RemoteClientRequestOptions } from "./client-transport.js";
-/**
- * 远端端点函数共享的请求与查询构造层。
- *
- * 职责单一聚焦：JSON 响应解析与错误信封透传、查询参数序列化，
- * 供各按域端点模块复用，杜绝端点函数内手工拼 query 样板。
- */
-/**
- * 执行远端请求并将响应解析为 JSON，统一处理错误信封透传。
- * 非 2xx 响应或显式 ok=false 信封抛出携带 code/status/details 的 Error。
- */
-export declare function fetchRemoteJson<T = any>(serverUrl: string, path: string, token?: string, options?: {
-    method?: string;
-    body?: unknown;
-    errorPrefix?: string;
-} & RemoteClientRequestOptions): Promise<T>;
-/**
- * 由可选参数字典构造查询串（无参数时返回空串）。
- *
- * 序列化规则与既有端点行为严格一致：
- * - undefined 与空串一律跳过（对应原有 if (options?.xxx) 真值守卫）；
- * - 需保留「存在但为空」语义的参数（如 namespace，服务端区分空串与未传递）
- *   由调用方显式处理，不经由此助手序列化空串。
- */
-export declare function buildQueryString(params: Record<string, string | number | boolean | undefined>): string;
-/**
- * 构造保留「存在但为空」语义的查询串：仅跳过 undefined，空串照常序列化。
- * 适用 namespace 类参数：服务端以参数是否存在区分空命名空间与默认命名空间。
- */
-export declare function buildQueryStringPreservingEmpty(params: Record<string, string | number | boolean | undefined>): string;

package/dist/profile/client-query.js

@@ -1,69 +0,0 @@
-import { createRemoteFetch } from "./client-transport.js";
-import { ActionDockError, NOT_FOUND, REMOTE_REQUEST_FAILED, UNAUTHORIZED } from "../errors.js";
-/**
- * 远端端点函数共享的请求与查询构造层。
- *
- * 职责单一聚焦：JSON 响应解析与错误信封透传、查询参数序列化，
- * 供各按域端点模块复用，杜绝端点函数内手工拼 query 样板。
- */
-/**
- * 执行远端请求并将响应解析为 JSON，统一处理错误信封透传。
- * 非 2xx 响应或显式 ok=false 信封抛出携带 code/status/details 的 Error。
- */
-export async function fetchRemoteJson(serverUrl, path, token, options = {}) {
-    const remoteFetch = createRemoteFetch(serverUrl, token, {
-        allowInsecureHttp: options.allowInsecureHttp,
-        insecure: options.insecure,
-        dispatcher: options.dispatcher,
-    });
-    const res = await remoteFetch(path, {
-        method: options.method,
-        body: options.body,
-    });
-    const data = (await res.json().catch(() => ({})));
-    if (!res.ok || (options.method === "POST" && data && data.ok === false)) {
-        const errorPrefix = options.errorPrefix || "Remote request failed";
-        const msg = data?.error?.message || `${errorPrefix} (${res.status}): ${res.statusText}`;
-        const code = data?.error?.code ||
-            (res.status === 404 ? NOT_FOUND : res.status === 401 ? UNAUTHORIZED : REMOTE_REQUEST_FAILED);
-        const details = data?.error?.details ?? data?.error;
-        const err = new ActionDockError(code, msg, details, res.status);
-        err.errorData = data?.error;
-        throw err;
-    }
-    return data;
-}
-/**
- * 由可选参数字典构造查询串（无参数时返回空串）。
- *
- * 序列化规则与既有端点行为严格一致：
- * - undefined 与空串一律跳过（对应原有 if (options?.xxx) 真值守卫）；
- * - 需保留「存在但为空」语义的参数（如 namespace，服务端区分空串与未传递）
- *   由调用方显式处理，不经由此助手序列化空串。
- */
-export function buildQueryString(params) {
-    const search = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-        if (value === undefined || value === "") {
-            continue;
-        }
-        search.set(key, String(value));
-    }
-    const qs = search.toString();
-    return qs ? `?${qs}` : "";
-}
-/**
- * 构造保留「存在但为空」语义的查询串：仅跳过 undefined，空串照常序列化。
- * 适用 namespace 类参数：服务端以参数是否存在区分空命名空间与默认命名空间。
- */
-export function buildQueryStringPreservingEmpty(params) {
-    const search = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-        if (value === undefined) {
-            continue;
-        }
-        search.set(key, String(value));
-    }
-    const qs = search.toString();
-    return qs ? `?${qs}` : "";
-}

package/dist/profile/client.d.ts

@@ -1,26 +0,0 @@
-/**
- * 远端 Profile 客户端聚合入口。
- *
- * 历史上全部端点函数集中于单一 client.ts（约 950 行），现按域拆分为
- * 单一职责模块，此处仅保留聚合 re-export，导入路径 ./client 与
- * @actiondock/core 的公共导出面保持完全兼容。
- *
- * 模块划分：
- * - client-transport：传输层（鉴权头、明文校验、协议回退）
- * - client-query：共享请求与查询构造层
- * - client-health：健康检查
- * - client-actions：执行与 Action 查询
- * - client-playbooks：Playbook 规程查询
- * - client-runs：运行记录管理
- * - client-state：状态存储管理
- * - client-config：配置管理
- */
-export { assertSecureTransport, createRemoteFetch, fetchRemoteRoute, } from "./client-transport.js";
-export type { RemoteClientRequestOptions, RemoteFetchInit, SecureTransportOptions, } from "./client-transport.js";
-export { checkRemoteHealth } from "./client-health.js";
-export { executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteDoctor, fetchRemoteInfo, } from "./client-actions.js";
-export type { RemoteExecuteOptions, RemoteExecutionResult } from "./client-actions.js";
-export { fetchRemotePlaybookShow, fetchRemotePlaybooks } from "./client-playbooks.js";
-export { cancelRemoteRun, clearRemoteRuns, cleanExpiredRemoteRuns, fetchRemoteRun, fetchRemoteRuns, } from "./client-runs.js";
-export { clearRemoteState, deleteRemoteStateKey, fetchRemoteStateList, getRemoteStateKey, setRemoteStateKey, } from "./client-state.js";
-export { deleteRemoteConfig, fetchRemoteConfig, fetchRemoteConfigEnv, setRemoteConfig, } from "./client-config.js";

package/dist/profile/client.js

@@ -1,31 +0,0 @@
-/**
- * 远端 Profile 客户端聚合入口。
- *
- * 历史上全部端点函数集中于单一 client.ts（约 950 行），现按域拆分为
- * 单一职责模块，此处仅保留聚合 re-export，导入路径 ./client 与
- * @actiondock/core 的公共导出面保持完全兼容。
- *
- * 模块划分：
- * - client-transport：传输层（鉴权头、明文校验、协议回退）
- * - client-query：共享请求与查询构造层
- * - client-health：健康检查
- * - client-actions：执行与 Action 查询
- * - client-playbooks：Playbook 规程查询
- * - client-runs：运行记录管理
- * - client-state：状态存储管理
- * - client-config：配置管理
- */
-// 传输层与通用类型
-export { assertSecureTransport, createRemoteFetch, fetchRemoteRoute, } from "./client-transport.js";
-// 健康检查
-export { checkRemoteHealth } from "./client-health.js";
-// 执行与 Action 查询
-export { executeRemoteAction, fetchRemoteActionShow, fetchRemoteActions, fetchRemoteDoctor, fetchRemoteInfo, } from "./client-actions.js";
-// Playbook 规程查询
-export { fetchRemotePlaybookShow, fetchRemotePlaybooks } from "./client-playbooks.js";
-// 运行记录管理
-export { cancelRemoteRun, clearRemoteRuns, cleanExpiredRemoteRuns, fetchRemoteRun, fetchRemoteRuns, } from "./client-runs.js";
-// 状态存储管理
-export { clearRemoteState, deleteRemoteStateKey, fetchRemoteStateList, getRemoteStateKey, setRemoteStateKey, } from "./client-state.js";
-// 配置管理
-export { deleteRemoteConfig, fetchRemoteConfig, fetchRemoteConfigEnv, setRemoteConfig, } from "./client-config.js";

package/dist/project/closure.d.ts

@@ -1,25 +0,0 @@
-export interface EnsureDependencyClosureOptions {
-    /**
-     * 自定义依赖安装回调函数（便于单测 Mock 与自定义扩展）
-     */
-    ensure?: (root: string) => boolean | Promise<boolean>;
-    /**
-     * 自定义 ActionDock 家目录
-     */
-    customHome?: string;
-}
-export interface DependencyClosureResult {
-    /** 成功执行依赖预装的项目根路径列表（默认实现下永远为空） */
-    installed: string[];
-    /** 无法在注册表中解析包引用的警告列表 */
-    warnings: string[];
-}
-/**
- * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一调用依赖预装回调。
- * 默认预装回调为明确的不操作（ActionDock 2.0 不做运行时安装）；可通过 opts.ensure 注入自定义实现。
- *
- * @param roots 根项目目录列表
- * @param opts 选项参数
- * @returns 预装成功的路径列表及警告信息
- */
-export declare function ensureDependencyClosure(roots: string[], opts?: EnsureDependencyClosureOptions): Promise<DependencyClosureResult>;

package/dist/project/closure.js

@@ -1,74 +0,0 @@
-import { resolve } from "node:path";
-import { parseActionRef } from "../catalog/resolve-action.js";
-import { resolvePackageRoot } from "../registry/registry.js";
-import { loadManifest } from "./manifest.js";
-/**
- * 依赖预装的默认实现：明确的不操作。
- * ActionDock 2.0 移除了运行时静默在线安装，保留该签名仅为闭包遍历提供注入点（便于单测 Mock 与自定义扩展）。
- */
-function noopEnsure() {
-    return false;
-}
-/**
- * 广度优先遍历 (BFS) uses 声明的跨包依赖闭包，对涉及的每个项目包逐一调用依赖预装回调。
- * 默认预装回调为明确的不操作（ActionDock 2.0 不做运行时安装）；可通过 opts.ensure 注入自定义实现。
- *
- * @param roots 根项目目录列表
- * @param opts 选项参数
- * @returns 预装成功的路径列表及警告信息
- */
-export async function ensureDependencyClosure(roots, opts = {}) {
-    const seen = new Set();
-    const queue = [...roots];
-    const installed = [];
-    const warnings = [];
-    while (queue.length > 0) {
-        const rawRoot = queue.shift();
-        if (!rawRoot)
-            continue;
-        const root = resolve(rawRoot);
-        if (seen.has(root))
-            continue;
-        seen.add(root);
-        const ensureFn = opts.ensure ?? noopEnsure;
-        const wasInstalled = await ensureFn(root);
-        if (wasInstalled) {
-            installed.push(root);
-        }
-        let manifest;
-        try {
-            manifest = loadManifest(root);
-        }
-        catch {
-            continue;
-        }
-        if (!manifest || !manifest.actions)
-            continue;
-        for (const actionEntry of Object.values(manifest.actions)) {
-            if (!Array.isArray(actionEntry.uses))
-                continue;
-            for (const rawRef of actionEntry.uses) {
-                if (typeof rawRef !== "string" || !rawRef.trim())
-                    continue;
-                let parsed;
-                try {
-                    parsed = parseActionRef(rawRef);
-                }
-                catch {
-                    warnings.push(`uses 声明 '${rawRef}' 未在注册表中解析到包`);
-                    continue;
-                }
-                if (parsed.packageId) {
-                    const depRoot = resolvePackageRoot(parsed.packageId, root, opts.customHome);
-                    if (depRoot) {
-                        queue.push(resolve(depRoot));
-                    }
-                    else {
-                        warnings.push(`uses 声明 '${rawRef}' 未在注册表中解析到包`);
-                    }
-                }
-            }
-        }
-    }
-    return { installed, warnings };
-}

package/dist/registry/store.d.ts

@@ -1,42 +0,0 @@
-import type { GlobalRegistryData, LinkedPackageEntry, LinkedWorkspaceEntry, LinkResult, PruneResult, RegistryStatusReport, UnlinkResult } from "./types.js";
-/**
- * 用户显式注册位置存储契约。
- * 职责严格限制为存储与读取用户显式 link/unlink 的物理位置（packages 与 workspaces）。
- */
-export interface RegistryStore {
-    readonly customHome?: string;
-    getFilePath(): string;
-    load(): GlobalRegistryData;
-    loadAsync(): Promise<GlobalRegistryData>;
-    save(data: GlobalRegistryData): Promise<void>;
-    listPackages(): LinkedPackageEntry[];
-    listWorkspaces(): LinkedWorkspaceEntry[];
-    link(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<LinkResult>;
-    unlink(idOrPath: string): Promise<UnlinkResult | null>;
-    prune(): Promise<PruneResult>;
-    getStatus(): RegistryStatusReport;
-}
-/**
- * 默认注册表物理位置存储实现。
- * 直接基于文件系统注册表文件（~/.actiondock/registry.json）读写；
- * 全部方法均为向 registry.ts 自由函数透传 customHome 的零逻辑转发，
- * 收敛为单行委托以消除重复样板。
- */
-export declare class DefaultRegistryStore implements RegistryStore {
-    readonly customHome?: string;
-    constructor(customHome?: string);
-    getFilePath(): string;
-    load(): GlobalRegistryData;
-    loadAsync(): Promise<GlobalRegistryData>;
-    save(data: GlobalRegistryData): Promise<void>;
-    listPackages(): LinkedPackageEntry[];
-    listWorkspaces(): LinkedWorkspaceEntry[];
-    link(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<LinkResult>;
-    unlink(idOrPath: string): Promise<UnlinkResult | null>;
-    prune(): Promise<PruneResult>;
-    getStatus(): RegistryStatusReport;
-}

package/dist/registry/store.js

@@ -1,43 +0,0 @@
-import { getRegistryFilePath, getRegistryStatus, linkPackage, listLinkedPackages, listLinkedWorkspaces, loadRegistry, loadRegistryAsync, pruneRegistry, saveRegistry, unlinkPackage, } from "./registry.js";
-/**
- * 默认注册表物理位置存储实现。
- * 直接基于文件系统注册表文件（~/.actiondock/registry.json）读写；
- * 全部方法均为向 registry.ts 自由函数透传 customHome 的零逻辑转发，
- * 收敛为单行委托以消除重复样板。
- */
-export class DefaultRegistryStore {
-    customHome;
-    constructor(customHome) {
-        this.customHome = customHome;
-    }
-    getFilePath() {
-        return getRegistryFilePath(this.customHome);
-    }
-    load() {
-        return loadRegistry(this.customHome);
-    }
-    loadAsync() {
-        return loadRegistryAsync(this.customHome);
-    }
-    save(data) {
-        return saveRegistry(data, this.customHome);
-    }
-    listPackages() {
-        return listLinkedPackages(this.customHome);
-    }
-    listWorkspaces() {
-        return listLinkedWorkspaces(this.customHome);
-    }
-    link(path, options) {
-        return linkPackage(path, this.customHome, options);
-    }
-    unlink(idOrPath) {
-        return unlinkPackage(idOrPath, this.customHome);
-    }
-    prune() {
-        return pruneRegistry(this.customHome);
-    }
-    getStatus() {
-        return getRegistryStatus(this.customHome);
-    }
-}

package/dist/runtime/clock.d.ts

@@ -1,7 +0,0 @@
-/**
- * 时钟契约单一事实源已下沉至 storage/clock.ts（基础契约层）。
- *
- * 此处 re-export 维持 `runtime/clock` 与 `@actiondock/core` 根入口的既有
- * 导入路径兼容，外部消费方无需变更。
- */
-export { type Clock, SystemClock } from "../storage/clock.js";

package/dist/runtime/clock.js

@@ -1,7 +0,0 @@
-/**
- * 时钟契约单一事实源已下沉至 storage/clock.ts（基础契约层）。
- *
- * 此处 re-export 维持 `runtime/clock` 与 `@actiondock/core` 根入口的既有
- * 导入路径兼容，外部消费方无需变更。
- */
-export { SystemClock } from "../storage/clock.js";