@pooder/core 2.1.0 → 2.2.0

package/dist/index.mjs

@@ -1,20 +1,108 @@
 // src/service.ts
+function createServiceToken(name) {
+  if (!name) {
+    throw new Error("Service token name is required.");
+  }
+  return Object.freeze({
+    kind: "service-token",
+    key: Symbol(name),
+    name
+  });
+}
+function isServiceToken(identifier) {
+  return typeof identifier === "object" && identifier !== null && "kind" in identifier && identifier.kind === "service-token";
+}
 var ServiceRegistry = class {
   constructor() {
-    this.services = /* @__PURE__ */ new Map();
-  }
-  register(name, service) {
-    this.services.set(name, service);
+    this.servicesByName = /* @__PURE__ */ new Map();
+    this.servicesByToken = /* @__PURE__ */ new Map();
+    this.registrationOrder = [];
+  }
+  register(identifier, service, options = {}) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const existing = this.findEntry(normalized);
+    if (existing && !options.allowOverride) {
+      throw new Error(`Service "${normalized.name}" is already registered.`);
+    }
+    if (existing) {
+      this.removeEntry(existing);
+    }
+    const entry = {
+      token: normalized.token,
+      name: normalized.name,
+      service
+    };
+    this.servicesByName.set(entry.name, entry);
+    if (entry.token) {
+      this.servicesByToken.set(entry.token.key, entry);
+    }
+    this.registrationOrder.push(entry);
     return service;
   }
-  get(serviceName) {
-    return this.services.get(serviceName);
+  get(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    return entry == null ? void 0 : entry.service;
   }
-  has(serviceName) {
-    return this.services.has(serviceName);
+  getOrThrow(identifier, errorMessage) {
+    const service = this.get(identifier);
+    if (service) {
+      return service;
+    }
+    const normalized = this.normalizeIdentifier(identifier);
+    throw new Error(errorMessage != null ? errorMessage : `Service "${normalized.name}" not found.`);
+  }
+  has(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    return Boolean(this.findEntry(normalized));
+  }
+  delete(identifier) {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    if (!entry) {
+      return false;
+    }
+    this.removeEntry(entry);
+    return true;
   }
-  delete(serviceName) {
-    this.services.delete(serviceName);
+  list() {
+    return this.registrationOrder.map((entry) => ({
+      id: entry.name,
+      token: entry.token,
+      service: entry.service
+    }));
+  }
+  clear() {
+    this.servicesByName.clear();
+    this.servicesByToken.clear();
+    this.registrationOrder.length = 0;
+  }
+  findEntry(identifier) {
+    var _a;
+    if (identifier.token) {
+      return (_a = this.servicesByToken.get(identifier.token.key)) != null ? _a : this.servicesByName.get(identifier.name);
+    }
+    return this.servicesByName.get(identifier.name);
+  }
+  normalizeIdentifier(identifier) {
+    if (isServiceToken(identifier)) {
+      return { token: identifier, name: identifier.name };
+    }
+    const name = identifier.trim();
+    if (!name) {
+      throw new Error("Service identifier must be a non-empty string.");
+    }
+    return { name };
+  }
+  removeEntry(entry) {
+    this.servicesByName.delete(entry.name);
+    if (entry.token) {
+      this.servicesByToken.delete(entry.token.key);
+    }
+    const index = this.registrationOrder.lastIndexOf(entry);
+    if (index >= 0) {
+      this.registrationOrder.splice(index, 1);
+    }
   }
 };
 
@@ -172,127 +260,6 @@ var ContributionRegistry = class {
   }
 };
 
-// src/extension.ts
-var ExtensionRegistry = class extends Map {
-};
-var ExtensionManager = class {
-  constructor(context) {
-    this.extensionRegistry = new ExtensionRegistry();
-    this.extensionDisposables = /* @__PURE__ */ new Map();
-    this.context = context;
-  }
-  register(extension) {
-    if (this.extensionRegistry.has(extension.id)) {
-      console.warn(
-        `Plugin "${extension.id}" already registered. It will be overwritten.`
-      );
-    }
-    this.extensionDisposables.set(extension.id, []);
-    const disposables = this.extensionDisposables.get(extension.id);
-    if (extension.contribute) {
-      for (const [pointId, items] of Object.entries(extension.contribute())) {
-        if (Array.isArray(items)) {
-          items.forEach((item, index) => {
-            const contributionId = item.id || (item.command ? item.command : `${extension.id}.${pointId}.${index}`);
-            const contribution = {
-              id: contributionId,
-              metadata: {
-                extensionId: extension.id,
-                ...item == null ? void 0 : item.metadata
-              },
-              data: item
-            };
-            const disposable = this.context.contributions.register(
-              pointId,
-              contribution
-            );
-            disposables.push(disposable);
-            const dispose = this.collectContribution(pointId, contribution);
-            if (dispose) {
-              disposables.push(dispose);
-            }
-          });
-        }
-      }
-    }
-    try {
-      this.extensionRegistry.set(extension.id, extension);
-      this.context.eventBus.emit("extension:register", extension);
-    } catch (error) {
-      console.error(
-        `Error in onCreate hook for plugin "${extension.id}":`,
-        error
-      );
-    }
-    try {
-      extension.activate(this.context);
-    } catch (error) {
-      console.error(
-        `Error in onActivate hook for plugin "${extension.id}":`,
-        error
-      );
-    }
-    console.log(`Plugin "${extension.id}" registered successfully`);
-  }
-  collectContribution(pointId, item) {
-    if (pointId === ContributionPointIds.CONFIGURATIONS) {
-      const configService = this.context.services.get(
-        "ConfigurationService"
-      );
-      configService == null ? void 0 : configService.initializeDefaults([item.data]);
-    }
-    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
-      const commandService = this.context.services.get("CommandService");
-      return commandService.registerCommand(item.id, item.data.handler);
-    }
-    if (pointId === ContributionPointIds.TOOLS) {
-      const toolRegistry = this.context.services.get("ToolRegistryService");
-      if (!toolRegistry) return;
-      return toolRegistry.registerTool(item.data);
-    }
-  }
-  unregister(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-    try {
-      extension.deactivate(this.context);
-    } catch (error) {
-      console.error(`Error in deactivate for plugin "${name}":`, error);
-    }
-    const disposables = this.extensionDisposables.get(name);
-    if (disposables) {
-      disposables.forEach((d) => d.dispose());
-      this.extensionDisposables.delete(name);
-    }
-    this.extensionRegistry.delete(name);
-    console.log(`Plugin "${name}" unregistered`);
-    return true;
-  }
-  enable(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-  }
-  disable(name) {
-    const extension = this.extensionRegistry.get(name);
-    if (!extension) {
-      console.warn(`Plugin "${name}" not found.`);
-      return;
-    }
-  }
-  update() {
-  }
-  destroy() {
-    const extensionNames = Array.from(this.extensionRegistry.keys());
-    extensionNames.forEach((name) => this.unregister(name));
-  }
-};
-
 // src/services/CommandService.ts
 var CommandService = class {
   constructor() {
@@ -487,11 +454,42 @@ var ToolRegistryService = class {
   }
 };
 
+// src/services/tokens.ts
+var COMMAND_SERVICE = createServiceToken(
+  "CommandService"
+);
+var CONFIGURATION_SERVICE = createServiceToken(
+  "ConfigurationService"
+);
+var TOOL_REGISTRY_SERVICE = createServiceToken("ToolRegistryService");
+var TOOL_SESSION_SERVICE = createServiceToken("ToolSessionService");
+var WORKBENCH_SERVICE = createServiceToken("WorkbenchService");
+var CORE_SERVICE_TOKENS = {
+  COMMAND: COMMAND_SERVICE,
+  CONFIGURATION: CONFIGURATION_SERVICE,
+  TOOL_REGISTRY: TOOL_REGISTRY_SERVICE,
+  TOOL_SESSION: TOOL_SESSION_SERVICE,
+  WORKBENCH: WORKBENCH_SERVICE
+};
+
 // src/services/ToolSessionService.ts
 var ToolSessionService = class {
-  constructor() {
+  constructor(dependencies = {}) {
     this.sessions = /* @__PURE__ */ new Map();
     this.dirtyTrackers = /* @__PURE__ */ new Map();
+    this.commandService = dependencies.commandService;
+    this.toolRegistry = dependencies.toolRegistry;
+  }
+  init(context) {
+    var _a, _b;
+    (_a = this.commandService) != null ? _a : this.commandService = context.get(COMMAND_SERVICE);
+    (_b = this.toolRegistry) != null ? _b : this.toolRegistry = context.get(TOOL_REGISTRY_SERVICE);
+    if (!this.commandService) {
+      throw new Error("ToolSessionService requires CommandService.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService requires ToolRegistryService.");
+    }
   }
   setCommandService(commandService) {
     this.commandService = commandService;
@@ -541,12 +539,23 @@ var ToolSessionService = class {
     session.lastUpdatedAt = Date.now();
   }
   resolveTool(toolId) {
-    var _a;
-    return (_a = this.toolRegistry) == null ? void 0 : _a.getTool(toolId);
+    return this.getToolRegistry().getTool(toolId);
   }
   async runCommand(commandId, ...args) {
-    if (!commandId || !this.commandService) return void 0;
-    return await this.commandService.executeCommand(commandId, ...args);
+    if (!commandId) return void 0;
+    return await this.getCommandService().executeCommand(commandId, ...args);
+  }
+  getCommandService() {
+    if (!this.commandService) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.commandService;
+  }
+  getToolRegistry() {
+    if (!this.toolRegistry) {
+      throw new Error("ToolSessionService is not initialized.");
+    }
+    return this.toolRegistry;
   }
   async begin(toolId) {
     var _a;
@@ -626,11 +635,27 @@ var ToolSessionService = class {
 
 // src/services/WorkbenchService.ts
 var WorkbenchService = class {
-  constructor() {
+  constructor(dependencies = {}) {
     this._activeToolId = null;
     this.guards = [];
-  }
-  init() {
+    this.eventBus = dependencies.eventBus;
+    this.toolRegistry = dependencies.toolRegistry;
+    this.sessionService = dependencies.sessionService;
+  }
+  init(context) {
+    var _a, _b, _c;
+    (_a = this.eventBus) != null ? _a : this.eventBus = context.eventBus;
+    (_b = this.toolRegistry) != null ? _b : this.toolRegistry = context.get(TOOL_REGISTRY_SERVICE);
+    (_c = this.sessionService) != null ? _c : this.sessionService = context.get(TOOL_SESSION_SERVICE);
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService requires EventBus.");
+    }
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService requires ToolRegistryService.");
+    }
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService requires ToolSessionService.");
+    }
   }
   dispose() {
     this.guards = [];
@@ -666,11 +691,14 @@ var WorkbenchService = class {
     return true;
   }
   async switchTool(id, options) {
-    var _a, _b, _c, _d, _e;
+    var _a;
+    const eventBus = this.getEventBus();
+    const toolRegistry = this.getToolRegistry();
+    const sessionService = this.getSessionService();
     if (this._activeToolId === id) {
       return { ok: true, from: this._activeToolId, to: id };
     }
-    if (id && this.toolRegistry && !this.toolRegistry.hasTool(id)) {
+    if (id && !toolRegistry.hasTool(id)) {
       return {
         ok: false,
         from: this._activeToolId,
@@ -685,7 +713,7 @@ var WorkbenchService = class {
     };
     const guardAllowed = await this.runGuards(context);
     if (!guardAllowed) {
-      (_a = this.eventBus) == null ? void 0 : _a.emit("tool:switch:blocked", {
+      eventBus.emit("tool:switch:blocked", {
         ...context,
         reason: "blocked-by-guard"
       });
@@ -696,12 +724,10 @@ var WorkbenchService = class {
         reason: "blocked-by-guard"
       };
     }
-    if (context.from && this.sessionService) {
-      const leaveResult = await this.sessionService.handleBeforeLeave(
-        context.from
-      );
+    if (context.from) {
+      const leaveResult = await sessionService.handleBeforeLeave(context.from);
       if (leaveResult.decision === "blocked") {
-        (_b = this.eventBus) == null ? void 0 : _b.emit("tool:switch:blocked", {
+        eventBus.emit("tool:switch:blocked", {
           ...context,
           reason: leaveResult.reason || "session-blocked"
         });
@@ -712,19 +738,19 @@ var WorkbenchService = class {
           reason: leaveResult.reason || "session-blocked"
         };
       }
-      this.sessionService.deactivateSession(context.from);
+      sessionService.deactivateSession(context.from);
     }
-    if (id && this.sessionService && this.toolRegistry) {
-      const tool = this.toolRegistry.getTool(id);
-      if ((tool == null ? void 0 : tool.interaction) === "session" && ((_c = tool.session) == null ? void 0 : _c.autoBegin) !== false) {
-        await this.sessionService.begin(id);
+    if (id) {
+      const tool = toolRegistry.getTool(id);
+      if ((tool == null ? void 0 : tool.interaction) === "session" && ((_a = tool.session) == null ? void 0 : _a.autoBegin) !== false) {
+        await sessionService.begin(id);
       }
     }
     const previous = this._activeToolId;
     this._activeToolId = id;
     const reason = options == null ? void 0 : options.reason;
-    (_d = this.eventBus) == null ? void 0 : _d.emit("tool:activated", { id, previous, reason });
-    (_e = this.eventBus) == null ? void 0 : _e.emit("tool:switch", { from: previous, to: id, reason });
+    eventBus.emit("tool:activated", { id, previous, reason });
+    eventBus.emit("tool:switch", { from: previous, to: id, reason });
     return { ok: true, from: previous, to: id };
   }
   async activate(id) {
@@ -733,6 +759,147 @@ var WorkbenchService = class {
   async deactivate() {
     return await this.switchTool(null, { reason: "deactivate" });
   }
+  getEventBus() {
+    if (!this.eventBus) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.eventBus;
+  }
+  getToolRegistry() {
+    if (!this.toolRegistry) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.toolRegistry;
+  }
+  getSessionService() {
+    if (!this.sessionService) {
+      throw new Error("WorkbenchService is not initialized.");
+    }
+    return this.sessionService;
+  }
+};
+
+// src/extension.ts
+var ExtensionRegistry = class extends Map {
+};
+var ExtensionManager = class {
+  constructor(context) {
+    this.extensionRegistry = new ExtensionRegistry();
+    this.extensionDisposables = /* @__PURE__ */ new Map();
+    this.context = context;
+  }
+  register(extension) {
+    if (this.extensionRegistry.has(extension.id)) {
+      console.warn(
+        `Plugin "${extension.id}" already registered. It will be overwritten.`
+      );
+    }
+    this.extensionDisposables.set(extension.id, []);
+    const disposables = this.extensionDisposables.get(extension.id);
+    if (extension.contribute) {
+      for (const [pointId, items] of Object.entries(extension.contribute())) {
+        if (Array.isArray(items)) {
+          items.forEach((item, index) => {
+            const contributionId = item.id || (item.command ? item.command : `${extension.id}.${pointId}.${index}`);
+            const contribution = {
+              id: contributionId,
+              metadata: {
+                extensionId: extension.id,
+                ...item == null ? void 0 : item.metadata
+              },
+              data: item
+            };
+            const disposable = this.context.contributions.register(
+              pointId,
+              contribution
+            );
+            disposables.push(disposable);
+            const dispose = this.collectContribution(pointId, contribution);
+            if (dispose) {
+              disposables.push(dispose);
+            }
+          });
+        }
+      }
+    }
+    try {
+      this.extensionRegistry.set(extension.id, extension);
+      this.context.eventBus.emit("extension:register", extension);
+    } catch (error) {
+      console.error(
+        `Error in onCreate hook for plugin "${extension.id}":`,
+        error
+      );
+    }
+    try {
+      extension.activate(this.context);
+    } catch (error) {
+      console.error(
+        `Error in onActivate hook for plugin "${extension.id}":`,
+        error
+      );
+    }
+    console.log(`Plugin "${extension.id}" registered successfully`);
+  }
+  collectContribution(pointId, item) {
+    if (pointId === ContributionPointIds.CONFIGURATIONS) {
+      const configService = this.context.services.get(
+        CONFIGURATION_SERVICE
+      );
+      configService == null ? void 0 : configService.initializeDefaults([item.data]);
+    }
+    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
+      const commandService = this.context.services.get(COMMAND_SERVICE);
+      return commandService.registerCommand(item.id, item.data.handler);
+    }
+    if (pointId === ContributionPointIds.TOOLS) {
+      const toolRegistry = this.context.services.get(
+        TOOL_REGISTRY_SERVICE
+      );
+      if (!toolRegistry) return;
+      return toolRegistry.registerTool(item.data);
+    }
+  }
+  unregister(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+    try {
+      extension.deactivate(this.context);
+    } catch (error) {
+      console.error(`Error in deactivate for plugin "${name}":`, error);
+    }
+    const disposables = this.extensionDisposables.get(name);
+    if (disposables) {
+      disposables.forEach((d) => d.dispose());
+      this.extensionDisposables.delete(name);
+    }
+    this.extensionRegistry.delete(name);
+    console.log(`Plugin "${name}" unregistered`);
+    return true;
+  }
+  enable(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+  }
+  disable(name) {
+    const extension = this.extensionRegistry.get(name);
+    if (!extension) {
+      console.warn(`Plugin "${name}" not found.`);
+      return;
+    }
+  }
+  update() {
+  }
+  destroy() {
+    const extensionNames = Array.from(this.extensionRegistry.keys());
+    extensionNames.forEach((name) => this.unregister(name));
+  }
 };
 
 // src/index.ts
@@ -740,27 +907,37 @@ var Pooder = class {
   constructor() {
     this.eventBus = new event_default();
     this.services = new ServiceRegistry();
+    this.serviceContext = {
+      eventBus: this.eventBus,
+      get: (identifier) => this.services.get(identifier),
+      getOrThrow: (identifier, errorMessage) => this.services.getOrThrow(identifier, errorMessage),
+      has: (identifier) => this.services.has(identifier)
+    };
     this.contributions = new ContributionRegistry();
     this.initDefaultContributionPoints();
     const commandService = new CommandService();
-    this.registerService(commandService, "CommandService");
+    this.registerService(commandService, CORE_SERVICE_TOKENS.COMMAND);
     const configurationService = new ConfigurationService();
-    this.registerService(configurationService, "ConfigurationService");
+    this.registerService(configurationService, CORE_SERVICE_TOKENS.CONFIGURATION);
     const toolRegistryService = new ToolRegistryService();
-    this.registerService(toolRegistryService, "ToolRegistryService");
-    const toolSessionService = new ToolSessionService();
-    toolSessionService.setCommandService(commandService);
-    toolSessionService.setToolRegistry(toolRegistryService);
-    this.registerService(toolSessionService, "ToolSessionService");
-    const workbenchService = new WorkbenchService();
-    workbenchService.setEventBus(this.eventBus);
-    workbenchService.setToolRegistry(toolRegistryService);
-    workbenchService.setToolSessionService(toolSessionService);
-    this.registerService(workbenchService, "WorkbenchService");
+    this.registerService(toolRegistryService, CORE_SERVICE_TOKENS.TOOL_REGISTRY);
+    const toolSessionService = new ToolSessionService({
+      commandService,
+      toolRegistry: toolRegistryService
+    });
+    this.registerService(toolSessionService, CORE_SERVICE_TOKENS.TOOL_SESSION);
+    const workbenchService = new WorkbenchService({
+      eventBus: this.eventBus,
+      toolRegistry: toolRegistryService,
+      sessionService: toolSessionService
+    });
+    this.registerService(workbenchService, CORE_SERVICE_TOKENS.WORKBENCH);
     const context = {
       eventBus: this.eventBus,
       services: {
-        get: (serviceName) => this.services.get(serviceName)
+        get: (identifier) => this.services.get(identifier),
+        getOrThrow: (identifier, errorMessage) => this.services.getOrThrow(identifier, errorMessage),
+        has: (identifier) => this.services.has(identifier)
       },
       contributions: {
         get: (pointId) => this.getContributions(pointId),
@@ -792,38 +969,102 @@ var Pooder = class {
     });
   }
   // --- Service Management ---
-  registerService(service, id) {
-    var _a;
-    const serviceId = id || service.constructor.name;
+  registerService(service, identifier, options = {}) {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
     try {
-      (_a = service == null ? void 0 : service.init) == null ? void 0 : _a.call(service);
-    } catch (e) {
-      console.error(`Error initializing service ${serviceId}:`, e);
+      const initResult = this.invokeServiceHook(service, "init");
+      if (this.isPromiseLike(initResult)) {
+        throw new Error(
+          `Service "${serviceId}" init() is async. Use registerServiceAsync() instead.`
+        );
+      }
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
       return false;
     }
-    this.services.register(serviceId, service);
-    this.eventBus.emit("service:register", service);
+  }
+  async registerServiceAsync(service, identifier, options = {}) {
+    const serviceIdentifier = this.resolveServiceIdentifier(service, identifier);
+    const serviceId = this.getServiceLabel(serviceIdentifier);
+    try {
+      await this.invokeServiceHookAsync(service, "init");
+      this.services.register(serviceIdentifier, service, options);
+      this.eventBus.emit("service:register", service, { id: serviceId });
+      return true;
+    } catch (error) {
+      console.error(`Error initializing service ${serviceId}:`, error);
+      return false;
+    }
+  }
+  unregisterService(serviceOrIdentifier, id) {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+    if (!registeredService) {
+      console.warn(`Service ${serviceId} is not registered.`);
+      return true;
+    }
+    try {
+      const disposeResult = this.invokeServiceHook(registeredService, "dispose");
+      if (this.isPromiseLike(disposeResult)) {
+        throw new Error(
+          `Service "${serviceId}" dispose() is async. Use unregisterServiceAsync() instead.`
+        );
+      }
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
+      return false;
+    }
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
-  unregisterService(service, id) {
-    var _a;
-    const serviceId = id || service.constructor.name;
-    if (!this.services.has(serviceId)) {
+  async unregisterServiceAsync(serviceOrIdentifier, id) {
+    const resolvedIdentifier = this.resolveUnregisterIdentifier(
+      serviceOrIdentifier,
+      id
+    );
+    const serviceId = this.getServiceLabel(resolvedIdentifier);
+    const registeredService = this.services.get(resolvedIdentifier);
+    if (!registeredService) {
       console.warn(`Service ${serviceId} is not registered.`);
       return true;
     }
     try {
-      (_a = service == null ? void 0 : service.dispose) == null ? void 0 : _a.call(service);
-    } catch (e) {
-      console.error(`Error disposing service ${serviceId}:`, e);
+      await this.invokeServiceHookAsync(registeredService, "dispose");
+    } catch (error) {
+      console.error(`Error disposing service ${serviceId}:`, error);
       return false;
     }
-    this.services.delete(serviceId);
-    this.eventBus.emit("service:unregister", service);
+    this.services.delete(resolvedIdentifier);
+    this.eventBus.emit("service:unregister", registeredService, { id: serviceId });
     return true;
   }
-  getService(id) {
-    return this.services.get(id);
+  getService(identifier) {
+    return this.services.get(identifier);
+  }
+  getServiceOrThrow(identifier, errorMessage) {
+    return this.services.getOrThrow(identifier, errorMessage);
+  }
+  hasService(identifier) {
+    return this.services.has(identifier);
+  }
+  async dispose() {
+    var _a;
+    this.extensionManager.destroy();
+    const registrations = this.services.list().slice().reverse();
+    for (const item of registrations) {
+      const identifier = (_a = item.token) != null ? _a : item.id;
+      await this.unregisterServiceAsync(identifier);
+    }
+    this.services.clear();
   }
   // --- Contribution Management ---
   registerContributionPoint(point) {
@@ -838,8 +1079,39 @@ var Pooder = class {
   getContributions(pointId) {
     return this.contributions.get(pointId);
   }
+  resolveServiceIdentifier(service, identifier) {
+    return identifier != null ? identifier : service.constructor.name;
+  }
+  resolveUnregisterIdentifier(serviceOrIdentifier, id) {
+    if (typeof serviceOrIdentifier === "string" || isServiceToken(serviceOrIdentifier)) {
+      return serviceOrIdentifier;
+    }
+    return id != null ? id : serviceOrIdentifier.constructor.name;
+  }
+  getServiceLabel(identifier) {
+    if (typeof identifier === "string") {
+      return identifier;
+    }
+    return identifier.name;
+  }
+  invokeServiceHook(service, hook) {
+    const handler = service[hook];
+    if (!handler) {
+      return;
+    }
+    return handler.call(service, this.serviceContext);
+  }
+  async invokeServiceHookAsync(service, hook) {
+    await this.invokeServiceHook(service, hook);
+  }
+  isPromiseLike(value) {
+    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+  }
 };
 export {
+  COMMAND_SERVICE,
+  CONFIGURATION_SERVICE,
+  CORE_SERVICE_TOKENS,
   CommandService,
   ConfigurationService,
   ContributionPointIds,
@@ -849,7 +1121,12 @@ export {
   ExtensionRegistry,
   Pooder,
   ServiceRegistry,
+  TOOL_REGISTRY_SERVICE,
+  TOOL_SESSION_SERVICE,
   ToolRegistryService,
   ToolSessionService,
-  WorkbenchService
+  WORKBENCH_SERVICE,
+  WorkbenchService,
+  createServiceToken,
+  isServiceToken
 };