pi2dsh 0.7.0 → 0.8.0

package/README.md

@@ -136,7 +136,7 @@ is aspirational.
 | Example | What you get |
 |---|---|
 | [`examples/vision-bridge`](examples/vision-bridge/) | A text-only model answers questions about images: mention an image path, a configured vision model reads it, the analysis is injected into the conversation (works in CLI and the DSH web app; probe images included) |
-| [`examples/custom-models`](examples/custom-models/) | Define a provider once in Pi's standard `models.json` — it becomes a native DSH llm route: visible in the DSH web model picker, usable as the main model, and resolvable/callable by every Pi plugin through one directory |
+| [`examples/custom-gateways`](examples/custom-gateways/) | Add any OpenAI-compatible gateway the official DSH way (the `llm-pi-ai:` section of DSH settings) — it appears in the DSH model picker, works as the main model, and every Pi plugin sees it through the bridge's registry projection; the bridge owns zero model configuration |
 
 More verified capabilities (approval guardian, cross-session memory,
 interactive OAuth, MCP config conversion, host mode) get their examples as

package/README.zh.md

@@ -124,7 +124,7 @@ npx pi2dsh mcp-config                               # Pi mcpServers → DSH patc
 | 示例 | 你得到什么 |
 |---|---|
 | [`examples/vision-bridge`](examples/vision-bridge/) | 纯文本模型回答图片问题：消息里带图片路径，配置的视觉模型识图，分析结果注入对话（CLI 与 DSH Web 都能用；附探针测试图） |
-| [`examples/custom-models`](examples/custom-models/) | 在 Pi 标准 `models.json` 里定义一次 provider——它成为原生 DSH llm 路由：出现在 DSH Web 模型选择器、可当主模型对话、所有 Pi 插件经同一个目录可见可调 |
+| [`examples/custom-gateways`](examples/custom-gateways/) | 用 DSH 官方方式（DSH settings 的 `llm-pi-ai:` 段）接入任意 OpenAI 兼容网关——出现在 DSH 模型选择器、可当主模型、所有 Pi 插件经桥的 registry 投影看到同一路由；桥自身零模型配置 |
 
 更多已验证能力（审批 guardian、跨会话记忆、交互式 OAuth、MCP 配置转换、host 模式）的示例，将按同一标准逐个重新端到端验证后补齐。
 

package/dist/analyzer-CKTsWVzn.mjs

@@ -0,0 +1,628 @@
+
+import { R as __exportAll } from "./pi-ai-C6Xag6xt.mjs";
+import { c as PI_AI_PACKAGES, f as ruleForApi, g as ruleForUiContextProperty, h as ruleForHostImport, l as PI_CODING_AGENT_PACKAGES, m as ruleForEvent, p as ruleForContextProperty, u as PI_TUI_PACKAGES } from "./mcp-config-Dlou-ZA-.mjs";
+import { builtinModules } from "node:module";
+import { lstat, readFile, readdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import ts from "typescript";
+//#region src/module-graph.ts
+const SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const MODULE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".json"
+];
+function sourceKind(path) {
+	if (path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs")) return ts.ScriptKind.JS;
+	if (path.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (path.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	return ts.ScriptKind.TS;
+}
+function literalModule(node) {
+	return node !== void 0 && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : void 0;
+}
+function isImportMetaUrl(node) {
+	return node !== void 0 && ts.isPropertyAccessExpression(node) && node.name.text === "url" && ts.isMetaProperty(node.expression) && node.expression.keywordToken === ts.SyntaxKind.ImportKeyword;
+}
+function localReferences(path, text) {
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, sourceKind(path));
+	const values = /* @__PURE__ */ new Map();
+	const createRequireNames = /* @__PURE__ */ new Set(["createRequire"]);
+	const requireNames = /* @__PURE__ */ new Set(["require"]);
+	const add = (kind, specifier, lazy) => {
+		if (!specifier.startsWith(".") && !specifier.startsWith("#")) return;
+		const key = `${kind}:${specifier}`;
+		const existing = values.get(key);
+		if (existing === void 0) values.set(key, {
+			kind,
+			specifier,
+			lazy
+		});
+		else if (existing.lazy && !lazy) existing.lazy = false;
+	};
+	function collectRequireAliases(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && (node.moduleSpecifier.text === "node:module" || node.moduleSpecifier.text === "module") && node.importClause?.namedBindings !== void 0 && ts.isNamedImports(node.importClause.namedBindings)) {
+			for (const element of node.importClause.namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "createRequire") createRequireNames.add(element.name.text);
+		} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && createRequireNames.has(node.initializer.expression.text)) requireNames.add(node.name.text);
+		ts.forEachChild(node, collectRequireAliases);
+	}
+	collectRequireAliases(source);
+	function visit(node) {
+		if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier !== void 0 && ts.isStringLiteral(node.moduleSpecifier)) add("module", node.moduleSpecifier.text, false);
+		else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) add("module", node.moduleReference.expression.text, false);
+		else if (ts.isCallExpression(node) && node.arguments.length > 0 && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && requireNames.has(node.expression.text))) {
+			const specifier = literalModule(node.arguments[0]);
+			if (specifier !== void 0) add("module", specifier, insideFunctionBody(node));
+		} else if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "URL" && isImportMetaUrl(node.arguments?.[1])) {
+			const specifier = literalModule(node.arguments?.[0]);
+			if (specifier !== void 0) add("asset", specifier, false);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return [...values.values()];
+}
+function externalPackage(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || specifier.startsWith("bun:") || builtinModules.includes(specifier)) return void 0;
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function insideTry(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (ts.isTryStatement(current)) return true;
+		if (ts.isFunctionLike(current)) return false;
+		current = current.parent;
+	}
+	return false;
+}
+function insideFunctionBody(node) {
+	let current = node.parent;
+	while (current !== void 0) {
+		if (ts.isFunctionLike(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+function runtimeExternalPackages(path, text) {
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, sourceKind(path));
+	const packages = /* @__PURE__ */ new Map();
+	const createRequireNames = /* @__PURE__ */ new Set(["createRequire"]);
+	const requireNames = /* @__PURE__ */ new Set(["require"]);
+	const add = (specifier, lazy) => {
+		const name = externalPackage(specifier);
+		if (name === void 0 || name.length === 0) return;
+		const existing = packages.get(name);
+		if (existing === void 0) packages.set(name, {
+			name,
+			lazy
+		});
+		else if (existing.lazy && !lazy) existing.lazy = false;
+	};
+	function collectRequireAliases(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && (node.moduleSpecifier.text === "node:module" || node.moduleSpecifier.text === "module") && node.importClause?.namedBindings !== void 0 && ts.isNamedImports(node.importClause.namedBindings)) {
+			for (const element of node.importClause.namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "createRequire") createRequireNames.add(element.name.text);
+		} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && createRequireNames.has(node.initializer.expression.text)) requireNames.add(node.name.text);
+		ts.forEachChild(node, collectRequireAliases);
+	}
+	collectRequireAliases(source);
+	function visit(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+			const clause = node.importClause;
+			const named = clause?.namedBindings;
+			const namedImportsAreTypeOnly = named !== void 0 && ts.isNamedImports(named) && named.elements.length > 0 && named.elements.every((element) => element.isTypeOnly);
+			if (clause === void 0 || !clause.isTypeOnly && (clause.name !== void 0 || !namedImportsAreTypeOnly)) add(node.moduleSpecifier.text, false);
+		} else if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== void 0 && ts.isStringLiteral(node.moduleSpecifier)) add(node.moduleSpecifier.text, false);
+		else if (ts.isImportEqualsDeclaration(node) && !node.isTypeOnly && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) add(node.moduleReference.expression.text, false);
+		else if (ts.isCallExpression(node) && node.arguments.length > 0 && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && requireNames.has(node.expression.text))) {
+			if (!insideTry(node)) {
+				const specifier = literalModule(node.arguments[0]);
+				if (specifier !== void 0) add(specifier, insideFunctionBody(node));
+			}
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return [...packages.values()];
+}
+function inside(rootDir, path) {
+	const pathRelative = relative(rootDir, path);
+	return pathRelative === "" || pathRelative !== ".." && !pathRelative.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
+}
+function sourceAlternates(base) {
+	const extension = extname(base);
+	const stem = extension.length > 0 ? base.slice(0, -extension.length) : base;
+	if (extension === ".js") return [`${stem}.ts`, `${stem}.tsx`];
+	if (extension === ".mjs") return [`${stem}.mts`, `${stem}.ts`];
+	if (extension === ".cjs") return [`${stem}.cts`, `${stem}.ts`];
+	if (extension === ".jsx") return [`${stem}.tsx`, `${stem}.ts`];
+	return [];
+}
+async function isFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function subpathImportTarget(rootDir, specifier, importsMap) {
+	const conditionValue = (value) => {
+		if (typeof value === "string") return value;
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		for (const condition of [
+			"import",
+			"node",
+			"default"
+		]) {
+			const candidate = conditionValue(record[condition]);
+			if (candidate !== void 0) return candidate;
+		}
+	};
+	const direct = conditionValue(importsMap[specifier]);
+	if (direct !== void 0) return resolve(rootDir, direct);
+	for (const [pattern, value] of Object.entries(importsMap)) {
+		const star = pattern.indexOf("*");
+		if (star === -1) continue;
+		const prefix = pattern.slice(0, star);
+		const suffix = pattern.slice(star + 1);
+		if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) continue;
+		const wildcard = specifier.slice(prefix.length, specifier.length - suffix.length);
+		const target = conditionValue(value);
+		if (target !== void 0) return resolve(rootDir, target.replace("*", wildcard));
+	}
+}
+async function packageImportsMap(rootDir) {
+	try {
+		const parsed = JSON.parse(await readFile(join(rootDir, "package.json"), "utf8"));
+		return typeof parsed.imports === "object" && parsed.imports !== null ? parsed.imports : {};
+	} catch {
+		return {};
+	}
+}
+async function resolveModule(fromFile, specifier, rootDir, importsMap) {
+	if (specifier.startsWith("#")) {
+		const target = subpathImportTarget(rootDir, specifier, importsMap);
+		if (target === void 0) throw new Error(`cannot resolve subpath import ${JSON.stringify(specifier)} through the package "imports" map`);
+		return resolveModule(fromFile, relative(dirname(fromFile), target).startsWith(".") ? relative(dirname(fromFile), target) : `./${relative(dirname(fromFile), target)}`, rootDir, importsMap);
+	}
+	const base = resolve(dirname(fromFile), specifier);
+	const candidates = [
+		base,
+		...sourceAlternates(base),
+		...extname(base) === "" ? MODULE_EXTENSIONS.map((extension) => `${base}${extension}`) : [],
+		...MODULE_EXTENSIONS.map((extension) => join(base, `index${extension}`))
+	];
+	for (const candidate of [...new Set(candidates)]) {
+		if (!inside(rootDir, candidate)) throw new Error(`extension import escapes the Pi package: ${specifier} from ${fromFile}`);
+		if (await isFile(candidate)) return candidate;
+	}
+	throw new Error(`cannot resolve local extension import ${JSON.stringify(specifier)} from ${fromFile}`);
+}
+async function expandAsset(path, rootDir) {
+	if (!inside(rootDir, path)) throw new Error(`extension asset escapes the Pi package: ${path}`);
+	let info;
+	try {
+		info = await lstat(path);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		for (const alternate of sourceAlternates(path)) if (await isFile(alternate)) return [alternate];
+		throw error;
+	}
+	if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${path}`);
+	if (info.isFile()) return [path];
+	if (!info.isDirectory()) return [];
+	const output = [];
+	for (const entry of await readdir(path)) output.push(...await expandAsset(join(path, entry), rootDir));
+	return output;
+}
+async function collectLocalClosure(rootDir, entries) {
+	const importsMap = await packageImportsMap(rootDir);
+	const graph = /* @__PURE__ */ new Map();
+	const issues = [];
+	const queue = entries.map((path) => resolve(path));
+	while (queue.length > 0) {
+		const source = queue.shift();
+		if (graph.has(source)) continue;
+		if (!inside(rootDir, source)) throw new Error(`extension source escapes the Pi package: ${source}`);
+		const info = await lstat(source);
+		if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${source}`);
+		if (!info.isFile()) throw new Error(`extension closure contains a non-file path: ${source}`);
+		const edges = [];
+		graph.set(source, edges);
+		if (!SCRIPT_EXTENSIONS.has(extname(source))) continue;
+		const text = await readFile(source, "utf8");
+		for (const reference of localReferences(source, text)) {
+			const lazy = reference.lazy || reference.kind === "asset";
+			try {
+				const targets = reference.kind === "module" ? [await resolveModule(source, reference.specifier, rootDir, importsMap)] : await expandAsset(resolve(dirname(source), reference.specifier), rootDir);
+				edges.push({
+					lazy,
+					targets
+				});
+				queue.push(...targets);
+			} catch (error) {
+				issues.push({
+					file: source,
+					kind: reference.kind,
+					specifier: reference.specifier,
+					detail: error instanceof Error ? error.message : String(error),
+					lazy
+				});
+			}
+		}
+	}
+	const loadTimeFiles = /* @__PURE__ */ new Set();
+	const loadQueue = entries.map((path) => resolve(path)).filter((path) => graph.has(path));
+	while (loadQueue.length > 0) {
+		const source = loadQueue.shift();
+		if (loadTimeFiles.has(source)) continue;
+		loadTimeFiles.add(source);
+		for (const edge of graph.get(source) ?? []) {
+			if (edge.lazy) continue;
+			for (const target of edge.targets) if (!loadTimeFiles.has(target)) loadQueue.push(target);
+		}
+	}
+	for (const issue of issues) if (!loadTimeFiles.has(issue.file)) issue.lazy = true;
+	return {
+		files: [...graph.keys()].sort(),
+		loadTimeFiles,
+		issues
+	};
+}
+//#endregion
+//#region src/analyzer.ts
+var analyzer_exports = /* @__PURE__ */ __exportAll({ analyzePackage: () => analyzePackage });
+function literalText(node) {
+	return node !== void 0 && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : void 0;
+}
+function hasModifier(node, kind) {
+	return ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) === true;
+}
+function parameterIdentifier(node) {
+	const parameter = node.parameters[0];
+	return parameter !== void 0 && ts.isIdentifier(parameter.name) ? parameter.name.text : void 0;
+}
+function extensionApiReceivers(source) {
+	const receivers = /* @__PURE__ */ new Set();
+	const functions = /* @__PURE__ */ new Map();
+	function index(node) {
+		if (ts.isFunctionDeclaration(node) && node.name !== void 0) functions.set(node.name.text, node);
+		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) functions.set(node.name.text, node.initializer);
+		if (ts.isParameter(node) && node.type !== void 0 && /(?:^|\.)ExtensionAPI\b/u.test(node.type.getText(source)) && ts.isIdentifier(node.name)) receivers.add(node.name.text);
+		if (ts.isParameter(node) && ts.isIdentifier(node.name) && /^(?:pi|extensionApi)$/iu.test(node.name.text)) receivers.add(node.name.text);
+		ts.forEachChild(node, index);
+	}
+	index(source);
+	for (const statement of source.statements) {
+		if (ts.isFunctionDeclaration(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword) && hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+			const name = parameterIdentifier(statement);
+			if (name !== void 0) receivers.add(name);
+		}
+		if (ts.isExportAssignment(statement)) {
+			const expression = statement.expression;
+			if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+				const name = parameterIdentifier(expression);
+				if (name !== void 0) receivers.add(name);
+			} else if (ts.isIdentifier(expression)) {
+				const candidate = functions.get(expression.text);
+				if (candidate !== void 0) {
+					const name = parameterIdentifier(candidate);
+					if (name !== void 0) receivers.add(name);
+				}
+			}
+		}
+		if (ts.isExportDeclaration(statement) && statement.moduleSpecifier === void 0 && statement.exportClause !== void 0 && ts.isNamedExports(statement.exportClause)) for (const element of statement.exportClause.elements) {
+			if (element.name.text !== "default" || element.propertyName === void 0 || !ts.isIdentifier(element.propertyName)) continue;
+			const candidate = functions.get(element.propertyName.text);
+			if (candidate !== void 0) {
+				const name = parameterIdentifier(candidate);
+				if (name !== void 0) receivers.add(name);
+			}
+		}
+	}
+	return receivers;
+}
+function extensionApiProperties(source, receivers) {
+	const properties = /* @__PURE__ */ new Set();
+	function visit(node) {
+		if ((ts.isPropertyDeclaration(node) || ts.isParameter(node)) && ts.isIdentifier(node.name)) {
+			if (node.type !== void 0 && /(?:^|\.)(?:Pi)?ExtensionAPI\b/u.test(node.type.getText(source)) || /^(?:pi|extensionApi)$/iu.test(node.name.text)) properties.add(node.name.text);
+		} else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isIdentifier(node.right) && receivers.has(node.right.text)) properties.add(node.left.name.text);
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return properties;
+}
+function enclosingFunctionName(node) {
+	const parent = node.parent;
+	if (ts.isMethodDeclaration(parent) && parent.name !== void 0) return parent.name.getText();
+	if ((ts.isArrowFunction(parent) || ts.isFunctionExpression(parent)) && ts.isPropertyAssignment(parent.parent)) return parent.parent.name.getText();
+}
+function extensionContextReceivers(source) {
+	const receivers = /* @__PURE__ */ new Set();
+	function visit(node) {
+		if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+			const typedContext = node.type !== void 0 && /(?:^|\.)(?:Extension|ExtensionCommand|ToolExecution)Context\b/u.test(node.type.getText(source));
+			const conventionalHandlerContext = /^(?:ctx|context)$/iu.test(node.name.text) && /^(?:execute|handler)$/u.test(enclosingFunctionName(node) ?? "");
+			if (typedContext || conventionalHandlerContext) receivers.add(node.name.text);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return receivers;
+}
+const PI_SHIMMED_PACKAGES = /* @__PURE__ */ new Set([
+	...PI_CODING_AGENT_PACKAGES,
+	...PI_TUI_PACKAGES,
+	...PI_AI_PACKAGES
+]);
+const PI_HOST_PACKAGES = /* @__PURE__ */ new Set([
+	...PI_SHIMMED_PACKAGES,
+	"typebox",
+	"@sinclair/typebox"
+]);
+function dependencyNames(packageJson) {
+	const names = /* @__PURE__ */ new Set();
+	for (const field of [
+		"dependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	]) {
+		const value = packageJson[field];
+		if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+		for (const [name, specifier] of Object.entries(value)) if (typeof specifier === "string") names.add(name);
+	}
+	return names;
+}
+function pushFinding(findings, rootDir, file, source, node, capability, level, detail) {
+	const position = source.getLineAndCharacterOfPosition(node.getStart(source));
+	findings.push({
+		capability,
+		level,
+		file: relative(rootDir, file).replaceAll("\\", "/"),
+		line: position.line + 1,
+		detail
+	});
+}
+async function analyzeExtension(rootDir, file) {
+	const text = await readFile(file, "utf8");
+	const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, sourceKind(file));
+	const findings = [];
+	const receivers = extensionApiReceivers(source);
+	const apiProperties = extensionApiProperties(source, receivers);
+	const contextReceivers = extensionContextReceivers(source);
+	const methodAliases = /* @__PURE__ */ new Map();
+	const eventBusAliases = /* @__PURE__ */ new Set();
+	const uiAliases = /* @__PURE__ */ new Set();
+	function reportHostImport(packageName, importedName, node) {
+		const matched = ruleForHostImport(packageName, importedName);
+		if (matched === void 0) {
+			pushFinding(findings, rootDir, file, source, node, `host-import(${packageName}:${importedName})`, "unsupported", `The pi2dsh host shim does not export ${JSON.stringify(importedName)} from ${JSON.stringify(packageName)}.`);
+			return;
+		}
+		pushFinding(findings, rootDir, file, source, node, `host-import(${packageName}:${importedName})`, matched.level, matched.detail);
+	}
+	for (const statement of source.statements) if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && PI_SHIMMED_PACKAGES.has(statement.moduleSpecifier.text)) {
+		const packageName = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		if (clause === void 0) {
+			reportHostImport(packageName, "<side-effect>", statement);
+			continue;
+		}
+		if (clause.isTypeOnly) continue;
+		if (clause.name !== void 0) reportHostImport(packageName, "default", clause.name);
+		if (clause.namedBindings !== void 0 && ts.isNamespaceImport(clause.namedBindings)) reportHostImport(packageName, "*", clause.namedBindings);
+		else if (clause.namedBindings !== void 0) {
+			for (const element of clause.namedBindings.elements) if (!element.isTypeOnly) reportHostImport(packageName, element.propertyName?.text ?? element.name.text, element);
+		}
+	} else if (ts.isExportDeclaration(statement) && !statement.isTypeOnly && statement.moduleSpecifier !== void 0 && ts.isStringLiteral(statement.moduleSpecifier) && PI_HOST_PACKAGES.has(statement.moduleSpecifier.text)) {
+		const packageName = statement.moduleSpecifier.text;
+		if (statement.exportClause === void 0 || ts.isNamespaceExport(statement.exportClause)) reportHostImport(packageName, "*", statement);
+		else for (const element of statement.exportClause.elements) if (!element.isTypeOnly) reportHostImport(packageName, element.propertyName?.text ?? element.name.text, element);
+	} else if (ts.isImportEqualsDeclaration(statement) && !statement.isTypeOnly && ts.isExternalModuleReference(statement.moduleReference) && ts.isStringLiteral(statement.moduleReference.expression) && PI_HOST_PACKAGES.has(statement.moduleReference.expression.text)) reportHostImport(statement.moduleReference.expression.text, "*", statement);
+	const declarations = [];
+	const isApiReceiver = (node) => ts.isIdentifier(node) && receivers.has(node.text) || ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword && apiProperties.has(node.name.text);
+	function collectDeclarations(node) {
+		if (ts.isVariableDeclaration(node)) declarations.push(node);
+		ts.forEachChild(node, collectDeclarations);
+	}
+	collectDeclarations(source);
+	for (let pass = 0; pass < declarations.length + 1; pass += 1) {
+		let changed = false;
+		for (const declaration of declarations) {
+			const initializer = declaration.initializer;
+			if (initializer === void 0) continue;
+			if (ts.isIdentifier(declaration.name) && isApiReceiver(initializer)) {
+				if (!receivers.has(declaration.name.text)) {
+					receivers.add(declaration.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isIdentifier(initializer) && contextReceivers.has(initializer.text)) {
+				if (!contextReceivers.has(declaration.name.text)) {
+					contextReceivers.add(declaration.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isPropertyAccessExpression(initializer) && initializer.name.text === "ui" && ts.isIdentifier(initializer.expression) && contextReceivers.has(initializer.expression.text) && !uiAliases.has(declaration.name.text)) {
+				uiAliases.add(declaration.name.text);
+				changed = true;
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isPropertyAccessExpression(initializer) && isApiReceiver(initializer.expression)) {
+				if (initializer.name.text === "events") {
+					if (!eventBusAliases.has(declaration.name.text)) {
+						eventBusAliases.add(declaration.name.text);
+						changed = true;
+					}
+				} else if (!methodAliases.has(declaration.name.text)) {
+					methodAliases.set(declaration.name.text, initializer.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isObjectBindingPattern(declaration.name) && isApiReceiver(initializer)) for (const element of declaration.name.elements) {
+				if (!ts.isIdentifier(element.name)) continue;
+				const method = element.propertyName !== void 0 && ts.isIdentifier(element.propertyName) ? element.propertyName.text : element.name.text;
+				if (method === "events") {
+					if (!eventBusAliases.has(element.name.text)) {
+						eventBusAliases.add(element.name.text);
+						changed = true;
+					}
+				} else if (!methodAliases.has(element.name.text)) {
+					methodAliases.set(element.name.text, method);
+					changed = true;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+	function reportMethod(method, args, node) {
+		if (method === "on") {
+			const event = literalText(args[0]);
+			if (event === void 0) pushFinding(findings, rootDir, file, source, node, "on(<dynamic>)", "unsupported", "Dynamic event names cannot be audited or mapped safely.");
+			else {
+				const rule = ruleForEvent(event);
+				pushFinding(findings, rootDir, file, source, node, `on(${event})`, rule.level, rule.detail);
+			}
+			return;
+		}
+		const rule = ruleForApi(method);
+		if (rule === void 0) {
+			pushFinding(findings, rootDir, file, source, node, method, "unsupported", `Unknown ExtensionAPI method ${JSON.stringify(method)} cannot be audited or mapped safely.`);
+			return;
+		}
+		pushFinding(findings, rootDir, file, source, node, method, rule.level, rule.detail);
+	}
+	function reportEventBus(method, node) {
+		const rule = ruleForApi("events");
+		if ((method === "on" || method === "emit") && rule !== void 0) pushFinding(findings, rootDir, file, source, node, `events.${method}`, rule.level, rule.detail);
+		else pushFinding(findings, rootDir, file, source, node, `events.${method}`, "unsupported", `Unknown Pi event-bus method ${JSON.stringify(method)} cannot be mapped safely.`);
+	}
+	function reportContext(property, node) {
+		const matched = ruleForContextProperty(property);
+		if (matched === void 0) pushFinding(findings, rootDir, file, source, node, `ctx.${property}`, "unsupported", `Unknown Pi extension-context property ${JSON.stringify(property)} cannot be audited or mapped safely.`);
+		else pushFinding(findings, rootDir, file, source, node, `ctx.${property}`, matched.level, matched.detail);
+	}
+	function reportUiContext(property, node) {
+		const matched = ruleForUiContextProperty(property);
+		if (matched === void 0) pushFinding(findings, rootDir, file, source, node, `ctx.ui.${property}`, "unsupported", `Unknown Pi UI-context property ${JSON.stringify(property)} cannot be audited or mapped safely.`);
+		else pushFinding(findings, rootDir, file, source, node, `ctx.ui.${property}`, matched.level, matched.detail);
+	}
+	function visit(node) {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			const method = methodAliases.get(node.expression.text);
+			if (method !== void 0) reportMethod(method, node.arguments, node);
+		} else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+			const target = node.expression.expression;
+			if (isApiReceiver(target)) reportMethod(node.expression.name.text, node.arguments, node);
+			else if (ts.isIdentifier(target) && eventBusAliases.has(target.text)) reportEventBus(node.expression.name.text, node);
+			else if (ts.isPropertyAccessExpression(target) && target.name.text === "events" && isApiReceiver(target.expression)) reportEventBus(node.expression.name.text, node);
+		} else if (ts.isCallExpression(node) && ts.isElementAccessExpression(node.expression) && isApiReceiver(node.expression.expression)) {
+			const method = literalText(node.expression.argumentExpression);
+			if (method === void 0) pushFinding(findings, rootDir, file, source, node, "<dynamic-api-method>", "unsupported", "Dynamic ExtensionAPI method access cannot be audited or mapped safely.");
+			else reportMethod(method, node.arguments, node);
+		}
+		if (ts.isPropertyAccessExpression(node)) {
+			const target = node.expression;
+			if (ts.isPropertyAccessExpression(target) && target.name.text === "ui" && ts.isIdentifier(target.expression) && contextReceivers.has(target.expression.text)) reportUiContext(node.name.text, node);
+			else if (ts.isIdentifier(target) && uiAliases.has(target.text)) reportUiContext(node.name.text, node);
+			else if (ts.isIdentifier(target) && contextReceivers.has(target.text) && node.name.text !== "ui") reportContext(node.name.text, node);
+		} else if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression) && contextReceivers.has(node.expression.text)) {
+			const property = literalText(node.argumentExpression);
+			if (property === void 0) pushFinding(findings, rootDir, file, source, node, "ctx.<dynamic>", "unsupported", "Dynamic Pi extension-context access cannot be audited or mapped safely.");
+			else if (property !== "ui") reportContext(property, node);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return findings;
+}
+async function analyzePackage(pkg) {
+	const extensionClosure = await collectLocalClosure(pkg.rootDir, pkg.resources.extensions);
+	const findings = (await Promise.all(extensionClosure.files.filter((file) => SCRIPT_EXTENSIONS.has(extname(file))).map((file) => analyzeExtension(pkg.rootDir, file)))).flat();
+	if (pkg.resources.extensions.length > 0 && findings.length === 0) findings.push({
+		capability: "static-audit",
+		level: "unsupported",
+		file: pkg.resources.extensions.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")).join(", "),
+		line: 1,
+		detail: "No ExtensionAPI use was statically proven across the local module closure; conversion fails closed instead of claiming compatibility."
+	});
+	for (const issue of extensionClosure.issues) {
+		const lazyIssue = issue.lazy || issue.kind === "asset";
+		findings.push({
+			capability: `${issue.kind}(${issue.specifier})`,
+			level: lazyIssue ? "partial" : "fatal",
+			file: relative(pkg.rootDir, issue.file).replaceAll("\\", "/"),
+			line: 1,
+			detail: lazyIssue ? `Unresolved reference on a lazy path: ${issue.detail}. Extension load is unaffected; if the feature that evaluates it runs, it fails the same way under Pi (published file layout is preserved).` : `The local extension closure is incomplete: ${issue.detail}`
+		});
+	}
+	const declaredDependencies = dependencyNames(pkg.packageJson);
+	for (const file of extensionClosure.files.filter((candidate) => SCRIPT_EXTENSIONS.has(extname(candidate)))) {
+		const text = await readFile(file, "utf8");
+		const lazyFile = !extensionClosure.loadTimeFiles.has(file);
+		for (const use of runtimeExternalPackages(file, text)) {
+			if (PI_HOST_PACKAGES.has(use.name) || declaredDependencies.has(use.name)) continue;
+			const lazyUse = use.lazy || lazyFile;
+			findings.push({
+				capability: lazyUse ? `optional-lazy-dependency(${use.name})` : `undeclared-runtime-dependency(${use.name})`,
+				level: lazyUse ? "partial" : "fatal",
+				file: relative(pkg.rootDir, file).replaceAll("\\", "/"),
+				line: 1,
+				detail: lazyUse ? `The extension imports ${JSON.stringify(use.name)} only on a lazily-evaluated path without declaring it; the feature that needs it asks for the module at call time, exactly as under Pi (install ${use.name} to use that feature).` : `The extension imports ${JSON.stringify(use.name)} at load time, but the Pi package does not declare it as a dependency.`
+			});
+		}
+	}
+	const resourceFinding = (file, capability, level, detail) => ({
+		capability,
+		level,
+		file: relative(pkg.rootDir, file).replaceAll("\\", "/"),
+		line: 1,
+		detail
+	});
+	for (const file of pkg.resources.skills.filter((path) => basename(path) === "SKILL.md" || path.endsWith(".md"))) findings.push(resourceFinding(file, "skill", "full", "Copied as a DSH filesystem skill with its resource directory intact."));
+	for (const file of pkg.resources.prompts) findings.push(resourceFinding(file, "prompt", "full", "Registered as a DSH slash command with Pi-compatible argument expansion."));
+	for (const file of pkg.resources.themes) findings.push(resourceFinding(file, "theme", "unsupported", "Pi terminal themes have no effect in DSH Web or headless surfaces."));
+	findings.sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.capability.localeCompare(right.capability));
+	const summary = {
+		full: 0,
+		partial: 0,
+		unsupported: 0,
+		fatal: 0
+	};
+	for (const finding of findings) summary[finding.level] += 1;
+	const verdict = summary.fatal > 0 ? "blocked" : summary.partial > 0 || summary.unsupported > 0 ? "review" : "ready";
+	return {
+		schemaVersion: 1,
+		package: pkg.identity,
+		verdict,
+		summary,
+		resources: {
+			extensions: pkg.resources.extensions.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			skills: pkg.resources.skills.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			prompts: pkg.resources.prompts.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			themes: pkg.resources.themes.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/"))
+		},
+		findings
+	};
+}
+//#endregion
+export { runtimeExternalPackages as a, collectLocalClosure as i, analyzer_exports as n, SCRIPT_EXTENSIONS as r, analyzePackage as t };
+
+//# sourceMappingURL=analyzer-CKTsWVzn.mjs.map