@logictan/dsh-config-manager 0.1.60

package/lib/schema/config.js

@@ -0,0 +1,165 @@
+/**
+ * 各分区数据结构：ZIP 内 JSON 分区文件 → 解析/校验，以及分区文件路径表。
+ * 类型本体在 types.ts；本文件是「分区数据如何落盘/读回」的唯一出口。
+ */
+import { parseJsonSafe } from '../utils/json.js';
+import { isPathSafe } from '../utils/paths.js';
+/** 全部分区 id（manifest 校验与 adapter registry 共用） */
+export const SECTION_IDS = [
+    'settings', 'ui', 'providers', 'plugins', 'mcp', 'prompts',
+    'skills', 'agentPresets', 'agentInstructions', 'workspaces', 'pluginFiles',
+    'credentialsStatus', 'secrets', 'sessions', 'self',
+];
+/** JSON 分区在 ZIP 内的相对路径；文件类分区（skills 等）走目录前缀，不在此表 */
+export const SECTION_JSON_PATHS = {
+    settings: 'config/settings.json',
+    ui: 'config/ui.json',
+    providers: 'ai/providers.json',
+    plugins: 'plugins/plugins.json',
+    mcp: 'mcp/servers.json',
+    prompts: 'custom/prompts.json',
+    workspaces: 'workspaces/workspaces.json',
+    credentialsStatus: 'security/credentials.json',
+};
+/** 文件类分区在 ZIP 内的目录前缀 */
+export const SECTION_FILE_PREFIXES = {
+    skills: 'custom/skills/',
+    agentPresets: 'agents/presets/',
+    agentInstructions: 'custom/agent-instructions/',
+    pluginFiles: 'plugin-files/',
+    sessions: 'sessions/',
+    self: 'self/',
+};
+/** 该分区是否是「文件类」分区（ZIP 内以真实文件存放而非 JSON） */
+export function isFileSection(sectionId) {
+    return sectionId in SECTION_FILE_PREFIXES;
+}
+/** 从 ZIP 内 JSON 解析分区数据（深度保护 + 结构校验） */
+export function parseSectionJson(sectionId, raw) {
+    const parsed = parseJsonSafe(raw);
+    const issues = validateSectionData(sectionId, parsed);
+    const errors = issues.filter((i) => i.severity === 'error');
+    if (errors.length > 0) {
+        throw new Error(`分区 ${sectionId} 数据无效: ${errors.map((e) => e.message).join('; ')}`);
+    }
+    return parsed;
+}
+/** 分区数据结构基础校验（version 字段 + 顶层形状） */
+export function validateSectionData(sectionId, data) {
+    const issues = [];
+    if (data === null || typeof data !== 'object') {
+        return [{ path: '$', message: `分区 ${sectionId} 数据必须是对象`, severity: 'error' }];
+    }
+    const obj = data;
+    if (obj['version'] !== 1) {
+        issues.push({ path: 'version', message: `分区 ${sectionId} 的 version 必须为 1（收到 ${String(obj['version'])}）`, severity: 'error' });
+        return issues;
+    }
+    switch (sectionId) {
+        case 'settings':
+        case 'ui': {
+            const ns = obj['namespaces'];
+            if (ns === null || typeof ns !== 'object') {
+                issues.push({ path: 'namespaces', message: `分区 ${sectionId} 缺少 namespaces 对象`, severity: 'error' });
+            }
+            else {
+                for (const [name, rec] of Object.entries(ns)) {
+                    if (rec === null || typeof rec !== 'object') {
+                        issues.push({ path: `namespaces.${name}`, message: 'namespace 记录必须是对象', severity: 'error' });
+                        continue;
+                    }
+                    const r = rec;
+                    if (typeof r['revision'] !== 'number')
+                        issues.push({ path: `namespaces.${name}.revision`, message: 'revision 必须是数字', severity: 'error' });
+                    if (!('value' in r))
+                        issues.push({ path: `namespaces.${name}.value`, message: '缺少 value', severity: 'error' });
+                    const secrets = r['secrets'];
+                    if (secrets !== undefined && !Array.isArray(secrets))
+                        issues.push({ path: `namespaces.${name}.secrets`, message: 'secrets 必须是数组', severity: 'error' });
+                }
+            }
+            break;
+        }
+        case 'providers': {
+            const p = obj['providers'];
+            if (p === null || typeof p !== 'object')
+                issues.push({ path: 'providers', message: '缺少 providers 对象', severity: 'error' });
+            break;
+        }
+        case 'plugins': {
+            if (!Array.isArray(obj['plugins']))
+                issues.push({ path: 'plugins', message: 'plugins 必须是数组', severity: 'error' });
+            if (obj['patch'] !== undefined && !Array.isArray(obj['patch']))
+                issues.push({ path: 'patch', message: 'patch 必须是数组', severity: 'error' });
+            // issue #35：patchFiles 会被写到 <home>/profiles/<profile>/<relativePath>，必须逐项校验
+            // （不可信 bundle 的路径穿越向量——与 file 类分区同级的防线）。
+            const patchFiles = obj['patchFiles'];
+            if (patchFiles !== undefined) {
+                if (!Array.isArray(patchFiles)) {
+                    issues.push({ path: 'patchFiles', message: 'patchFiles 必须是数组', severity: 'error' });
+                }
+                else {
+                    patchFiles.forEach((pf, i) => {
+                        const rec = (pf !== null && typeof pf === 'object') ? pf : null;
+                        if (rec === null) {
+                            issues.push({ path: `patchFiles[${i}]`, message: 'patch 文件条目必须是对象', severity: 'error' });
+                            return;
+                        }
+                        const rel = rec['relativePath'];
+                        if (typeof rel !== 'string' || rel === '' || !isPathSafe(rel)) {
+                            issues.push({ path: `patchFiles[${i}].relativePath`, message: 'patch 文件路径必须是安全的相对路径（不得为绝对路径或含 ..）', severity: 'error' });
+                        }
+                        if (typeof rec['base64'] !== 'string') {
+                            issues.push({ path: `patchFiles[${i}].base64`, message: 'patch 文件内容必须是 base64 字符串', severity: 'error' });
+                        }
+                    });
+                }
+            }
+            break;
+        }
+        case 'mcp': {
+            if (!Array.isArray(obj['servers']))
+                issues.push({ path: 'servers', message: 'servers 必须是数组', severity: 'error' });
+            break;
+        }
+        case 'prompts': {
+            if (!Array.isArray(obj['prompts']))
+                issues.push({ path: 'prompts', message: 'prompts 必须是数组', severity: 'error' });
+            break;
+        }
+        case 'workspaces': {
+            if (!Array.isArray(obj['workspaces']))
+                issues.push({ path: 'workspaces', message: 'workspaces 必须是数组', severity: 'error' });
+            break;
+        }
+        case 'credentialsStatus': {
+            if (!Array.isArray(obj['credentials']))
+                issues.push({ path: 'credentials', message: 'credentials 必须是数组', severity: 'error' });
+            break;
+        }
+        case 'skills':
+        case 'agentPresets':
+        case 'agentInstructions':
+        case 'pluginFiles':
+        case 'sessions':
+        case 'self': {
+            if (!Array.isArray(obj['files']))
+                issues.push({ path: 'files', message: 'files 必须是数组', severity: 'error' });
+            break;
+        }
+        default:
+            issues.push({ path: '$', message: `未知分区 ${sectionId}`, severity: 'error' });
+    }
+    return issues;
+}
+/** 分区 JSON 载荷的类型收窄（供 adapter / analyzer 使用） */
+export function asSettingsSection(data) { return data; }
+export function asUiSection(data) { return data; }
+export function asProvidersSection(data) { return data; }
+export function asPluginsSection(data) { return data; }
+export function asMcpSection(data) { return data; }
+export function asPromptsSection(data) { return data; }
+export function asWorkspacesSection(data) { return data; }
+export function asCredentialsSection(data) { return data; }
+export function asFilesSection(data) { return data; }
+//# sourceMappingURL=config.js.map

package/lib/schema/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `dsh-config-manager/schema` 的运行时入口（`exports["./schema"]`）。
+ *
+ * 定位：**零 DSH 依赖、零 `node:` 依赖**的 schema 公共面。第三方在不安装
+ * 任何 `@deepseek-ai/*`、React 或 Node 内建模块的前提下，即可：
+ *  - 判定 `manifest.schemaVersion` 的兼容性（`isCurrent` / `isSupported` / `needsMigration` /
+ *    `isTooNew` / `canImport` / `describeVersion` / `UnsupportedSchemaError`）；
+ *  - 取到 `SECTION_IDS` / `SECTION_JSON_PATHS` / `SECTION_FILE_PREFIXES` / `isFileSection`，
+ *    据此实现自己的 importer / exporter（ZIP 内路径与文件类分区前缀的唯一权威）；
+ *  - 引用 Bundle Format v1 的全部载荷类型。
+ *
+ * 为什么需要它：此前的 `exports["./schema"]` 指向 `./lib/schema/types.js`，而 `types.ts`
+ * 是**纯类型文件**——编译产物是一个**空模块**（运行时零导出）。第三方
+ * `import('dsh-config-manager/schema')` 只会拿到 `{}`，`CURRENT_SCHEMA_VERSION` 等
+ * 版本工具**在包外无法导入**（它们定义在 `./versions.ts`，不在任何 exports 映射内）。
+ * 本文件把 `./schema` 变成真实可用的运行时入口。
+ *
+ * 约束（勿破）：本文件只 import 同目录模块（`./config.ts` / `./types.ts` / `./versions.ts`）。
+ * 不 import `../core/*`、不 import `node:*`、不 import 任何 UI / DSH 包——否则会破坏
+ * headless 消费（见 `docs/spec/headless-consumption.md`）与 `tests/architecture-boundaries.test.ts`。
+ */
+export { CURRENT_SCHEMA_VERSION, MIN_SUPPORTED_SCHEMA_VERSION, UnsupportedSchemaError, isCurrent, isSupported, needsMigration, isTooNew, canImport, describeVersion, } from './versions.ts';
+export { SECTION_IDS, SECTION_JSON_PATHS, SECTION_FILE_PREFIXES, isFileSection, } from './config.ts';
+export type { Platform, SectionId, EncryptionInfo, Manifest, NamespaceRecord, SettingsSection, UiMigrationNote, UiSection, ProviderEntry, ProvidersSection, PluginEntry, PatchLine, LocalPluginTarball, PluginsSection, McpServerEntry, McpSection, PromptEntry, PromptsSection, WorkspaceRecord, WorkspacesSection, CredentialStatus, CredentialsSection, FileEntry, FilesSection, SectionData, } from './types.ts';

package/lib/schema/index.js

@@ -0,0 +1,26 @@
+/**
+ * `dsh-config-manager/schema` 的运行时入口（`exports["./schema"]`）。
+ *
+ * 定位：**零 DSH 依赖、零 `node:` 依赖**的 schema 公共面。第三方在不安装
+ * 任何 `@deepseek-ai/*`、React 或 Node 内建模块的前提下，即可：
+ *  - 判定 `manifest.schemaVersion` 的兼容性（`isCurrent` / `isSupported` / `needsMigration` /
+ *    `isTooNew` / `canImport` / `describeVersion` / `UnsupportedSchemaError`）；
+ *  - 取到 `SECTION_IDS` / `SECTION_JSON_PATHS` / `SECTION_FILE_PREFIXES` / `isFileSection`，
+ *    据此实现自己的 importer / exporter（ZIP 内路径与文件类分区前缀的唯一权威）；
+ *  - 引用 Bundle Format v1 的全部载荷类型。
+ *
+ * 为什么需要它：此前的 `exports["./schema"]` 指向 `./lib/schema/types.js`，而 `types.ts`
+ * 是**纯类型文件**——编译产物是一个**空模块**（运行时零导出）。第三方
+ * `import('dsh-config-manager/schema')` 只会拿到 `{}`，`CURRENT_SCHEMA_VERSION` 等
+ * 版本工具**在包外无法导入**（它们定义在 `./versions.ts`，不在任何 exports 映射内）。
+ * 本文件把 `./schema` 变成真实可用的运行时入口。
+ *
+ * 约束（勿破）：本文件只 import 同目录模块（`./config.ts` / `./types.ts` / `./versions.ts`）。
+ * 不 import `../core/*`、不 import `node:*`、不 import 任何 UI / DSH 包——否则会破坏
+ * headless 消费（见 `docs/spec/headless-consumption.md`）与 `tests/architecture-boundaries.test.ts`。
+ */
+/* —— 版本判定（唯一出口，业务代码零散落 `if (v === 1)`） —— */
+export { CURRENT_SCHEMA_VERSION, MIN_SUPPORTED_SCHEMA_VERSION, UnsupportedSchemaError, isCurrent, isSupported, needsMigration, isTooNew, canImport, describeVersion, } from './versions.js';
+/* —— 分区表（第三方实现 importer/exporter 的路径权威） —— */
+export { SECTION_IDS, SECTION_JSON_PATHS, SECTION_FILE_PREFIXES, isFileSection, } from './config.js';
+//# sourceMappingURL=index.js.map

package/lib/schema/manifest.d.ts

@@ -0,0 +1,28 @@
+import type { Manifest, Platform, SectionId } from './types.ts';
+export declare const MANIFEST_FILE = "manifest.json";
+export declare const CHECKSUMS_FILE = "integrity/checksums.json";
+export declare const EXPORTER_NAME = "DSH Config Manager";
+export interface BuildManifestInput {
+    exporterVersion: string;
+    dshVersion: string;
+    platform: Platform;
+    arch: string;
+    sections: Record<SectionId, boolean>;
+    containsSecrets: boolean;
+    encrypted: boolean;
+    encryption: Manifest['security']['encryption'];
+    exportedAt?: string;
+}
+/** 构造 manifest（schemaVersion 恒为当前版本，集中于此） */
+export declare function buildManifest(input: BuildManifestInput): Manifest;
+/** 序列化（pretty JSON，供 ZIP 内 manifest.json） */
+export declare function serializeManifest(manifest: Manifest): string;
+/** 解析 + 结构校验；非法输入抛错（导入第一道闸之一） */
+export declare function parseManifest(raw: string): Manifest;
+export interface ManifestIssue {
+    path: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+/** 结构校验：字段类型 / sections 键集合 / security 形状 */
+export declare function validateManifest(m: unknown): ManifestIssue[];

package/lib/schema/manifest.js

@@ -0,0 +1,109 @@
+/**
+ * manifest.json 的类型、解析、序列化与结构校验。
+ * 类型本体在 types.ts（§13.1）；本文件负责 manifest 的读写与结构完整性。
+ */
+import { parseJsonSafe } from '../utils/json.js';
+import { CURRENT_SCHEMA_VERSION } from './versions.js';
+import { SECTION_IDS } from './config.js';
+export const MANIFEST_FILE = 'manifest.json';
+export const CHECKSUMS_FILE = 'integrity/checksums.json';
+export const EXPORTER_NAME = 'DSH Config Manager';
+/** 构造 manifest（schemaVersion 恒为当前版本，集中于此） */
+export function buildManifest(input) {
+    return {
+        schemaVersion: CURRENT_SCHEMA_VERSION,
+        exporter: { name: EXPORTER_NAME, version: input.exporterVersion },
+        source: {
+            dshVersion: input.dshVersion,
+            platform: input.platform,
+            arch: input.arch,
+        },
+        exportedAt: input.exportedAt ?? new Date().toISOString(),
+        sections: input.sections,
+        security: {
+            containsSecrets: input.containsSecrets,
+            encrypted: input.encrypted,
+            encryption: input.encryption,
+        },
+    };
+}
+/** 序列化（pretty JSON，供 ZIP 内 manifest.json） */
+export function serializeManifest(manifest) {
+    return JSON.stringify(manifest, null, 2);
+}
+/** 解析 + 结构校验；非法输入抛错（导入第一道闸之一） */
+export function parseManifest(raw) {
+    const parsed = parseJsonSafe(raw);
+    const issues = validateManifest(parsed);
+    const errors = issues.filter((i) => i.severity === 'error');
+    if (errors.length > 0) {
+        throw new Error(`manifest.json 无效: ${errors.map((e) => e.message).join('; ')}`);
+    }
+    return parsed;
+}
+/** 结构校验：字段类型 / sections 键集合 / security 形状 */
+export function validateManifest(m) {
+    const issues = [];
+    if (m === null || typeof m !== 'object') {
+        return [{ path: '$', message: 'manifest 必须是对象', severity: 'error' }];
+    }
+    const obj = m;
+    if (typeof obj['schemaVersion'] !== 'number') {
+        issues.push({ path: 'schemaVersion', message: 'schemaVersion 必须是数字', severity: 'error' });
+    }
+    const exporter = obj['exporter'];
+    if (!exporter || typeof exporter !== 'object') {
+        issues.push({ path: 'exporter', message: 'exporter 缺失', severity: 'error' });
+    }
+    else {
+        if (typeof exporter['name'] !== 'string')
+            issues.push({ path: 'exporter.name', message: 'exporter.name 必须是字符串', severity: 'error' });
+        if (typeof exporter['version'] !== 'string')
+            issues.push({ path: 'exporter.version', message: 'exporter.version 必须是字符串', severity: 'error' });
+    }
+    const source = obj['source'];
+    if (!source || typeof source !== 'object') {
+        issues.push({ path: 'source', message: 'source 缺失', severity: 'error' });
+    }
+    else {
+        if (typeof source['dshVersion'] !== 'string')
+            issues.push({ path: 'source.dshVersion', message: 'source.dshVersion 必须是字符串', severity: 'error' });
+        if (typeof source['platform'] !== 'string')
+            issues.push({ path: 'source.platform', message: 'source.platform 必须是字符串', severity: 'error' });
+        if (typeof source['arch'] !== 'string')
+            issues.push({ path: 'source.arch', message: 'source.arch 必须是字符串', severity: 'error' });
+    }
+    if (typeof obj['exportedAt'] !== 'string' || Number.isNaN(Date.parse(obj['exportedAt']))) {
+        issues.push({ path: 'exportedAt', message: 'exportedAt 必须是合法 ISO-8601 时间', severity: 'error' });
+    }
+    const sections = obj['sections'];
+    if (!sections || typeof sections !== 'object') {
+        issues.push({ path: 'sections', message: 'sections 缺失', severity: 'error' });
+    }
+    else {
+        for (const key of Object.keys(sections)) {
+            if (!SECTION_IDS.includes(key)) {
+                issues.push({ path: `sections.${key}`, message: `未知分区 "${key}"`, severity: 'warning' });
+            }
+            if (typeof sections[key] !== 'boolean') {
+                issues.push({ path: `sections.${key}`, message: `sections.${key} 必须是布尔`, severity: 'error' });
+            }
+        }
+    }
+    const security = obj['security'];
+    if (!security || typeof security !== 'object') {
+        issues.push({ path: 'security', message: 'security 缺失', severity: 'error' });
+    }
+    else {
+        if (typeof security['containsSecrets'] !== 'boolean')
+            issues.push({ path: 'security.containsSecrets', message: 'containsSecrets 必须是布尔', severity: 'error' });
+        if (typeof security['encrypted'] !== 'boolean')
+            issues.push({ path: 'security.encrypted', message: 'encrypted 必须是布尔', severity: 'error' });
+        const enc = security['encryption'];
+        if (enc !== null && (typeof enc !== 'object' || enc === undefined)) {
+            issues.push({ path: 'security.encryption', message: 'encryption 必须是对象或 null', severity: 'error' });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=manifest.js.map

package/lib/schema/tombstones.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 删除墓碑（tombstone）机制（F4）：记录用户明确删除的条目，
+ * 导入/恢复时据此过滤，防止「旧备份复活已删条目」。
+ *
+ * 设计（借鉴 uagent-sync workspace-state-codec）：墓碑按 kind+id 去重，
+ * 过滤时把恢复数据里的条目映射为 {kind, id} 键，命中墓碑的条目剔除。
+ *
+ * 持久化：<dataDir>/tombstones.json（self 分区数据目录 $DSH_HOME/dsh-config-manager/ 下）。
+ * 本模块零依赖（不 import node 模块 / 核心层类型），fs 由调用方注入，
+ * 纯逻辑可独立测试；dataDir 与文件名形态由调用方保持一致。
+ *
+ * 安全语义：墓碑文件缺失/损坏一律安全降级为空列表（尽力而为的过滤，
+ * 绝不因墓碑文件问题阻塞导入主流程）。
+ */
+/** 墓碑条目类型：插件 / 技能（skills 分区文件）/ 整个分区 / 其他文件（agentPresets 等文件类分区） */
+export type TombstoneKind = 'plugin' | 'skill' | 'section' | 'file';
+export interface Tombstone {
+    kind: TombstoneKind;
+    /** 该类型内的标识：插件 → 包名；技能/文件 → 相对路径；分区 → SectionId */
+    id: string;
+    /** 删除时间（ISO-8601 UTC） */
+    deletedAt: string;
+    /** 删除原因（用户可读，可选） */
+    reason?: string;
+}
+/** 墓碑持久化文件名（位于 <dataDir>/ 下） */
+export declare const TOMBSTONES_FILE = "tombstones.json";
+/** 墓碑持久化所需的最小 fs 门面（结构化兼容 HostContext.fs / 测试内存实现） */
+export interface TombstoneFs {
+    readFile(relPath: string): Promise<Uint8Array>;
+    writeFile(relPath: string, data: Uint8Array): Promise<void>;
+}
+/** 注册墓碑：按 kind+id 去重（同键已存在 → 用新条目替换，保留最新 deletedAt/reason）；返回新数组 */
+export declare function addTombstone(list: Tombstone[], entry: Tombstone): Tombstone[];
+/** 某条目（kind+id）是否已被墓碑覆盖 */
+export declare function isTombstoned(kind: TombstoneKind, id: string, tombstones: readonly Tombstone[]): boolean;
+/** 过滤 {kind,id} 形态数组：剔除墓碑命中的条目，保留其余（返回新数组，不改原数组）。
+ *  非 TombstoneKind 的 kind（如导入计划项的 Install/Update 等）永远不会误命中。 */
+export declare function filterTombstoned<T extends {
+    kind: string;
+    id: string;
+}>(items: readonly T[], tombstones: readonly Tombstone[]): T[];
+/** 读取 <dataDir>/tombstones.json；文件不存在 / 解析失败 / 结构非法 → []（安全降级，不抛错） */
+export declare function loadTombstones(fs: TombstoneFs, dataDir: string): Promise<Tombstone[]>;
+/** 写入 <dataDir>/tombstones.json（覆盖写；dataDir 目录由调用方保证可写） */
+export declare function saveTombstones(fs: TombstoneFs, dataDir: string, list: Tombstone[]): Promise<void>;

package/lib/schema/tombstones.js

@@ -0,0 +1,64 @@
+/**
+ * 删除墓碑（tombstone）机制（F4）：记录用户明确删除的条目，
+ * 导入/恢复时据此过滤，防止「旧备份复活已删条目」。
+ *
+ * 设计（借鉴 uagent-sync workspace-state-codec）：墓碑按 kind+id 去重，
+ * 过滤时把恢复数据里的条目映射为 {kind, id} 键，命中墓碑的条目剔除。
+ *
+ * 持久化：<dataDir>/tombstones.json（self 分区数据目录 $DSH_HOME/dsh-config-manager/ 下）。
+ * 本模块零依赖（不 import node 模块 / 核心层类型），fs 由调用方注入，
+ * 纯逻辑可独立测试；dataDir 与文件名形态由调用方保持一致。
+ *
+ * 安全语义：墓碑文件缺失/损坏一律安全降级为空列表（尽力而为的过滤，
+ * 绝不因墓碑文件问题阻塞导入主流程）。
+ */
+/** 墓碑持久化文件名（位于 <dataDir>/ 下） */
+export const TOMBSTONES_FILE = 'tombstones.json';
+/** 注册墓碑：按 kind+id 去重（同键已存在 → 用新条目替换，保留最新 deletedAt/reason）；返回新数组 */
+export function addTombstone(list, entry) {
+    const idx = list.findIndex((t) => t.kind === entry.kind && t.id === entry.id);
+    if (idx === -1)
+        return [...list, entry];
+    const next = [...list];
+    next[idx] = entry;
+    return next;
+}
+/** 某条目（kind+id）是否已被墓碑覆盖 */
+export function isTombstoned(kind, id, tombstones) {
+    return tombstones.some((t) => t.kind === kind && t.id === id);
+}
+/** 过滤 {kind,id} 形态数组：剔除墓碑命中的条目，保留其余（返回新数组，不改原数组）。
+ *  非 TombstoneKind 的 kind（如导入计划项的 Install/Update 等）永远不会误命中。 */
+export function filterTombstoned(items, tombstones) {
+    if (tombstones.length === 0)
+        return [...items];
+    return items.filter((item) => !isTombstoned(item.kind, item.id, tombstones));
+}
+/** 读取 <dataDir>/tombstones.json；文件不存在 / 解析失败 / 结构非法 → []（安全降级，不抛错） */
+export async function loadTombstones(fs, dataDir) {
+    try {
+        const raw = await fs.readFile(`${dataDir}/${TOMBSTONES_FILE}`);
+        const parsed = JSON.parse(new TextDecoder().decode(raw));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter(isTombstone);
+    }
+    catch {
+        return [];
+    }
+}
+/** 写入 <dataDir>/tombstones.json（覆盖写；dataDir 目录由调用方保证可写） */
+export async function saveTombstones(fs, dataDir, list) {
+    const payload = JSON.stringify(list, null, 2);
+    await fs.writeFile(`${dataDir}/${TOMBSTONES_FILE}`, new TextEncoder().encode(payload));
+}
+/** 形状校验：逐条过滤非法条目（容忍部分损坏，保留合法项） */
+function isTombstone(v) {
+    if (v === null || typeof v !== 'object')
+        return false;
+    const t = v;
+    return ((t['kind'] === 'plugin' || t['kind'] === 'skill' || t['kind'] === 'section' || t['kind'] === 'file')
+        && typeof t['id'] === 'string' && t['id'] !== ''
+        && typeof t['deletedAt'] === 'string');
+}
+//# sourceMappingURL=tombstones.js.map