@webskill/sdk 0.0.6 → 0.1.1

package/dist/memoryArtifactStore-C9lFVqPF-U8nXvqL9.js

@@ -0,0 +1,637 @@
+import { parse } from "yaml";
+import { zipSync } from "fflate";
+
+//#region ../core/dist/index.js
+/**
+* 所有公开 API 抛出的结构化错误，code 供上层可编程处理
+* @stable
+*/
+var WebSkillError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "WebSkillError";
+		this.code = code;
+		this.details = details;
+	}
+};
+/** 技能目录内的安装清单文件名（不参与 files 列表与 digest） */
+const SKILL_MANIFEST_FILE = "webskill.skill-manifest.json";
+/** managed root 下的锁定文件名（不参与 files 列表与 digest） */
+const SKILLS_LOCKFILE = "skills.lock.json";
+/** 整体 digest：逐文件 "<path>:<sha256>\n" 拼接串（文件按 path 排序）的 sha256（hash 由调用方提供，可为 WebCrypto 异步实现） */
+async function computeDigest(files, sha256) {
+	return sha256([...files].sort((a, b) => a.path.localeCompare(b.path)).map((f) => `${f.path}:${f.sha256}\n`).join(""));
+}
+/** 由逐文件清单构建 manifest（digest 由 computeDigest 计算） */
+async function buildManifest(input) {
+	return {
+		schemaVersion: 1,
+		name: input.name,
+		...input.version !== void 0 ? { version: input.version } : {},
+		source: input.source,
+		installedAt: input.installedAt,
+		integrity: {
+			algorithm: "sha256",
+			digest: await computeDigest(input.files, input.sha256)
+		},
+		files: input.files
+	};
+}
+/** 按 manifest.files 比对实际 hash（调用方负责计算 actualHashes） */
+function verifyManifest(manifest, actualHashes) {
+	const mismatches = [];
+	for (const file of manifest.files) {
+		const actual = actualHashes.get(file.path);
+		if (actual === void 0 || actual !== file.sha256) mismatches.push(file.path);
+	}
+	return {
+		ok: mismatches.length === 0,
+		mismatches
+	};
+}
+const ROOT = "/";
+/** 内存文件系统：路径一律规范化为 `/` 分隔，写入自动创建父目录 */
+var MemoryFS = class {
+	kind = "memory";
+	#entries = /* @__PURE__ */ new Map();
+	constructor() {
+		this.#entries.set(ROOT, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	#normalize(path) {
+		const out = [];
+		for (const seg of path.replace(/\\/g, "/").split("/")) {
+			if (seg === "" || seg === ".") continue;
+			if (seg === "..") out.pop();
+			else out.push(seg);
+		}
+		return ROOT + out.join("/");
+	}
+	#parentOf(key) {
+		const i = key.lastIndexOf("/");
+		return i <= 0 ? ROOT : key.slice(0, i);
+	}
+	#ensureParents(key) {
+		const chain = [];
+		let dir = this.#parentOf(key);
+		while (!this.#entries.has(dir)) {
+			chain.push(dir);
+			dir = this.#parentOf(dir);
+		}
+		for (const d of chain.reverse()) this.#entries.set(d, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	#getFile(key) {
+		const entry = this.#entries.get(key);
+		if (!entry || entry.type !== "file") throw new WebSkillError("FS_NOT_FOUND", `File not found: ${key}`);
+		return entry;
+	}
+	#getDirectory(key) {
+		const entry = this.#entries.get(key);
+		if (!entry || entry.type !== "directory") throw new WebSkillError("FS_NOT_FOUND", `Directory not found: ${key}`);
+		return entry;
+	}
+	async readText(path) {
+		return new TextDecoder().decode(this.#getFile(this.#normalize(path)).content);
+	}
+	async writeText(path, content) {
+		await this.writeBinary(path, new TextEncoder().encode(content));
+	}
+	async readBinary(path) {
+		return this.#getFile(this.#normalize(path)).content;
+	}
+	async writeBinary(path, content) {
+		const key = this.#normalize(path);
+		this.#ensureParents(key);
+		this.#entries.set(key, {
+			type: "file",
+			content,
+			mtimeMs: Date.now()
+		});
+	}
+	async exists(path) {
+		return this.#entries.has(this.#normalize(path));
+	}
+	async stat(path) {
+		const key = this.#normalize(path);
+		const entry = this.#entries.get(key);
+		if (!entry) throw new WebSkillError("FS_NOT_FOUND", `Path not found: ${key}`);
+		return {
+			path: key,
+			type: entry.type,
+			size: entry.type === "file" ? entry.content.length : void 0,
+			mtimeMs: entry.mtimeMs
+		};
+	}
+	async list(path) {
+		const key = this.#normalize(path);
+		this.#getDirectory(key);
+		const prefix = key === ROOT ? ROOT : key + "/";
+		const out = [];
+		for (const [k, entry] of this.#entries) {
+			if (k === key || !k.startsWith(prefix)) continue;
+			if (k.slice(prefix.length).includes("/")) continue;
+			out.push({
+				path: k,
+				type: entry.type,
+				size: entry.type === "file" ? entry.content.length : void 0,
+				mtimeMs: entry.mtimeMs
+			});
+		}
+		return out;
+	}
+	async mkdir(path) {
+		const key = this.#normalize(path);
+		if (this.#entries.has(key)) return;
+		this.#ensureParents(key);
+		this.#entries.set(key, {
+			type: "directory",
+			content: /* @__PURE__ */ new Uint8Array(0),
+			mtimeMs: Date.now()
+		});
+	}
+	async remove(path, options) {
+		const key = this.#normalize(path);
+		if (!this.#entries.get(key)) throw new WebSkillError("FS_NOT_FOUND", `Path not found: ${key}`);
+		if (key === ROOT) throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", "Cannot delete root directory");
+		const prefix = key + "/";
+		const descendants = [...this.#entries.keys()].filter((k) => k.startsWith(prefix));
+		if (descendants.length > 0 && !options?.recursive) throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", `Directory not empty, use recursive: ${key}`);
+		for (const k of descendants) this.#entries.delete(k);
+		this.#entries.delete(key);
+	}
+};
+/** 统一分隔符为 `/`，去除 `.` 段与重复分隔符（不解析 `..`） */
+function normalizePath(path) {
+	return path.replace(/\\/g, "/").split("/").filter((s) => s !== "" && s !== ".").join("/");
+}
+/**
+* 将相对路径安全地解析到 root 之内。
+* 拒绝空路径、绝对路径（`/`、`\\`、`C:\` 形式）与任何 `..` 段。
+*/
+function resolveInsideRoot(root, relativePath) {
+	const fail = (reason) => {
+		throw new WebSkillError("FS_PATH_OUTSIDE_ROOT", `Path outside root: ${reason} (path: ${JSON.stringify(relativePath)})`);
+	};
+	if (relativePath.trim() === "") fail("empty path");
+	if (relativePath.startsWith("/") || relativePath.startsWith("\\") || /^[a-zA-Z]:[\\/]/.test(relativePath)) fail("absolute paths not allowed");
+	const segments = relativePath.replace(/\\/g, "/").split("/");
+	if (segments.some((s) => s === "..")) fail("`..` segments not allowed");
+	const clean = segments.filter((s) => s !== "" && s !== ".");
+	if (clean.length === 0) fail("path resolves to empty");
+	const normalizedRoot = normalizePath(root);
+	const joined = normalizedRoot === "" ? clean.join("/") : `${normalizedRoot}/${clean.join("/")}`;
+	return root.startsWith("/") || root.startsWith("\\") ? `/${joined}` : joined;
+}
+const FRONTMATTER_RE = /^---[^\S\r\n]*\r?\n([\s\S]*?)\r?\n---[^\S\r\n]*(?:\r?\n|$)([\s\S]*)$/;
+const invalid = (message, details) => {
+	throw new WebSkillError("SKILL_INVALID_METADATA", message, details);
+};
+function parseSkillMarkdown(raw) {
+	const match = FRONTMATTER_RE.exec(raw);
+	if (!match) invalid("SKILL.md missing YAML frontmatter (must start with a `---` line)");
+	const [, yamlText, bodyRaw] = match;
+	let data;
+	try {
+		data = parse(yamlText);
+	} catch (cause) {
+		invalid("frontmatter YAML parse failed", cause);
+	}
+	if (typeof data !== "object" || data === null || Array.isArray(data)) invalid("frontmatter must be a YAML object");
+	const metadata = data;
+	if (typeof metadata["name"] !== "string" || metadata["name"].trim() === "") invalid("frontmatter missing required `name` field");
+	if (typeof metadata["description"] !== "string" || metadata["description"].trim() === "") invalid("frontmatter missing required `description` field");
+	return {
+		metadata,
+		body: bodyRaw.trim()
+	};
+}
+const SKILL_NAME_MAX_LENGTH = 64;
+/** Agent Skills 官方命名规范：小写字母/数字/连字符，不允许首尾或连续连字符 */
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function isValidSkillName(name) {
+	return name.length <= 64 && SKILL_NAME_PATTERN.test(name);
+}
+const SCRIPT_EXTENSION_RE = /\.(ts|js)$/;
+/** D2 schema sidecar（scripts/<name>.schema.json）属于协议内文件，不算非法脚本 */
+const SCHEMA_SIDECAR_RE = /\.schema\.json$/;
+/**
+* 技能合规规则的唯一实现。SkillDiscovery 与 validateSkills 都必须调用本函数，
+* 禁止各自重复实现规则（避免两套规则漂移）。
+*/
+function checkSkillRules(input) {
+	const { dirName } = input;
+	if (!input.hasSkillMd) return [{
+		code: "SKILL_NOT_FOUND",
+		severity: "warning",
+		message: `Directory ${dirName} missing SKILL.md, not treated as a skill, skipped`
+	}];
+	if (input.parseError) return [{
+		code: input.parseError.code,
+		severity: "error",
+		message: `SKILL.md parse failed for directory ${dirName}: ${input.parseError.message}`
+	}];
+	const issues = [];
+	const metadata = input.metadata;
+	if (metadata) {
+		if (!isValidSkillName(metadata.name)) issues.push({
+			code: "SKILL_INVALID_NAME",
+			severity: "error",
+			message: `Skill name ${JSON.stringify(metadata.name)} does not conform to naming convention (lowercase letters/digits/hyphens, ≤64 chars)`
+		});
+		if (metadata.name !== dirName) issues.push({
+			code: "SKILL_INVALID_NAME",
+			severity: "error",
+			message: `Skill name ${JSON.stringify(metadata.name)} does not match directory name ${JSON.stringify(dirName)}`
+		});
+		if (input.existingNames?.has(metadata.name)) issues.push({
+			code: "SKILL_DUPLICATE_NAME",
+			severity: "error",
+			message: `Duplicate skill name ${JSON.stringify(metadata.name)}`
+		});
+	}
+	for (const fileName of input.scriptFileNames ?? []) if (!SCRIPT_EXTENSION_RE.test(fileName) && !SCHEMA_SIDECAR_RE.test(fileName)) issues.push({
+		code: "SKILL_UNSUPPORTED_SCRIPT",
+		severity: "error",
+		message: `Unsupported script file in scripts/ of directory ${dirName}: ${fileName} (only .ts/.js and .schema.json sidecars allowed)`
+	});
+	const allowedTools = metadata?.["allowed-tools"];
+	if (Array.isArray(allowedTools)) {
+		const scriptNames = new Set((input.scriptFileNames ?? []).filter((f) => SCRIPT_EXTENSION_RE.test(f)).map((f) => f.replace(SCRIPT_EXTENSION_RE, "")));
+		for (const entry of allowedTools) if (typeof entry === "string" && !scriptNames.has(entry)) issues.push({
+			code: "SKILL_UNKNOWN_ALLOWED_TOOL",
+			severity: "warning",
+			message: `allowed-tools entry ${JSON.stringify(entry)} of directory ${dirName} does not match any script in scripts/`
+		});
+	}
+	if (metadata && input.knownSkillNames) {
+		const dependencies = metadata["dependencies"];
+		if (Array.isArray(dependencies)) {
+			for (const dep of dependencies) if (typeof dep === "string" && !input.knownSkillNames.has(dep)) issues.push({
+				code: "SKILL_UNKNOWN_DEPENDENCY",
+				severity: "error",
+				message: `Skill ${JSON.stringify(metadata.name)} depends on unknown skill ${JSON.stringify(dep)}`
+			});
+		}
+	}
+	return issues;
+}
+/**
+* 循环依赖检测（全量邻接表，discovery 两趟扫描第二趟调用）。
+* 每个环只报一次（error 级，阻断进 Catalog）；自引用视为长度 1 的环。
+*/
+function checkDependencyCycles(adjacency) {
+	const issues = [];
+	const involved = /* @__PURE__ */ new Set();
+	const reported = /* @__PURE__ */ new Set();
+	const state = /* @__PURE__ */ new Map();
+	const stack = [];
+	const visit = (node) => {
+		if (state.get(node) === "done") return;
+		if (state.get(node) === "visiting") {
+			const cycle = [...stack.slice(stack.indexOf(node)), node];
+			const key = cycle.slice(0, -1).sort().join("");
+			if (!reported.has(key)) {
+				reported.add(key);
+				for (const name of cycle.slice(0, -1)) involved.add(name);
+				issues.push({
+					code: "SKILL_CIRCULAR_DEPENDENCY",
+					severity: "error",
+					message: `Circular skill dependency detected: ${cycle.join(" -> ")}`
+				});
+			}
+			return;
+		}
+		state.set(node, "visiting");
+		stack.push(node);
+		for (const dep of adjacency.get(node) ?? []) visit(dep);
+		stack.pop();
+		state.set(node, "done");
+	};
+	for (const node of adjacency.keys()) visit(node);
+	return {
+		issues,
+		involved
+	};
+}
+/**
+* 技能包集（skill pack）格式与打包逻辑（node/browser 共用单一来源）：
+*   webskill.skill-pack.json   { schemaVersion: 1, skills: [{ name, digest }] }
+*   <skill-a>/SKILL.md … webskill.skill-manifest.json
+*   <skill-b>/SKILL.md …
+* fflate 环境无关；文件读取经 FileSystemProvider 抽象。
+*/
+/** 包级清单文件名（位于 zip 根，不参与各技能 digest） */
+const SKILL_PACK_FILE = "webskill.skill-pack.json";
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+const baseName$1 = (p) => p.split("/").pop() ?? p;
+async function listFilesRecursive(fs, root, prefix = "") {
+	const out = [];
+	for (const entry of await fs.list(root)) {
+		const rel = prefix === "" ? baseName$1(entry.path) : `${prefix}/${baseName$1(entry.path)}`;
+		if (entry.type === "directory") out.push(...await listFilesRecursive(fs, entry.path, rel));
+		else out.push(rel);
+	}
+	return out;
+}
+/**
+* 多技能打包为单一 zip（包级清单 + 各技能目录含自身 manifest）。
+* manifestBuilder 负责确保技能目录内 manifest 文件存在并返回之（digest 入包级清单）。
+* @stable
+*/
+async function exportSkills(fs, input) {
+	if (input.roots.length === 0) throw new WebSkillError("EXPORT_FAILED", "exportSkills requires at least one skill root");
+	const files = {};
+	const skills = [];
+	try {
+		for (const root of input.roots) {
+			const base = root.replace(/\/+$/, "");
+			const manifest = await input.manifestBuilder(base);
+			skills.push({
+				name: manifest.name,
+				digest: manifest.integrity.digest
+			});
+			for (const rel of await listFilesRecursive(fs, base)) files[`${manifest.name}/${rel}`] = await fs.readBinary(`${base}/${rel}`);
+		}
+	} catch (e) {
+		if (e instanceof WebSkillError) throw e;
+		throw new WebSkillError("EXPORT_FAILED", `Failed to export skill pack: ${messageOf(e)}`, e);
+	}
+	const pack = {
+		schemaVersion: 1,
+		skills
+	};
+	files[SKILL_PACK_FILE] = new TextEncoder().encode(JSON.stringify(pack, null, 2));
+	return zipSync(files, { level: 6 });
+}
+/** 包级清单解析 + 形状校验；损坏 → INSTALL_FAILED（安装侧保证零残留） */
+function parseSkillPackManifest(text) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (e) {
+		throw new WebSkillError("INSTALL_FAILED", `Skill pack manifest is not valid JSON: ${messageOf(e)}`, e);
+	}
+	const invalid = (detail) => {
+		throw new WebSkillError("INSTALL_FAILED", `Skill pack manifest is corrupted: ${detail}`);
+	};
+	if (typeof raw !== "object" || raw === null) invalid("not an object");
+	const record = raw;
+	if (record["schemaVersion"] !== 1) invalid("schemaVersion must be 1");
+	if (!Array.isArray(record["skills"]) || record["skills"].length === 0) invalid("\"skills\" must be a non-empty array");
+	for (const entry of record["skills"]) {
+		if (typeof entry !== "object" || entry === null) invalid("skill entry is not an object");
+		const { name, digest } = entry;
+		if (typeof name !== "string" || name === "") invalid("skill entry missing a valid \"name\"");
+		if (typeof digest !== "string" || digest === "") invalid(`skill "${name}" missing a valid "digest"`);
+	}
+	return raw;
+}
+/** 由条目列表构建 Catalog，保证按名称排序 */
+function buildCatalog(entries) {
+	return { entries: [...entries].sort((a, b) => a.name.localeCompare(b.name)) };
+}
+/** 按技能名读取技能根目录内的文件，全部读取强制经过路径安全检查 */
+var SkillReader = class {
+	#fs;
+	#index;
+	constructor(fs, index) {
+		this.#fs = fs;
+		this.#index = index;
+	}
+	#rootFor(skillName) {
+		const root = this.#index.get(skillName);
+		if (!root) throw new WebSkillError("SKILL_NOT_FOUND", `Unknown skill: ${skillName}`);
+		return root;
+	}
+	async readSkillMarkdown(skillName) {
+		return this.readSkillFile(skillName, "SKILL.md");
+	}
+	async readSkillFile(skillName, relativePath) {
+		return this.#fs.readText(resolveInsideRoot(this.#rootFor(skillName), relativePath));
+	}
+	async readSkillBinary(skillName, relativePath) {
+		return this.#fs.readBinary(resolveInsideRoot(this.#rootFor(skillName), relativePath));
+	}
+};
+const baseName = (path) => path.split("/").pop() ?? path;
+var SkillDiscovery = class {
+	#fs;
+	#roots;
+	/** name → skillRoot，与 SkillReader 共享同一 Map 引用 */
+	#index = /* @__PURE__ */ new Map();
+	#reader;
+	constructor(fs, roots) {
+		this.#fs = fs;
+		this.#roots = roots;
+		this.#reader = new SkillReader(fs, this.#index);
+	}
+	async discover() {
+		this.#index.clear();
+		const entries = [];
+		const issues = [];
+		const candidates = [];
+		const knownSkillNames = /* @__PURE__ */ new Set();
+		const adjacency = /* @__PURE__ */ new Map();
+		for (const root of this.#roots) {
+			if (!await this.#fs.exists(root)) {
+				issues.push({
+					code: "FS_NOT_FOUND",
+					severity: "warning",
+					message: `Skill root directory not found, skipped: ${root}`,
+					path: root
+				});
+				continue;
+			}
+			for (const child of await this.#fs.list(root)) {
+				if (child.type !== "directory") continue;
+				const dirName = baseName(child.path);
+				const skillRoot = `${root}/${dirName}`;
+				const skillMdPath = `${skillRoot}/SKILL.md`;
+				const hasSkillMd = await this.#fs.exists(skillMdPath);
+				let metadata;
+				let parseError;
+				if (hasSkillMd) try {
+					metadata = parseSkillMarkdown(await this.#fs.readText(skillMdPath)).metadata;
+				} catch (e) {
+					parseError = e instanceof WebSkillError ? e : new WebSkillError("SKILL_INVALID_METADATA", String(e));
+				}
+				candidates.push({
+					dirName,
+					skillRoot,
+					hasSkillMd,
+					metadata,
+					parseError,
+					scriptFileNames: await this.#listScriptFileNames(skillRoot)
+				});
+				if (metadata) {
+					knownSkillNames.add(metadata.name);
+					const dependencies = metadata["dependencies"];
+					adjacency.set(metadata.name, Array.isArray(dependencies) ? dependencies.filter((d) => typeof d === "string") : []);
+				}
+			}
+		}
+		const cycles = checkDependencyCycles(adjacency);
+		const claimedNames = /* @__PURE__ */ new Set();
+		for (const candidate of candidates) {
+			const { metadata } = candidate;
+			const candidateIssues = checkSkillRules({
+				dirName: candidate.dirName,
+				hasSkillMd: candidate.hasSkillMd,
+				metadata,
+				parseError: candidate.parseError,
+				scriptFileNames: candidate.scriptFileNames,
+				existingNames: claimedNames,
+				knownSkillNames
+			});
+			for (const issue of candidateIssues) issue.path ??= candidate.skillRoot;
+			issues.push(...candidateIssues);
+			if (metadata) claimedNames.add(metadata.name);
+			const excludedByCycle = metadata !== void 0 && cycles.involved.has(metadata.name);
+			if (candidateIssues.some((i) => i.severity === "error") || !metadata || excludedByCycle) continue;
+			this.#index.set(metadata.name, candidate.skillRoot);
+			entries.push({
+				name: metadata.name,
+				description: metadata.description,
+				version: typeof metadata["version"] === "string" ? metadata["version"] : void 0,
+				license: typeof metadata["license"] === "string" ? metadata["license"] : void 0,
+				root: candidate.skillRoot,
+				source: "local",
+				hasScripts: candidate.scriptFileNames.length > 0,
+				hasReferences: await this.#fs.exists(`${candidate.skillRoot}/references`),
+				hasAssets: await this.#fs.exists(`${candidate.skillRoot}/assets`)
+			});
+		}
+		issues.push(...cycles.issues);
+		entries.sort((a, b) => a.name.localeCompare(b.name));
+		return {
+			entries,
+			issues
+		};
+	}
+	async catalog() {
+		const { entries, issues } = await this.discover();
+		return {
+			catalog: buildCatalog(entries),
+			issues
+		};
+	}
+	/** 按需加载技能完整文档；技能不存在时抛 SKILL_NOT_FOUND */
+	async loadDocument(skillName) {
+		if (this.#index.size === 0) await this.discover();
+		const { metadata, body } = parseSkillMarkdown(await this.#reader.readSkillMarkdown(skillName));
+		const skillRoot = this.#index.get(skillName);
+		return {
+			metadata,
+			body,
+			location: {
+				skillRoot,
+				skillMdPath: `${skillRoot}/SKILL.md`,
+				source: "local"
+			}
+		};
+	}
+	async #listScriptFileNames(skillRoot) {
+		const scriptsDir = `${skillRoot}/scripts`;
+		if (!await this.#fs.exists(scriptsDir)) return [];
+		return (await this.#fs.list(scriptsDir)).filter((s) => s.type === "file").map((s) => baseName(s.path));
+	}
+};
+/**
+* 合规校验。内部直接复用 SkillDiscovery 的扫描逻辑，
+* 规则判定同样落在 checkSkillRules 单一来源上。
+*/
+async function validateSkills(fs, roots) {
+	const { issues } = await new SkillDiscovery(fs, roots).discover();
+	return {
+		ok: !issues.some((i) => i.severity === "error"),
+		issues
+	};
+}
+function renderCatalogJson(catalog) {
+	return JSON.stringify(catalog, null, 2);
+}
+const jsonRenderer = {
+	format: "json",
+	render: renderCatalogJson
+};
+/** 转义 XML 五个特殊字符：& < > " ' */
+function escapeXml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function renderAvailableSkillsXml(catalog) {
+	const lines = ["<available_skills>"];
+	for (const skill of catalog.entries) {
+		lines.push("  <skill>");
+		lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+		lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+		if (skill.version !== void 0) lines.push(`    <version>${escapeXml(skill.version)}</version>`);
+		if (skill.license !== void 0) lines.push(`    <license>${escapeXml(skill.license)}</license>`);
+		lines.push(`    <source>${escapeXml(skill.source)}</source>`);
+		lines.push("  </skill>");
+	}
+	lines.push("</available_skills>");
+	return lines.join("\n");
+}
+const xmlRenderer = {
+	format: "xml",
+	render: renderAvailableSkillsXml
+};
+
+//#endregion
+//#region ../runtime/dist/memoryArtifactStore-C9lFVqPF.js
+/** 内存 ArtifactStore：测试与浏览器降级用；索引随进程生命周期存在 */
+var MemoryArtifactStore = class {
+	#byRun = /* @__PURE__ */ new Map();
+	#seq = 0;
+	async createTextArtifact(input) {
+		return this.#record({
+			runId: input.runId,
+			path: input.path,
+			type: "text",
+			size: new TextEncoder().encode(input.content).length,
+			mimeType: input.mimeType,
+			metadata: input.metadata
+		});
+	}
+	async createBinaryArtifact(input) {
+		return this.#record({
+			runId: input.runId,
+			path: input.path,
+			type: "binary",
+			size: input.content.length,
+			mimeType: input.mimeType,
+			metadata: input.metadata
+		});
+	}
+	async listArtifacts(runId) {
+		return [...this.#byRun.get(runId) ?? []];
+	}
+	#record(input) {
+		const artifact = {
+			id: `art-${++this.#seq}`,
+			runId: input.runId,
+			path: input.path,
+			type: input.type,
+			mimeType: input.mimeType,
+			size: input.size,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata: input.metadata
+		};
+		const list = this.#byRun.get(input.runId) ?? [];
+		list.push(artifact);
+		this.#byRun.set(input.runId, list);
+		return artifact;
+	}
+};
+
+//#endregion
+export { renderAvailableSkillsXml as C, verifyManifest as D, validateSkills as E, xmlRenderer as O, parseSkillPackManifest as S, resolveInsideRoot as T, exportSkills as _, SKILL_NAME_MAX_LENGTH as a, normalizePath as b, SkillDiscovery as c, buildCatalog as d, buildManifest as f, escapeXml as g, computeDigest as h, SKILL_MANIFEST_FILE as i, SkillReader as l, checkSkillRules as m, MemoryFS as n, SKILL_NAME_PATTERN as o, checkDependencyCycles as p, SKILLS_LOCKFILE as r, SKILL_PACK_FILE as s, MemoryArtifactStore as t, WebSkillError as u, isValidSkillName as v, renderCatalogJson as w, parseSkillMarkdown as x, jsonRenderer as y };

package/dist/node.d.ts

@@ -1,3 +1,4 @@
-import { $t as SKILLS_LOCKFILE, Nt as createScriptContext, cn as SkillInstallSource, dn as SkillManifest, en as SKILL_MANIFEST_FILE, gn as SkillsLockfile, vn as VerifyResult } from "./index-DCifjtJx.js";
-import { a as LlmEnvConfig, c as OxcSchemaInferer, d as SkillManager, f as loadLlmConfigFromEnv, i as LlmCapabilities, l as SandboxOptions, m as readArchiveManifest, n as FileArtifactStore, o as NodeFS, p as probeLlmCapabilities, r as FileMemoryStore, s as NodeScriptExecutor, t as CliUiBridge, u as SandboxedScriptExecutor } from "./index-vi7GPemR.js";
-export { CliUiBridge, FileArtifactStore, FileMemoryStore, type LlmCapabilities, type LlmEnvConfig, NodeFS, NodeScriptExecutor, OxcSchemaInferer, SKILLS_LOCKFILE, SKILL_MANIFEST_FILE, type SandboxOptions, SandboxedScriptExecutor, SkillManager, type SkillManifest, type SkillInstallSource as SkillSource, type SkillsLockfile, type VerifyResult, createScriptContext, loadLlmConfigFromEnv, probeLlmCapabilities, readArchiveManifest };
+import { E as SKILL_MANIFEST_FILE, H as SkillsLockfile, L as SkillManifest, P as SkillInstallSource, T as SKILLS_LOCKFILE, W as VerifyResult } from "./types-CgNC-oQu-Dq_A1yA-.js";
+import { ct as createScriptContext } from "./index-oG5Nzgb9.js";
+import { a as LlmEnvConfig, c as OxcSchemaInferer, d as SkillManager, f as loadLlmConfigFromEnv, i as LlmCapabilities, l as SandboxOptions, m as readArchiveManifest, n as FileArtifactStore, o as NodeFS, p as probeLlmCapabilities, r as FileMemoryStore, s as NodeScriptExecutor, t as CliUiBridge, u as SandboxedScriptExecutor } from "./index-Dc4X2N54.js";
+export { CliUiBridge, FileArtifactStore, FileMemoryStore, type LlmCapabilities, type LlmEnvConfig, NodeFS, NodeScriptExecutor, OxcSchemaInferer, SKILLS_LOCKFILE, SKILL_MANIFEST_FILE, type SandboxOptions, SandboxedScriptExecutor, type SkillInstallSource, SkillManager, type SkillManifest, type SkillsLockfile, type VerifyResult, createScriptContext, loadLlmConfigFromEnv, probeLlmCapabilities, readArchiveManifest };

package/dist/node.js

@@ -1,4 +1,5 @@
-import { E as createScriptContext, H as SKILL_MANIFEST_FILE, V as SKILLS_LOCKFILE } from "./dist-nXiR40hi.js";
-import { a as NodeScriptExecutor, c as SkillManager, d as readArchiveManifest, i as NodeFS, l as loadLlmConfigFromEnv, n as FileArtifactStore, o as OxcSchemaInferer, r as FileMemoryStore, s as SandboxedScriptExecutor, t as CliUiBridge, u as probeLlmCapabilities } from "./dist-33_zuOCm.js";
+import { i as SKILL_MANIFEST_FILE, r as SKILLS_LOCKFILE } from "./memoryArtifactStore-C9lFVqPF-U8nXvqL9.js";
+import { S as createScriptContext } from "./dist-D5fsiETF.js";
+import { a as NodeScriptExecutor, c as SkillManager, d as readArchiveManifest, i as NodeFS, l as loadLlmConfigFromEnv, n as FileArtifactStore, o as OxcSchemaInferer, r as FileMemoryStore, s as SandboxedScriptExecutor, t as CliUiBridge, u as probeLlmCapabilities } from "./dist-Cc3Mqi3_.js";
 
 export { CliUiBridge, FileArtifactStore, FileMemoryStore, NodeFS, NodeScriptExecutor, OxcSchemaInferer, SKILLS_LOCKFILE, SKILL_MANIFEST_FILE, SandboxedScriptExecutor, SkillManager, createScriptContext, loadLlmConfigFromEnv, probeLlmCapabilities, readArchiveManifest };