@xopcai/xopc 0.0.303 → 0.0.307

package/dist/src/extensions/api.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { getProviderRegistry, init_plugin_registry } from "../providers/plugin-registry.js";
 import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { registerSpeechProvider } from "../voice/tts/speech-registry.js";
 import { HOOK_EXECUTION_MODES } from "./types/hooks.js";
@@ -12,6 +13,7 @@ import { isAbsolute, resolve } from "path";
 import { EventEmitter } from "events";
 //#region src/extensions/api.ts
 init_logger();
+init_plugin_registry();
 var ExtensionApiImpl = class {
 	_tools = /* @__PURE__ */ new Map();
 	_hooks = /* @__PURE__ */ new Map();
@@ -25,6 +27,7 @@ var ExtensionApiImpl = class {
 	_registeredSpeechProviderIds = [];
 	_registeredMediaUnderstandingProviderIds = [];
 	_registeredMarketplaceAdapterIds = [];
+	_providerCleanup = [];
 	_manifestCommands = /* @__PURE__ */ new Map();
 	constructor(id, name, version, source, config, extensionConfig, _logger, _resolvePath, _coreRegistry, _contracts = {}, runtime) {
 		this.id = id;
@@ -68,15 +71,17 @@ var ExtensionApiImpl = class {
 	registerHook(event, handler, opts) {
 		this._assertContract("hooks", event);
 		if (!this._hooks.has(event)) this._hooks.set(event, /* @__PURE__ */ new Set());
-		this._hooks.get(event).add(handler);
-		if (opts?.once) {
-			const wrapper = async (...args) => {
-				await handler(...args);
-				this._hooks.get(event)?.delete(wrapper);
-			};
-			this._hooks.get(event).add(wrapper);
-		}
-		this._registry.addHook(event, handler, this.id, opts?.priority ?? 0);
+		const hookEvent = event;
+		const registeredHandler = opts?.once ? async (...args) => {
+			try {
+				return await handler(...args);
+			} finally {
+				this._hooks.get(event)?.delete(registeredHandler);
+				this._registry.removeHook(hookEvent, registeredHandler);
+			}
+		} : handler;
+		this._hooks.get(event).add(registeredHandler);
+		this._registry.addHook(hookEvent, registeredHandler, this.id, opts?.priority ?? 0);
 		this._logger.info(`Registered hook: ${event}`);
 	}
 	/**
@@ -89,11 +94,12 @@ var ExtensionApiImpl = class {
 	*   return { systemPrompt: event.systemPrompt };
 	* });
 	*/
-	onHook(hookName, handler, _opts) {
+	onHook(hookName, handler, opts) {
 		this._assertContract("hooks", hookName);
 		const mode = HOOK_EXECUTION_MODES[hookName];
 		if (!this._typedHooks.has(hookName)) this._typedHooks.set(hookName, /* @__PURE__ */ new Set());
 		this._typedHooks.get(hookName).add(handler);
+		this._registry.addHook(hookName, handler, this.id, opts?.priority ?? 0);
 		this._logger.debug(`Registered typed hook: ${hookName} (mode: ${mode})`);
 	}
 	/**
@@ -107,14 +113,14 @@ var ExtensionApiImpl = class {
 	registerChannel(registration) {
 		const plugin = registration.plugin;
 		this._assertContract("channels", plugin.id);
-		this._registry.addChannelPlugin(plugin);
+		this._registry.addChannelPlugin(plugin, this.id);
 		for (const migration of plugin.migrations ?? []) this.registerMigration(migration);
 		this._eventBus.emit("channel:register", plugin);
 		this._logger.info(`Registered channel plugin: ${plugin.id}`);
 	}
 	registerHttpRoute(path, handler) {
 		this._assertContract("httpRoutes", path);
-		this._registry.addHttpRoute(path, handler);
+		this._registry.addHttpRoute(path, handler, this.id);
 		this._eventBus.emit("http:route", {
 			path,
 			handler
@@ -154,7 +160,7 @@ var ExtensionApiImpl = class {
 		};
 		commandRegistry.register(definition);
 		this._registeredCommandIds.push(commandId);
-		this._registry.addCommand(command);
+		this._registry.addCommand(command, this.id);
 		this._eventBus.emit("command:register", command);
 		this._logger.info(`Registered chat command: /${command.name}`);
 	}
@@ -200,13 +206,13 @@ var ExtensionApiImpl = class {
 	}
 	registerService(service) {
 		this._assertContract("services", service.id);
-		this._registry.addService(service);
+		this._registry.addService(service, this.id);
 		this._eventBus.emit("service:register", service);
 		this._logger.info(`Registered service: ${service.id}`);
 	}
 	registerGatewayMethod(method, handler) {
 		this._assertContract("gatewayMethods", method);
-		this._registry.addGatewayMethod(method, handler);
+		this._registry.addGatewayMethod(method, handler, this.id);
 		this._eventBus.emit("gateway:method", {
 			method,
 			handler
@@ -244,22 +250,12 @@ var ExtensionApiImpl = class {
 	*/
 	registerProvider(plugin) {
 		this._assertContract("providers", plugin.id);
-		import("../providers/plugin-registry.js").then(({ getProviderRegistry }) => {
-			getProviderRegistry().register(plugin);
-			this._logger.info(`Extension registered provider: ${plugin.id}`);
-		}).catch((err) => {
-			this._logger.error(`Failed to register provider: ${err instanceof Error ? err.message : String(err)}`);
-		});
-	}
-	/**
-	* Register a full ProviderPlugin (alias for registerProvider)
-	*/
-	registerProviderPlugin(plugin) {
-		this.registerProvider(plugin);
+		this._providerCleanup.push(getProviderRegistry().register(plugin));
+		this._logger.info(`Extension registered provider: ${plugin.id}`);
 	}
 	registerSpeechProvider(plugin) {
 		this._assertContract("speechProviders", plugin.id);
-		registerSpeechProvider(plugin);
+		this._providerCleanup.push(registerSpeechProvider(plugin));
 		if (!this._registeredSpeechProviderIds.includes(plugin.id)) this._registeredSpeechProviderIds.push(plugin.id);
 		this._logger.info(`Registered speech provider: ${plugin.id}`);
 	}
@@ -269,7 +265,7 @@ var ExtensionApiImpl = class {
 	}
 	registerMediaUnderstandingProvider(plugin) {
 		this._assertContract("mediaUnderstandingProviders", plugin.id);
-		registerMediaUnderstandingProvider(plugin);
+		this._providerCleanup.push(registerMediaUnderstandingProvider(plugin));
 		if (!this._registeredMediaUnderstandingProviderIds.includes(plugin.id)) this._registeredMediaUnderstandingProviderIds.push(plugin.id);
 		this._logger.info(`Registered media understanding provider: ${plugin.id}`);
 	}
@@ -287,9 +283,6 @@ var ExtensionApiImpl = class {
 		if (!this._registeredMarketplaceAdapterIds.includes(adapterId)) this._registeredMarketplaceAdapterIds.push(adapterId);
 		this._logger.info(`Extension registered marketplace adapter: ${adapterId}`);
 	}
-	registerFlag(_name, _config) {}
-	getFlag(_name) {}
-	registerShortcut(_key, _config) {}
 	registerTui(register) {
 		this._assertContract("tui", this.id);
 		this._registry.addTuiRegistration(this.id, register);
@@ -323,6 +316,7 @@ var ExtensionApiImpl = class {
 		this._registry.removeReloadRegistration(this.id);
 		for (const adapterId of this._registeredMarketplaceAdapterIds) unregisterMarketplaceAdapter(adapterId);
 		this._registeredMarketplaceAdapterIds = [];
+		for (const cleanup of this._providerCleanup.splice(0).reverse()) cleanup();
 		this._typedEventBus.cleanupAll();
 		this._eventBus.removeAllListeners();
 		this._hooks.clear();

package/dist/src/extensions/config-validation.d.ts

@@ -0,0 +1,8 @@
+export type ExtensionConfigValidationResult = {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+    errors?: unknown;
+};
+export declare function validateExtensionConfig(schema: Record<string, unknown> | undefined, config: Record<string, unknown>): ExtensionConfigValidationResult;

package/dist/src/extensions/config-validation.js

@@ -0,0 +1,25 @@
+import Ajv from "ajv";
+//#region src/extensions/config-validation.ts
+const validator = new Ajv({
+	allErrors: true,
+	strict: false
+});
+function validateExtensionConfig(schema, config) {
+	if (!schema) return { valid: true };
+	try {
+		const validate = validator.compile(schema);
+		if (validate(config)) return { valid: true };
+		return {
+			valid: false,
+			reason: validator.errorsText(validate.errors, { separator: "; " }),
+			errors: validate.errors
+		};
+	} catch (error) {
+		return {
+			valid: false,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+//#endregion
+export { validateExtensionConfig };

package/dist/src/extensions/extension-registry-impl.d.ts

@@ -3,8 +3,7 @@
  * without going through `loader.ts` (which imports back from `api.ts`,
  * forming a circular cycle).
  *
- * `loader.ts` still re-exports the class for backward-compat; this file is a
- * leaf and only depends on the type definitions in `./types/index.js`.
+ * This file is a leaf and only depends on the type definitions in `./types/index.js`.
  */
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { ChannelPlugin } from '../channels/plugin-types.js';
@@ -18,6 +17,13 @@ export declare class ExtensionRegistryImpl implements ExtensionRegistry {
     gatewayMethods: Map<string, GatewayMethodHandler>;
     tools: Map<string, AgentTool<any, any>>;
     private toolExtensionIds;
+    private hookOwners;
+    private hookPriorities;
+    private channelOwners;
+    private httpRouteOwners;
+    private commandOwners;
+    private serviceOwners;
+    private gatewayMethodOwners;
     channelPlugins: ChannelPlugin[];
     private cliRegistrations;
     private reloadRegistrations;
@@ -26,17 +32,22 @@ export declare class ExtensionRegistryImpl implements ExtensionRegistry {
     addExtension(record: ExtensionRecord): void;
     getExtension(id: string): ExtensionRecord | undefined;
     getEnabledExtensions(): ExtensionRecord[];
-    addHook(event: ExtensionHookEvent, handler: ExtensionHookHandler, _extensionId: string, _priority?: number): void;
+    addHook(event: ExtensionHookEvent, handler: ExtensionHookHandler, extensionId: string, priority?: number): void;
+    removeHook(event: ExtensionHookEvent, handler: ExtensionHookHandler): void;
     getHooks(event: ExtensionHookEvent): ExtensionHookHandler[];
-    addChannelPlugin(plugin: ChannelPlugin): void;
-    addHttpRoute(path: string, handler: HttpRequestHandler): void;
-    getHttpRoute(path: string): HttpRequestHandler | undefined;
-    addCommand(command: ExtensionCommand): void;
+    addChannelPlugin(plugin: ChannelPlugin, extensionId?: string): void;
+    addHttpRoute(path: string, handler: HttpRequestHandler, extensionId?: string): void;
+    getHttpRoute(extensionId: string, path: string): HttpRequestHandler | undefined;
+    addCommand(command: ExtensionCommand, extensionId?: string): void;
     getCommand(name: string): ExtensionCommand | undefined;
-    addService(service: ExtensionService): void;
+    addService(service: ExtensionService, extensionId?: string): void;
     getService(id: string): ExtensionService | undefined;
-    addGatewayMethod(method: string, handler: GatewayMethodHandler): void;
+    addGatewayMethod(method: string, handler: GatewayMethodHandler, extensionId?: string): void;
     getGatewayMethod(method: string): GatewayMethodHandler | undefined;
+    getServicesForExtension(extensionId: string): ExtensionService[];
+    removeExtensionContributions(extensionId: string): void;
+    private removeOwnedEntries;
+    private httpRouteKey;
     addTool(tool: any, extensionId: string): void;
     removeTool(name: string): void;
     getTools(): Map<string, any>;

package/dist/src/extensions/extension-registry-impl.js

@@ -12,6 +12,13 @@ var ExtensionRegistryImpl = class {
 	gatewayMethods = /* @__PURE__ */ new Map();
 	tools = /* @__PURE__ */ new Map();
 	toolExtensionIds = /* @__PURE__ */ new Map();
+	hookOwners = /* @__PURE__ */ new Map();
+	hookPriorities = /* @__PURE__ */ new Map();
+	channelOwners = /* @__PURE__ */ new Map();
+	httpRouteOwners = /* @__PURE__ */ new Map();
+	commandOwners = /* @__PURE__ */ new Map();
+	serviceOwners = /* @__PURE__ */ new Map();
+	gatewayMethodOwners = /* @__PURE__ */ new Map();
 	channelPlugins = [];
 	cliRegistrations = [];
 	reloadRegistrations = [];
@@ -26,45 +33,106 @@ var ExtensionRegistryImpl = class {
 	getEnabledExtensions() {
 		return Array.from(this.extensions.values()).filter((p) => p.enabled);
 	}
-	addHook(event, handler, _extensionId, _priority = 0) {
+	addHook(event, handler, extensionId, priority = 0) {
 		if (!this.hooks.has(event)) this.hooks.set(event, []);
-		this.hooks.get(event).push(handler);
+		const owners = this.hookOwners.get(event) ?? /* @__PURE__ */ new Map();
+		const priorities = this.hookPriorities.get(event) ?? /* @__PURE__ */ new Map();
+		owners.set(handler, extensionId);
+		priorities.set(handler, priority);
+		this.hookOwners.set(event, owners);
+		this.hookPriorities.set(event, priorities);
+		const handlers = this.hooks.get(event);
+		handlers.push(handler);
+		handlers.sort((left, right) => (priorities.get(right) ?? 0) - (priorities.get(left) ?? 0));
+	}
+	removeHook(event, handler) {
+		const handlers = this.hooks.get(event);
+		if (!handlers) return;
+		const next = handlers.filter((candidate) => candidate !== handler);
+		if (next.length > 0) this.hooks.set(event, next);
+		else this.hooks.delete(event);
+		const owners = this.hookOwners.get(event);
+		const priorities = this.hookPriorities.get(event);
+		owners?.delete(handler);
+		priorities?.delete(handler);
+		if (owners?.size === 0) this.hookOwners.delete(event);
+		if (priorities?.size === 0) this.hookPriorities.delete(event);
 	}
 	getHooks(event) {
 		return this.hooks.get(event) || [];
 	}
-	addChannelPlugin(plugin) {
+	addChannelPlugin(plugin, extensionId = "") {
 		this.channelPlugins = this.channelPlugins.filter((p) => p.id !== plugin.id);
 		this.channelPlugins.push(plugin);
+		this.channelOwners.set(plugin.id, extensionId);
 	}
-	addHttpRoute(path, handler) {
-		if (this.httpRoutes.has(path)) log.warn({ path }, `HTTP route already registered, overwriting`);
-		this.httpRoutes.set(path, handler);
+	addHttpRoute(path, handler, extensionId = "") {
+		const key = this.httpRouteKey(extensionId, path);
+		if (this.httpRoutes.has(key)) log.warn({
+			extensionId,
+			path
+		}, `HTTP route already registered, overwriting`);
+		this.httpRoutes.set(key, handler);
+		this.httpRouteOwners.set(key, extensionId);
 	}
-	getHttpRoute(path) {
-		return this.httpRoutes.get(path);
+	getHttpRoute(extensionId, path) {
+		return this.httpRoutes.get(this.httpRouteKey(extensionId, path));
 	}
-	addCommand(command) {
+	addCommand(command, extensionId = "") {
 		if (this.commands.has(command.name)) log.warn({ command: command.name }, `Command already registered, overwriting`);
 		this.commands.set(command.name, command);
+		this.commandOwners.set(command.name, extensionId);
 	}
 	getCommand(name) {
 		return this.commands.get(name);
 	}
-	addService(service) {
+	addService(service, extensionId = "") {
 		if (this.services.has(service.id)) log.warn({ service: service.id }, `Service already registered, overwriting`);
 		this.services.set(service.id, service);
+		this.serviceOwners.set(service.id, extensionId);
 	}
 	getService(id) {
 		return this.services.get(id);
 	}
-	addGatewayMethod(method, handler) {
+	addGatewayMethod(method, handler, extensionId = "") {
 		if (this.gatewayMethods.has(method)) log.warn({ method }, `Gateway method already registered, overwriting`);
 		this.gatewayMethods.set(method, handler);
+		this.gatewayMethodOwners.set(method, extensionId);
 	}
 	getGatewayMethod(method) {
 		return this.gatewayMethods.get(method);
 	}
+	getServicesForExtension(extensionId) {
+		return [...this.services.entries()].filter(([id]) => this.serviceOwners.get(id) === extensionId).map(([, service]) => service);
+	}
+	removeExtensionContributions(extensionId) {
+		for (const [event, handlers] of this.hooks) for (const handler of [...handlers]) if (this.hookOwners.get(event)?.get(handler) === extensionId) this.removeHook(event, handler);
+		for (const [name, owner] of this.toolExtensionIds) if (owner === extensionId) this.removeTool(name);
+		this.channelPlugins = this.channelPlugins.filter((plugin) => {
+			const owned = this.channelOwners.get(plugin.id) === extensionId;
+			if (owned) this.channelOwners.delete(plugin.id);
+			return !owned;
+		});
+		this.removeOwnedEntries(this.httpRoutes, this.httpRouteOwners, extensionId);
+		this.removeOwnedEntries(this.commands, this.commandOwners, extensionId);
+		this.removeOwnedEntries(this.services, this.serviceOwners, extensionId);
+		this.removeOwnedEntries(this.gatewayMethods, this.gatewayMethodOwners, extensionId);
+		this.cliRegistrations = this.cliRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.reloadRegistrations = this.reloadRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.migrationRegistrations = this.migrationRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.tuiRegistrations = this.tuiRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.extensions.delete(extensionId);
+	}
+	removeOwnedEntries(values, owners, extensionId) {
+		for (const [key, owner] of owners) {
+			if (owner !== extensionId) continue;
+			owners.delete(key);
+			values.delete(key);
+		}
+	}
+	httpRouteKey(extensionId, path) {
+		return `${extensionId}:${path.startsWith("/") ? path : `/${path}`}`;
+	}
 	addTool(tool, extensionId) {
 		if (this.tools.has(tool.name)) log.warn({ tool: tool.name }, `Tool already registered, overwriting`);
 		this.tools.set(tool.name, tool);

package/dist/src/extensions/hooks.d.ts

@@ -2,7 +2,7 @@
  * Extension Hook System
  */
 import type { ExtensionHookEvent, HookAgentContext as HookContext, AgentMessage, BeforeAgentStartContext } from './types/hooks.js';
-import { ExtensionRegistryImpl as ExtensionRegistry } from './loader.js';
+import { ExtensionRegistryImpl as ExtensionRegistry } from './extension-registry-impl.js';
 export interface HookRunnerOptions {
     catchErrors?: boolean;
     logger?: HookLogger;

package/dist/src/extensions/index.d.ts

@@ -5,7 +5,8 @@
  */
 export * from './types/index.js';
 export { ExtensionApiImpl, createExtensionLogger, createPathResolver } from './api.js';
-export { ExtensionRegistryImpl, ExtensionLoader, normalizeExtensionConfig, resolveExtensionPath, areExtensionsGloballyDisabled } from './loader.js';
+export { ExtensionRegistryImpl } from './extension-registry-impl.js';
+export { ExtensionLoader, normalizeExtensionConfig, resolveExtensionPath, areExtensionsGloballyDisabled } from './loader.js';
 export type { ActivationPlanLoadOptions } from './loader.js';
 export type { ExtensionRegistry } from './types/core.js';
 export { ManifestRegistry, type ManifestRegistryEntry } from './manifest-registry.js';

package/dist/src/extensions/install-transaction.d.ts

@@ -8,6 +8,8 @@ export interface StagedExtensionInstall {
 }
 /** Extract, validate, install dependencies, and import-check an extension away from its live path. */
 export declare function stageExtensionStoreZip(buffer: Buffer, extensionsDir: string): Promise<StagedExtensionInstall>;
+export declare function stageExtensionNpm(packageSpec: string, extensionsDir: string, timeoutMs?: number): Promise<StagedExtensionInstall>;
+export declare function stageExtensionLocal(localPath: string, extensionsDir: string): Promise<StagedExtensionInstall>;
 /** Move a staged extension into its live path, preserving the previous version for rollback. */
 export declare function commitStagedExtensionInstall(state: StagedExtensionInstall, overwrite: boolean): void;
 /** Restore the previous live extension, or remove a newly committed install. */

package/dist/src/extensions/install-transaction.js

@@ -1,36 +1,47 @@
-import { installExtensionFromStoreZip } from "./install.js";
+import { installExtensionFromStoreZip, installFromLocal, installFromNpm } from "./install.js";
 import { join } from "node:path";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/extensions/install-transaction.ts
-/** Extract, validate, install dependencies, and import-check an extension away from its live path. */
-async function stageExtensionStoreZip(buffer, extensionsDir) {
+async function validateStagedInstall(result, stagingRoot, extensionsDir) {
+	if (!result.ok || !result.extensionId || !result.targetDir) throw new Error(result.error ?? "Extension staging failed");
+	const manifestPath = join(result.targetDir, "xopc.extension.json");
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	if (!manifest.main) throw new Error("Extension manifest must declare main");
+	const mainUrl = pathToFileURL(join(result.targetDir, manifest.main));
+	mainUrl.searchParams.set("xopcInstallCheck", `${Date.now()}-${Math.random()}`);
+	await import(mainUrl.href);
+	return {
+		extensionId: result.extensionId,
+		stagingRoot,
+		stagedExtensionDir: result.targetDir,
+		targetDir: join(extensionsDir, result.extensionId),
+		committed: false
+	};
+}
+async function stageExtensionInstall(extensionsDir, install) {
 	mkdirSync(extensionsDir, { recursive: true });
 	const stagingRoot = mkdtempSync(join(extensionsDir, ".xopc-install-"));
 	try {
-		const result = await installExtensionFromStoreZip(buffer, stagingRoot);
-		if (!result.ok || !result.extensionId || !result.targetDir) throw new Error(result.error ?? "Extension staging failed");
-		const manifestPath = join(result.targetDir, "xopc.extension.json");
-		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-		if (!manifest.main) throw new Error("Extension manifest must declare main");
-		const mainUrl = pathToFileURL(join(result.targetDir, manifest.main));
-		mainUrl.searchParams.set("xopcInstallCheck", `${Date.now()}-${Math.random()}`);
-		await import(mainUrl.href);
-		return {
-			extensionId: result.extensionId,
-			stagingRoot,
-			stagedExtensionDir: result.targetDir,
-			targetDir: join(extensionsDir, result.extensionId),
-			committed: false
-		};
-	} catch (err) {
+		return await validateStagedInstall(await install(stagingRoot), stagingRoot, extensionsDir);
+	} catch (error) {
 		rmSync(stagingRoot, {
 			recursive: true,
 			force: true
 		});
-		throw err;
+		throw error;
 	}
 }
+/** Extract, validate, install dependencies, and import-check an extension away from its live path. */
+async function stageExtensionStoreZip(buffer, extensionsDir) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installExtensionFromStoreZip(buffer, stagingRoot));
+}
+async function stageExtensionNpm(packageSpec, extensionsDir, timeoutMs) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installFromNpm(packageSpec, stagingRoot, timeoutMs));
+}
+async function stageExtensionLocal(localPath, extensionsDir) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installFromLocal(localPath, stagingRoot));
+}
 /** Move a staged extension into its live path, preserving the previous version for rollback. */
 function commitStagedExtensionInstall(state, overwrite) {
 	if (existsSync(state.targetDir)) {
@@ -71,4 +82,4 @@ function finalizeStagedExtensionInstall(state) {
 	state.backupDir = void 0;
 }
 //#endregion
-export { commitStagedExtensionInstall, finalizeStagedExtensionInstall, rollbackStagedExtensionInstall, stageExtensionStoreZip };
+export { commitStagedExtensionInstall, finalizeStagedExtensionInstall, rollbackStagedExtensionInstall, stageExtensionLocal, stageExtensionNpm, stageExtensionStoreZip };

package/dist/src/extensions/install.js

@@ -4,13 +4,14 @@ import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveBundledExtensionsDir, resolveExtensionsDir as resolveExtensionsDir$1 } from "../config/paths.js";
 import { MAX_EXTENSION_STORE_ZIP_BYTES } from "./store-zip-limits.js";
 import { checkEngineCompatibility } from "./engine-check.js";
+import { EXTENSION_API_VERSION, EXTENSION_UI_API_VERSION, checkExtensionApiCompatibility } from "./api-version.js";
 import { collectExtensionPackageDependencyIssues } from "./package-contract.js";
 import { execFileSync } from "node:child_process";
 import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import semver from "semver";
-import AdmZip from "adm-zip";
 import { tmpdir } from "os";
+import AdmZip from "adm-zip";
 //#region src/extensions/install.ts
 /**
 * Extension Installation Module
@@ -140,6 +141,7 @@ function installExtensionProdDependencies(extensionDir) {
 			"install",
 			"--prod",
 			"--no-frozen-lockfile",
+			"--package-import-method=copy",
 			...scriptArgs
 		]);
 		if (pnpm.ok) return pnpm;
@@ -488,6 +490,21 @@ async function installFromDirectory(sourceDir, extensionsDir) {
 		ok: false,
 		error: engineCheck.reason ?? `xopc ${PACKAGE_VERSION} does not satisfy engines.xopc ${manifest.engines.xopc}`
 	};
+	for (const [engineName, requiredRange, currentVersion] of [[
+		"extensionApi",
+		manifest.engines.extensionApi,
+		EXTENSION_API_VERSION
+	], [
+		"extensionUiApi",
+		manifest.engines.extensionUiApi,
+		EXTENSION_UI_API_VERSION
+	]]) {
+		const result = checkExtensionApiCompatibility(requiredRange, currentVersion, engineName);
+		if (result.parseWarning || !result.compatible) return {
+			ok: false,
+			error: result.reason ?? `Incompatible engines.${engineName}`
+		};
+	}
 	if (!manifest.main) return {
 		ok: false,
 		error: "Extension manifest must declare main"

package/dist/src/extensions/loader.d.ts

@@ -21,8 +21,8 @@ import { type SlotRegistry } from './slots.js';
 import { type ExtensionDiagnostics } from './diagnostics.js';
 export type { ExtensionLoaderOptions, ExtensionSourceOrigin } from './discover-extensions.js';
 export { areExtensionsGloballyDisabled } from './discover-extensions.js';
-export { ExtensionRegistryImpl } from './extension-registry-impl.js';
 import { ExtensionRegistryImpl } from './extension-registry-impl.js';
+export { ExtensionRegistryImpl } from './extension-registry-impl.js';
 export interface ActivationPlanLoadOptions extends Partial<ActivationContext> {
     phase?: ActivationLoadPhase | 'all';
 }
@@ -30,6 +30,7 @@ export declare class ExtensionLoader {
     private registry;
     private options;
     private extensionInstances;
+    private startedServiceIds;
     private jiti;
     private _appConfig?;
     private _runtimeContext?;
@@ -118,6 +119,7 @@ export declare class ExtensionLoader {
      * Respects configured preferred plugin from config.extensions.slots
      */
     private claimExtensionSlots;
+    private releaseExtensionSlots;
     loadManifest(extensionPath: string): ExtensionManifest | null;
     private moduleEntryCandidates;
     private loadModule;
@@ -125,10 +127,8 @@ export declare class ExtensionLoader {
     private initializeExtension;
     startServices(): Promise<void>;
     stopServices(): Promise<void>;
-    /**
-     * Basic type validation for config values
-     */
-    private validateType;
+    unloadExtension(extensionId: string): Promise<boolean>;
+    shutdown(): Promise<void>;
 }
 export declare function resolveExtensionPath(id: string, _options: ExtensionLoaderOptions): string | null;
 export declare function normalizeExtensionConfig(rawConfig: Record<string, unknown>): ResolvedExtensionConfig[];