@actiondock/core 2.6.0 → 2.8.0

package/dist/{app/app.js → package/runtime.js}

@@ -1,19 +1,24 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { DefaultExecutionService } from "../execution/service.js";
-import { createDefaultPlatform } from "../platform/index.js";
+import { createNodePlatform } from "../platform/index.js";
 import { findProjectRoot, loadProjectConfig } from "../project/loader.js";
 import { RuntimeConfig } from "../runtime/context.js";
 import { normalizeActionCollection } from "../runtime/action-collection.js";
-import { createGlobalStorage, createLazyStorage, createStorage } from "../storage/index.js";
+import { createLazyStorage } from "../storage/index.js";
 import { isSecretConfigKey, sanitizeConfigDefinitions } from "../storage/mask.js";
 import { decodeStateKey, SqliteRuntimeStorage } from "../storage/sqlite.js";
+import { createPackageIdentity } from "../runtime/identity.js";
+import { ACTION_NOT_FOUND, ActionDockError, CAPABILITY_UNAVAILABLE, INVALID_ARGUMENT, INVOCATION_UNSUPPORTED, NOT_FOUND, } from "../errors.js";
+import { createRootInvocationContext } from "../invocation/types.js";
 import { buildStaticActionMap, buildStaticPlaybookMap } from "./static-index.js";
+import { applyActionSummaryFilters } from "./types.js";
 /**
- * ActionDock 统一应用默认实现。
+ * ActionDock 统一包运行时默认实现。
  * 封装并管理单个 Action Package 的执行引擎、静态元数据索引、配置与状态存储生命周期。
  */
-export class DefaultActionDockApp {
+export class DefaultPackageRuntime {
+    identity;
     packageId;
     packageInstanceId;
     generationId;
@@ -27,6 +32,7 @@ export class DefaultActionDockApp {
     options;
     runtimeConfig;
     isClosed = false;
+    injectedGlobalStorage = false;
     /** 静态清单索引缓存：包静态事实（根目录、配置、内存注入集合）在实例生命周期内不变，解析结果同实例内复用 */
     staticActionIndex;
     staticPlaybookIndex;
@@ -58,13 +64,18 @@ export class DefaultActionDockApp {
         }
         this.packageRoot = packageRoot;
         this.projectConfig = projectConfig;
-        this.packageId = projectConfig.id;
-        this.packageInstanceId = options.packageInstanceId || projectConfig.packageInstanceId || this.packageId;
-        this.generationId = options.generationId || projectConfig.generationId || "1";
+        this.identity = options.identity || createPackageIdentity({
+            id: projectConfig.id,
+            instanceId: options?.packageInstanceId || projectConfig.packageInstanceId,
+            generation: options?.generationId || projectConfig.generationId,
+        });
+        this.packageId = this.identity.id;
+        this.packageInstanceId = this.identity.instanceId;
+        this.generationId = this.identity.generation;
         // 2. 转换 Action 集合：委托归一化单一入口
         this.actionsMap = normalizeActionCollection(options.actions).actionsMap;
         // 3. 确定平台适配层
-        this.platform = options.platform ?? createDefaultPlatform();
+        this.platform = options.platform ?? createNodePlatform();
         // 4. 确定并初始化存储实例
         if (options.storage) {
             this.storage = options.storage;
@@ -79,20 +90,8 @@ export class DefaultActionDockApp {
                 // CLI 查询旁观视图显式置 recoverOrphans: false 跳过收割
                 recoverOrphans: options.recoverOrphans !== false,
             };
-            const storageFactory = this.platform.storage;
             const initStorage = () => {
-                if (typeof storageFactory === "function") {
-                    return storageFactory(this.packageId, storageOpts);
-                }
-                else if (storageFactory && typeof storageFactory.createStorage === "function") {
-                    return storageFactory.createStorage(this.packageId, storageOpts);
-                }
-                else if (storageFactory && typeof storageFactory.create === "function") {
-                    return storageFactory.create(this.packageId, storageOpts);
-                }
-                else {
-                    return createStorage(this.packageId, storageOpts);
-                }
+                return this.platform.storage.createStorage(this.packageId, storageOpts);
             };
             if (options.inMemory) {
                 this.storage = initStorage();
@@ -104,12 +103,14 @@ export class DefaultActionDockApp {
         // 5. 确定全局存储实例
         if (options.globalStorage) {
             this.globalStorage = options.globalStorage;
+            this.injectedGlobalStorage = true;
         }
         else if (options.inMemory) {
             this.globalStorage = new SqliteRuntimeStorage({
                 dbPath: ":memory:",
                 packageId: "__global__",
             });
+            this.injectedGlobalStorage = false;
         }
         else {
             const globalOpts = {
@@ -119,20 +120,15 @@ export class DefaultActionDockApp {
                 // 与主存储保持同侧收割语义（全局库 runs 表为空集，收割无实际副作用）
                 recoverOrphans: options.recoverOrphans !== false,
             };
-            const storageFactory = this.platform.storage;
             const initGlobalStorage = () => {
-                if (storageFactory && typeof storageFactory.createGlobalStorage === "function") {
-                    return storageFactory.createGlobalStorage(globalOpts);
-                }
-                return createGlobalStorage(globalOpts);
+                return this.platform.storage.createGlobalStorage(globalOpts);
             };
             this.globalStorage = createLazyStorage(initGlobalStorage);
+            this.injectedGlobalStorage = false;
         }
         // 6. 初始化唯一执行协调服务
         this.executionService = new DefaultExecutionService({
-            packageId: this.packageId,
-            packageInstanceId: this.packageInstanceId,
-            generationId: this.generationId,
+            identity: this.identity,
             hostSessionId: options.hostSessionId,
             storage: this.storage,
             globalStorage: this.globalStorage,
@@ -145,14 +141,18 @@ export class DefaultActionDockApp {
             logger: options.logger,
             eventSink: options.eventSink ?? this.platform?.eventSink,
             maxActiveRuns: options.maxActiveRuns,
-            maxCallDepth: options.maxCallDepth,
-            maxSubRuns: options.maxSubRuns,
             ownerId: options.ownerId,
             actionResolver: options.actionResolver,
-            packageContextResolver: options.packageContextResolver,
             customHome: options.customHome,
-            platform: this.platform,
+            moduleLoader: this.platform.modules,
+            actionInvoker: options.actionInvoker,
         });
+        if (!options.actionInvoker) {
+            const unsupportedInvoker = async () => {
+                throw new ActionDockError(INVOCATION_UNSUPPORTED, "Cascaded action invocation (ctx.actions.invoke) is not supported in standalone PackageRuntime. Actions must be executed within an ActionDock Host.");
+            };
+            this.executionService.setActionInvoker?.(unsupportedInvoker);
+        }
         // 7. 初始化配置解析器
         this.runtimeConfig = new RuntimeConfig(this.storage, options.configOverrides, this.projectConfig, this.globalStorage);
     }
@@ -209,7 +209,7 @@ export class DefaultActionDockApp {
     }
     async listActions(options) {
         const map = this.getStaticActionMap();
-        let summaries = Array.from(map.values()).map((spec) => ({
+        const summaries = Array.from(map.values()).map((spec) => ({
             id: spec.id,
             packageId: this.packageId,
             description: spec.description,
@@ -220,18 +220,7 @@ export class DefaultActionDockApp {
             inputSchema: spec.inputSchema,
             outputSchema: spec.outputSchema,
         }));
-        if (options?.tags && options.tags.length > 0) {
-            summaries = summaries.filter((s) => options.tags.every((t) => s.tags?.includes(t)));
-        }
-        if (options?.query) {
-            const q = options.query.toLowerCase();
-            summaries = summaries.filter((s) => s.id.toLowerCase().includes(q) ||
-                (s.description && s.description.toLowerCase().includes(q)));
-        }
-        if (options?.prefix) {
-            summaries = summaries.filter((s) => s.id.startsWith(options.prefix));
-        }
-        return summaries;
+        return applyActionSummaryFilters(summaries, options);
     }
     async describeAction(id) {
         const map = this.getStaticActionMap();
@@ -253,14 +242,14 @@ export class DefaultActionDockApp {
                 this.executionService.getAction(id) ||
                     (spec ? this.executionService.getAction(spec.id) : undefined);
         }
-        if (!liveAction && this.executionService.runner?.resolveAction) {
+        if (!liveAction && this.executionService.resolveAction) {
             try {
                 // 仅在本包范围内解析动态动作：限定 packageId 前缀，避免全局兜底搜索把
                 // 其他包的动作误计为本包提供者（host 层据此统计候选导致 AMBIGUOUS_ACTION_REF 误报）。
                 const qualifiedId = id.includes("/") ? id : `${this.packageId}/${id}`;
-                const resolution = await this.executionService.runner.resolveAction(qualifiedId);
-                if (resolution.status === "found") {
-                    liveAction = resolution.action;
+                const resolution = await this.executionService.resolveAction(qualifiedId);
+                if (resolution) {
+                    liveAction = resolution;
                 }
             }
             catch {
@@ -283,7 +272,7 @@ export class DefaultActionDockApp {
             };
         }
         if (!spec) {
-            throw new Error(`Action '${id}' not found in package '${this.packageId}'`);
+            throw new ActionDockError(ACTION_NOT_FOUND, `Action '${id}' not found in package '${this.packageId}'`);
         }
         return {
             ...spec,
@@ -305,13 +294,28 @@ export class DefaultActionDockApp {
         const cleanId = id.replace(/\.md$/, "");
         const spec = map.get(cleanId) || map.get(id);
         if (!spec) {
-            throw new Error(`Playbook '${id}' not found in package '${this.packageId}'`);
+            throw new ActionDockError(NOT_FOUND, `Playbook '${id}' not found in package '${this.packageId}'`);
         }
         return {
             ...spec,
             packageId: this.packageId,
         };
     }
+    buildRootInvocationContext(actionId, options) {
+        const rootKey = `${this.packageId}/${actionId}`;
+        return createRootInvocationContext({
+            targetPackage: this.identity,
+            callStack: [rootKey],
+            signal: options?.signal,
+            timeoutMs: options?.timeoutMs,
+            config: options?.config,
+            requestId: options?.requestId,
+            hostSessionId: this.options.hostSessionId,
+            maxCallDepth: this.options.maxCallDepth,
+            logger: this.options.logger,
+            process: this.options.process ?? this.platform.process,
+        });
+    }
     async runAction(id, input, options) {
         let actionId = id;
         if (actionId.includes("/")) {
@@ -319,10 +323,11 @@ export class DefaultActionDockApp {
                 actionId = actionId.slice(this.packageId.length + 1);
             }
             else {
-                throw new Error(`ActionDockApp only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
+                throw new ActionDockError(INVOCATION_UNSUPPORTED, `PackageRuntime only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
             }
         }
-        return this.executionService.execute(actionId, input, options);
+        const context = this.buildRootInvocationContext(actionId, options);
+        return this.executionService.execute(actionId, input, context);
     }
     async startAction(id, input, options) {
         let actionId = id;
@@ -331,10 +336,18 @@ export class DefaultActionDockApp {
                 actionId = actionId.slice(this.packageId.length + 1);
             }
             else {
-                throw new Error(`ActionDockApp only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
+                throw new ActionDockError(INVOCATION_UNSUPPORTED, `PackageRuntime only accepts local action short ID '${id}'. Cross-package invocations must be dispatched via Host invoker.`);
             }
         }
-        return this.executionService.start(actionId, input, options);
+        const context = this.buildRootInvocationContext(actionId, options);
+        return this.executionService.start(actionId, input, context);
+    }
+    async startInvocation(actionId, input, context) {
+        let targetId = actionId;
+        if (targetId.startsWith(`${this.packageId}/`)) {
+            targetId = targetId.slice(this.packageId.length + 1);
+        }
+        return this.executionService.start(targetId, input, context);
     }
     async getRun(runId) {
         return this.executionService.get(runId);
@@ -345,6 +358,16 @@ export class DefaultActionDockApp {
     events(runId, options) {
         return this.executionService.events(runId, options);
     }
+    setActionInvoker(invoker) {
+        if (this.executionService && typeof this.executionService.setActionInvoker === "function") {
+            this.executionService.setActionInvoker(invoker);
+        }
+    }
+    recoverDeadSessionRuns(sessionId) {
+        if (typeof this.storage.recoverDeadSessionRuns === "function") {
+            this.storage.recoverDeadSessionRuns(sessionId);
+        }
+    }
     async listConfig() {
         const declared = this.projectConfig.config || {};
         const stored = this.storage.listConfig();
@@ -383,36 +406,41 @@ export class DefaultActionDockApp {
     /**
      * 状态作用域统一解析辅助函数（单一事实源）。
      *
-     * 完成重载消歧与 actionId 冲突校验，返回最终生效的命名空间：
-     * - actionId 存在时拼 接 `${actionId}:${namespace}` 或直接 actionId；
-     * - 无 actionId 时返回显式 namespace 或空字符串（包级扁平状态）。
+     * 完成重载消歧后委托 mergeStateScope 计算最终生效的命名空间：
+     * - (actionId, key, options) 形态：位置 actionId 参与冲突校验；
+     * - (key, options) 扁平形态：首参是状态键，options.actionId 属合法显式指定。
      */
     resolveStateScope(actionIdOrKey, keyOrOptions, options) {
-        let actionId;
-        let resolvedOpts;
         // 消歧规则（与原始重载语义严格一致）：仅当第二参为字符串时认定为
         // (actionId, key, options) 形态；否则（undefined 或选项对象）认定为
         // (key, options) 扁平调用形态，首参是状态键而非 actionId
         if (typeof keyOrOptions === "string") {
-            actionId = actionIdOrKey;
-            resolvedOpts = options;
-            if (resolvedOpts?.actionId && resolvedOpts.actionId !== actionId) {
-                throw new Error(`Conflicting actionId specified: positional '${actionId}' vs options.actionId '${resolvedOpts.actionId}'`);
+            return { ns: this.mergeStateScope(actionIdOrKey, options), opts: options };
+        }
+        return { ns: this.mergeStateScope(undefined, keyOrOptions), opts: keyOrOptions };
+    }
+    /**
+     * 合并位置 actionId 与 options.actionId 并计算最终命名空间（单一事实源）。
+     *
+     * - positionalActionId 非 undefined：调用形态携带位置 actionId，
+     *   options.actionId 与其冲突时抛出异常（空串同样参与冲突校验）；
+     * - positionalActionId 为 undefined：无位置 actionId 的扁平调用形态，
+     *   options.actionId 属合法显式指定，直接采纳。
+     */
+    mergeStateScope(positionalActionId, opts) {
+        let actionId;
+        if (positionalActionId !== undefined) {
+            actionId = positionalActionId;
+            if (opts?.actionId && opts.actionId !== actionId) {
+                throw new ActionDockError(INVALID_ARGUMENT, `Conflicting actionId specified: positional '${actionId}' vs options.actionId '${opts.actionId}'`);
             }
         }
         else {
-            // (key, options) 扁平调用：首参是状态键，无位置 actionId；
-            // options.actionId 属于合法的显式指定，直接采纳而非判为冲突
-            actionId = "";
-            resolvedOpts = keyOrOptions;
-        }
-        if (!actionId && resolvedOpts?.actionId) {
-            actionId = resolvedOpts.actionId;
+            actionId = opts?.actionId ?? "";
         }
-        const ns = actionId
-            ? (resolvedOpts?.namespace ? `${actionId}:${resolvedOpts.namespace}` : actionId)
-            : (resolvedOpts?.namespace ?? "");
-        return { ns, opts: resolvedOpts };
+        return actionId
+            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
+            : (opts?.namespace ?? "");
     }
     async getState(actionIdOrKey, keyOrOptions, options) {
         const { ns, opts } = this.resolveStateScope(actionIdOrKey, keyOrOptions, options);
@@ -431,18 +459,16 @@ export class DefaultActionDockApp {
         let key;
         let value;
         let opts;
-        let actionId;
+        // 携带位置 actionId 的调用形态标记：undefined 表示扁平 (key, value[, options]) 形态
+        let positionalActionId;
+        // 消歧规则（与原始重载语义严格一致）：按实参个数区分三形态
         if (arguments.length >= 4) {
-            if (options?.actionId && options.actionId !== actionIdOrKey) {
-                throw new Error(`Conflicting actionId specified: positional '${actionIdOrKey}' vs options.actionId '${options.actionId}'`);
-            }
-            actionId = actionIdOrKey;
+            positionalActionId = actionIdOrKey;
             key = keyOrValue;
             value = valueOrOptions;
             opts = options;
         }
         else if (arguments.length === 2) {
-            actionId = "";
             key = actionIdOrKey;
             value = keyOrValue;
             opts = undefined;
@@ -450,16 +476,14 @@ export class DefaultActionDockApp {
         else {
             if (valueOrOptions !== undefined &&
                 (typeof valueOrOptions !== "object" || valueOrOptions === null || Array.isArray(valueOrOptions))) {
-                throw new Error("Invalid options provided to setState. Use setActionState(actionId, key, value, options) or 4-argument setState for action state.");
+                throw new ActionDockError(INVALID_ARGUMENT, "Invalid options provided to setState. Use setActionState(actionId, key, value, options) or 4-argument setState for action state.");
             }
             key = actionIdOrKey;
             value = keyOrValue;
             opts = valueOrOptions;
-            actionId = opts?.actionId ?? "";
         }
-        const ns = actionId
-            ? (opts?.namespace ? `${actionId}:${opts.namespace}` : actionId)
-            : (opts?.namespace ?? "");
+        // 作用域解析与命名空间计算统一委托 mergeStateScope 单一事实源
+        const ns = this.mergeStateScope(positionalActionId, opts);
         if (ns) {
             await this.storage.setState(ns, key, value, opts?.ttl);
             return;
@@ -546,6 +570,25 @@ export class DefaultActionDockApp {
             all: opts?.all,
         });
     }
+    async listRuns(options) {
+        return this.storage.listRuns({
+            actionId: options?.actionId,
+            status: options?.status,
+            limit: options?.limit,
+        });
+    }
+    async clearRuns(options) {
+        return this.storage.clearRuns({
+            actionId: options?.actionId,
+            status: options?.status,
+        });
+    }
+    async listStateEntries(options) {
+        if (typeof this.storage.listStateEntries === "function") {
+            return this.storage.listStateEntries(options);
+        }
+        throw new ActionDockError(CAPABILITY_UNAVAILABLE, `CAPABILITY_UNAVAILABLE: listStateEntries is not supported by package '${this.packageId}' storage`);
+    }
     async close(options) {
         if (this.isClosed)
             return;
@@ -561,19 +604,21 @@ export class DefaultActionDockApp {
                 // 忽略存储重复关闭异常
             }
             finally {
-                try {
-                    this.globalStorage?.close();
-                }
-                catch {
-                    // 忽略全局存储关闭异常
+                if (!this.injectedGlobalStorage) {
+                    try {
+                        this.globalStorage?.close();
+                    }
+                    catch {
+                        // 忽略全局存储关闭异常
+                    }
                 }
             }
         }
     }
 }
 /**
- * 工厂函数：创建并初始化 ActionDockApp 实例。
+ * 工厂函数：创建并初始化 PackageRuntime 实例。
  */
-export async function createActionDockApp(options = {}) {
-    return new DefaultActionDockApp(options);
+export async function createPackageRuntime(options = {}) {
+    return new DefaultPackageRuntime(options);
 }

package/dist/{app → package}/static-index.js

@@ -2,6 +2,44 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { loadPlaybooks } from "../project/loader.js";
 import { loadManifest, MANIFEST_FILE_NAME } from "../project/manifest.js";
+/**
+ * 将增量声明合并到既有 Action 规范之上（纯函数，单一事实源）。
+ *
+ * 优先级语义由调用顺序表达：后层调用时以先层结果作为 base，
+ * 声明值（patch）存在时覆盖，缺省字段回退 base 既有值。
+ */
+function mergeSpec(base, id, packageId, patch, packageRoot, policy = {}) {
+    const { arrayCopy = true, arrayFields = [], deriveFilePath = false, preserveEntry = false } = policy;
+    const merged = {
+        id,
+        packageId,
+        description: patch.description ?? base?.description,
+        inputSchema: patch.inputSchema ?? base?.inputSchema,
+        outputSchema: patch.outputSchema ?? base?.outputSchema,
+        annotations: patch.annotations ?? base?.annotations,
+    };
+    for (const field of arrayFields) {
+        merged[field] = patch[field]
+            ? (arrayCopy ? [...patch[field]] : patch[field])
+            : base?.[field];
+    }
+    if (deriveFilePath) {
+        merged.entry = patch.entry ?? base?.entry;
+        merged.filePath =
+            patch.entry && packageRoot
+                ? resolve(packageRoot, patch.entry)
+                : base?.filePath;
+    }
+    else if (preserveEntry) {
+        merged.entry = base?.entry;
+        merged.filePath = base?.filePath;
+    }
+    else {
+        merged.entry = patch.entry ?? base?.entry;
+        merged.filePath = base?.filePath;
+    }
+    return merged;
+}
 /**
  * 静态读取并聚合指定包的 Action 规范索引。
  * 不产生全量模块导入与执行副作用。
@@ -28,18 +66,15 @@ export function buildStaticActionMap(input) {
                 const manifest = loadManifest(packageRoot);
                 if (manifest?.actions) {
                     for (const [id, item] of Object.entries(manifest.actions)) {
-                        map.set(id, {
-                            id,
-                            packageId,
-                            description: item.description,
-                            inputSchema: item.inputSchema,
-                            outputSchema: item.outputSchema,
-                            tags: item.tags ? [...item.tags] : [],
-                            annotations: item.annotations,
-                            uses: item.uses ? [...item.uses] : [],
-                            entry: item.entry,
-                            filePath: item.entry ? resolve(packageRoot, item.entry) : undefined,
-                        });
+                        // 磁盘清单为最底层来源：无更低层可回退，tags 与 uses 缺省时归一为空数组
+                        map.set(id, mergeSpec(undefined, id, packageId, {
+                            ...item,
+                            tags: item.tags ?? [],
+                            uses: item.uses ?? [],
+                        }, packageRoot, {
+                            arrayFields: ["tags", "uses"],
+                            deriveFilePath: true,
+                        }));
                     }
                 }
             }
@@ -53,21 +88,12 @@ export function buildStaticActionMap(input) {
         const rawActions = projectConfig.actions;
         if (typeof rawActions === "object" && rawActions !== null) {
             for (const [id, item] of Object.entries(rawActions)) {
-                const existing = map.get(id);
-                map.set(id, {
-                    id,
-                    packageId,
-                    description: item.description ?? existing?.description,
-                    inputSchema: item.inputSchema ?? existing?.inputSchema,
-                    outputSchema: item.outputSchema ?? existing?.outputSchema,
-                    tags: item.tags ?? existing?.tags,
-                    annotations: item.annotations ?? existing?.annotations,
-                    uses: item.uses ?? existing?.uses,
-                    entry: item.entry ?? existing?.entry,
-                    filePath: item.entry && packageRoot
-                        ? resolve(packageRoot, item.entry)
-                        : existing?.filePath,
-                });
+                // 配置声明层：覆盖磁盘清单层，entry 变化时重算物理路径；数组字段直传引用
+                map.set(id, mergeSpec(map.get(id), id, packageId, item, packageRoot, {
+                    arrayFields: ["tags", "uses"],
+                    arrayCopy: false,
+                    deriveFilePath: true,
+                }));
             }
         }
     }
@@ -80,20 +106,11 @@ export function buildStaticActionMap(input) {
                 continue;
             }
         }
-        const existing = map.get(id);
-        const actObj = act;
-        map.set(id, {
-            id,
-            packageId,
-            description: actObj.description ?? existing?.description,
-            inputSchema: actObj.inputSchema ?? existing?.inputSchema,
-            outputSchema: actObj.outputSchema ?? existing?.outputSchema,
-            tags: actObj.tags ? [...actObj.tags] : existing?.tags,
-            annotations: actObj.annotations ?? existing?.annotations,
-            uses: actObj.uses ? [...actObj.uses] : existing?.uses,
-            entry: existing?.entry,
-            filePath: existing?.filePath,
-        });
+        // 内存注入层：保留磁盘层解析出的 entry 与 filePath，仅覆盖动态定义相关字段
+        map.set(id, mergeSpec(map.get(id), id, packageId, act, packageRoot, {
+            arrayFields: ["tags", "uses"],
+            preserveEntry: true,
+        }));
     }
     return map;
 }

package/dist/package/storage-view.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeStorage } from "../storage/types.js";
+/**
+ * 构造外部注入 storage 的非接管视图。
+ *
+ * 外部注入的 storage 生命周期由注入方管理，本视图仅委托读写而不接管关闭：
+ * 所有成员函数与属性原样转发到原始实例并绑定原 this，仅 close 收敛为
+ * 显式声明的无操作边界，确保 service.close() 级联关闭时不会误伤外部实例。
+ *
+ * 单一事实源：mcp 适配层与 testing 运行时共同引用，严禁再各自复制 Proxy 包装实现。
+ *
+ * @param storage 外部注入的存储实例
+ */
+export declare function createNonClosingStorageView<T extends RuntimeStorage>(storage: T): T;

package/dist/package/storage-view.js

@@ -0,0 +1,22 @@
+/**
+ * 构造外部注入 storage 的非接管视图。
+ *
+ * 外部注入的 storage 生命周期由注入方管理，本视图仅委托读写而不接管关闭：
+ * 所有成员函数与属性原样转发到原始实例并绑定原 this，仅 close 收敛为
+ * 显式声明的无操作边界，确保 service.close() 级联关闭时不会误伤外部实例。
+ *
+ * 单一事实源：mcp 适配层与 testing 运行时共同引用，严禁再各自复制 Proxy 包装实现。
+ *
+ * @param storage 外部注入的存储实例
+ */
+export function createNonClosingStorageView(storage) {
+    return new Proxy(storage, {
+        get(target, prop) {
+            if (prop === "close") {
+                return () => undefined;
+            }
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}