@objectstack/core 4.0.3 → 4.0.5

package/dist/index.cjs

@@ -39,7 +39,6 @@ __export(index_exports, {
   ObjectKernel: () => ObjectKernel,
   ObjectKernelBase: () => ObjectKernelBase,
   ObjectLogger: () => ObjectLogger,
-  PackageManager: () => PackageManager,
   PluginConfigValidator: () => PluginConfigValidator,
   PluginHealthMonitor: () => PluginHealthMonitor,
   PluginLoader: () => PluginLoader,
@@ -160,7 +159,13 @@ var ObjectKernelBase = class {
         }
       },
       logger: this.logger,
-      getKernel: () => this
+      getKernel: () => this,
+      registerServiceFactory: (_name, _factory, _lifecycle, _dependencies) => {
+        throw new Error("[KernelBase] registerServiceFactory not supported \u2014 use ObjectKernel");
+      },
+      getServiceScoped: async (_name, _scopeId) => {
+        throw new Error("[KernelBase] getServiceScoped not supported \u2014 use ObjectKernel");
+      }
     };
   }
   /**
@@ -279,145 +284,58 @@ var ObjectKernelBase = class {
   }
 };
 
-// src/utils/env.ts
-var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-function getEnv(key, defaultValue) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[key] || defaultValue;
-  }
-  try {
-    if (typeof globalThis !== "undefined" && globalThis.process?.env) {
-      return globalThis.process.env[key] || defaultValue;
-    }
-  } catch (e) {
-  }
-  return defaultValue;
-}
-function safeExit(code = 0) {
-  if (isNode) {
-    process.exit(code);
-  }
-}
-function getMemoryUsage() {
-  if (isNode) {
-    return process.memoryUsage();
-  }
-  return { heapUsed: 0, heapTotal: 0 };
-}
-
 // src/logger.ts
-var import_meta = {};
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4,
+  silent: 5
+};
+var LEVEL_COLORS = {
+  debug: "\x1B[36m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m",
+  fatal: "\x1B[35m",
+  silent: ""
+};
+var RESET = "\x1B[0m";
 var ObjectLogger = class _ObjectLogger {
-  // CommonJS require function for Node.js
-  constructor(config = {}) {
-    this.isNode = isNode;
+  constructor(config = {}, bindings = {}) {
     this.config = {
       name: config.name,
       level: config.level ?? "info",
-      format: config.format ?? (this.isNode ? "json" : "pretty"),
+      format: config.format ?? "pretty",
       redact: config.redact ?? ["password", "token", "secret", "key"],
       sourceLocation: config.sourceLocation ?? false,
       file: config.file,
-      rotation: config.rotation ?? {
-        maxSize: "10m",
-        maxFiles: 5
-      }
+      rotation: config.rotation ?? { maxSize: "10m", maxFiles: 5 }
     };
-    if (this.isNode) {
-      this.initPinoLogger();
+    this.bindings = bindings;
+    if (this.config.file && typeof process !== "undefined") {
+      this.openFileStream(this.config.file);
     }
   }
-  /**
-   * Initialize Pino logger for Node.js
-   */
-  async initPinoLogger() {
-    if (!this.isNode) return;
+  openFileStream(path) {
     try {
-      const { createRequire } = await import("module");
-      this.require = createRequire(import_meta.url);
-      const pino = this.require("pino");
-      const pinoOptions = {
-        level: this.config.level,
-        redact: {
-          paths: this.config.redact,
-          censor: "***REDACTED***"
-        }
-      };
-      if (this.config.name) {
-        pinoOptions.name = this.config.name;
-      }
-      const targets = [];
-      if (this.config.format === "pretty") {
-        let hasPretty = false;
-        try {
-          this.require.resolve("pino-pretty");
-          hasPretty = true;
-        } catch (e) {
-        }
-        if (hasPretty) {
-          targets.push({
-            target: "pino-pretty",
-            options: {
-              colorize: true,
-              translateTime: "SYS:standard",
-              ignore: "pid,hostname"
-            },
-            level: this.config.level
-          });
-        } else {
-          console.warn("[Logger] pino-pretty not found. Install it for pretty logging: pnpm add -D pino-pretty");
-          targets.push({
-            target: "pino/file",
-            options: { destination: 1 },
-            level: this.config.level
-          });
-        }
-      } else if (this.config.format === "json") {
-        targets.push({
-          target: "pino/file",
-          options: { destination: 1 },
-          // stdout
-          level: this.config.level
-        });
-      } else {
-        targets.push({
-          target: "pino/file",
-          options: { destination: 1 },
-          level: this.config.level
-        });
-      }
-      if (this.config.file) {
-        targets.push({
-          target: "pino/file",
-          options: {
-            destination: this.config.file,
-            mkdir: true
-          },
-          level: this.config.level
-        });
-      }
-      if (targets.length > 0) {
-        pinoOptions.transport = targets.length === 1 ? targets[0] : { targets };
-      }
-      this.pinoInstance = pino(pinoOptions);
-      this.pinoLogger = this.pinoInstance;
-    } catch (error) {
-      console.warn("[Logger] Pino not available, falling back to console:", error);
-      this.pinoLogger = null;
+      const fs = require("fs");
+      const dir = require("path").dirname(path);
+      fs.mkdirSync(dir, { recursive: true });
+      this.fileStream = fs.createWriteStream(path, { flags: "a" });
+    } catch {
     }
   }
-  /**
-   * Redact sensitive keys from context object (for browser)
-   */
+  isEnabled(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.config.level];
+  }
   redactSensitive(obj) {
     if (!obj || typeof obj !== "object") return obj;
     const redacted = Array.isArray(obj) ? [...obj] : { ...obj };
     for (const key in redacted) {
-      const lowerKey = key.toLowerCase();
-      const shouldRedact = this.config.redact.some(
-        (pattern) => lowerKey.includes(pattern.toLowerCase())
-      );
-      if (shouldRedact) {
+      const lower = key.toLowerCase();
+      if (this.config.redact.some((p) => lower.includes(p.toLowerCase()))) {
         redacted[key] = "***REDACTED***";
       } else if (typeof redacted[key] === "object" && redacted[key] !== null) {
         redacted[key] = this.redactSensitive(redacted[key]);
@@ -425,146 +343,89 @@ var ObjectLogger = class _ObjectLogger {
     }
     return redacted;
   }
-  /**
-   * Format log entry for browser
-   */
-  formatBrowserLog(level, message, context) {
+  write(level, message, meta, error) {
+    if (!this.isEnabled(level)) return;
+    const context = this.redactSensitive({
+      ...this.bindings,
+      ...meta,
+      ...error ? { error: { message: error.message, stack: error.stack } } : {}
+    });
+    const hasContext = Object.keys(context).length > 0;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    let line;
     if (this.config.format === "json") {
-      return JSON.stringify({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      line = JSON.stringify({
+        time: ts,
         level,
-        message,
+        ...this.config.name ? { name: this.config.name } : {},
+        msg: message,
         ...context
       });
-    }
-    if (this.config.format === "text") {
-      const parts = [(/* @__PURE__ */ new Date()).toISOString(), level.toUpperCase(), message];
-      if (context && Object.keys(context).length > 0) {
-        parts.push(JSON.stringify(context));
+    } else if (this.config.format === "text") {
+      const parts = [ts, level.toUpperCase(), message];
+      if (hasContext) parts.push(JSON.stringify(context));
+      line = parts.join(" | ");
+    } else {
+      const color = LEVEL_COLORS[level] || "";
+      const label = this.config.name ? `[${this.config.name}] ` : "";
+      line = `${color}${ts} ${level.toUpperCase()}${RESET} ${label}${message}`;
+      if (hasContext) line += ` ${JSON.stringify(context)}`;
+    }
+    const out = line + "\n";
+    if (typeof process !== "undefined" && process.stderr) {
+      if (level === "error" || level === "fatal") {
+        process.stderr.write(out);
+      } else {
+        process.stdout?.write(out);
       }
-      return parts.join(" | ");
-    }
-    const levelColors = {
-      debug: "\x1B[36m",
-      // Cyan
-      info: "\x1B[32m",
-      // Green
-      warn: "\x1B[33m",
-      // Yellow
-      error: "\x1B[31m",
-      // Red
-      fatal: "\x1B[35m",
-      // Magenta
-      silent: ""
-    };
-    const reset = "\x1B[0m";
-    const color = levelColors[level] || "";
-    let output = `${color}[${level.toUpperCase()}]${reset} ${message}`;
-    if (context && Object.keys(context).length > 0) {
-      output += ` ${JSON.stringify(context, null, 2)}`;
+    } else if (typeof console !== "undefined") {
+      const fn = level === "error" || level === "fatal" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log;
+      fn(line);
+    }
+    if (this.fileStream) {
+      this.fileStream.write(out);
     }
-    return output;
-  }
-  /**
-   * Log using browser console
-   */
-  logBrowser(level, message, context, error) {
-    const redactedContext = context ? this.redactSensitive(context) : void 0;
-    const mergedContext = error ? { ...redactedContext, error: { message: error.message, stack: error.stack } } : redactedContext;
-    const formatted = this.formatBrowserLog(level, message, mergedContext);
-    const consoleMethod = level === "debug" ? "debug" : level === "info" ? "log" : level === "warn" ? "warn" : level === "error" || level === "fatal" ? "error" : "log";
-    console[consoleMethod](formatted);
   }
-  /**
-   * Public logging methods
-   */
   debug(message, meta) {
-    if (this.isNode && this.pinoLogger) {
-      this.pinoLogger.debug(meta || {}, message);
-    } else {
-      this.logBrowser("debug", message, meta);
-    }
+    this.write("debug", message, meta);
   }
   info(message, meta) {
-    if (this.isNode && this.pinoLogger) {
-      this.pinoLogger.info(meta || {}, message);
-    } else {
-      this.logBrowser("info", message, meta);
-    }
+    this.write("info", message, meta);
   }
   warn(message, meta) {
-    if (this.isNode && this.pinoLogger) {
-      this.pinoLogger.warn(meta || {}, message);
-    } else {
-      this.logBrowser("warn", message, meta);
-    }
+    this.write("warn", message, meta);
   }
   error(message, errorOrMeta, meta) {
-    let error;
-    let context = {};
     if (errorOrMeta instanceof Error) {
-      error = errorOrMeta;
-      context = meta || {};
-    } else {
-      context = errorOrMeta || {};
-    }
-    if (this.isNode && this.pinoLogger) {
-      const errorContext = error ? { err: error, ...context } : context;
-      this.pinoLogger.error(errorContext, message);
+      this.write("error", message, meta, errorOrMeta);
     } else {
-      this.logBrowser("error", message, context, error);
+      this.write("error", message, errorOrMeta);
     }
   }
   fatal(message, errorOrMeta, meta) {
-    let error;
-    let context = {};
     if (errorOrMeta instanceof Error) {
-      error = errorOrMeta;
-      context = meta || {};
-    } else {
-      context = errorOrMeta || {};
-    }
-    if (this.isNode && this.pinoLogger) {
-      const errorContext = error ? { err: error, ...context } : context;
-      this.pinoLogger.fatal(errorContext, message);
+      this.write("fatal", message, meta, errorOrMeta);
     } else {
-      this.logBrowser("fatal", message, context, error);
+      this.write("fatal", message, errorOrMeta);
     }
   }
-  /**
-   * Create a child logger with additional context
-   * Note: Child loggers share the parent's Pino instance
-   */
+  log(message, ...args) {
+    this.info(message, args.length > 0 ? { args } : void 0);
+  }
   child(context) {
-    const childLogger = new _ObjectLogger(this.config);
-    if (this.isNode && this.pinoInstance) {
-      childLogger.pinoLogger = this.pinoInstance.child(context);
-      childLogger.pinoInstance = this.pinoInstance;
-    }
-    return childLogger;
+    const child = new _ObjectLogger(this.config, { ...this.bindings, ...context });
+    child.fileStream = this.fileStream;
+    return child;
   }
-  /**
-   * Set trace context for distributed tracing
-   */
   withTrace(traceId, spanId) {
     return this.child({ traceId, spanId });
   }
-  /**
-   * Cleanup resources
-   */
   async destroy() {
-    if (this.pinoLogger && this.pinoLogger.flush) {
-      await new Promise((resolve) => {
-        this.pinoLogger.flush(() => resolve());
-      });
+    if (this.fileStream) {
+      await new Promise((resolve) => this.fileStream.end(resolve));
+      this.fileStream = void 0;
     }
   }
-  /**
-   * Compatibility method for console.log usage
-   */
-  log(message, ...args) {
-    this.info(message, args.length > 0 ? { args } : void 0);
-  }
 };
 function createLogger(config) {
   return new ObjectLogger(config);
@@ -985,13 +846,13 @@ var PluginLoader = class {
     const scope = this.scopedServices.get(scopeId);
     let instance = scope.get(registration.name);
     if (!instance) {
-      instance = await this.createServiceInstance(registration);
+      instance = await this.createServiceInstance(registration, scopeId);
       scope.set(registration.name, instance);
       this.logger.debug(`Scoped service created: ${registration.name} (scope: ${scopeId})`);
     }
     return instance;
   }
-  async createServiceInstance(registration) {
+  async createServiceInstance(registration, scopeId) {
     if (!this.context) {
       throw new Error(`[PluginLoader] Context not set - cannot create service '${registration.name}'`);
     }
@@ -1000,13 +861,39 @@ var PluginLoader = class {
     }
     this.creating.add(registration.name);
     try {
-      return await registration.factory(this.context);
+      return await registration.factory(this.context, scopeId);
     } finally {
       this.creating.delete(registration.name);
     }
   }
 };
 
+// src/utils/env.ts
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+function getEnv(key, defaultValue) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[key] || defaultValue;
+  }
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.process?.env) {
+      return globalThis.process.env[key] || defaultValue;
+    }
+  } catch (e) {
+  }
+  return defaultValue;
+}
+function safeExit(code = 0) {
+  if (isNode) {
+    process.exit(code);
+  }
+}
+function getMemoryUsage() {
+  if (isNode) {
+    return process.memoryUsage();
+  }
+  return { heapUsed: 0, heapTotal: 0 };
+}
+
 // src/fallbacks/memory-cache.ts
 function createMemoryCache() {
   const store = /* @__PURE__ */ new Map();
@@ -1097,6 +984,22 @@ function createMemoryJob() {
 }
 
 // src/fallbacks/memory-i18n.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const tVal = target[key];
+    const sVal = source[key];
+    if (tVal && sVal && typeof tVal === "object" && !Array.isArray(tVal) && typeof sVal === "object" && !Array.isArray(sVal)) {
+      result[key] = deepMerge(
+        tVal,
+        sVal
+      );
+    } else {
+      result[key] = sVal;
+    }
+  }
+  return result;
+}
 function resolveLocale(requestedLocale, availableLocales) {
   if (availableLocales.length === 0) return void 0;
   if (availableLocales.includes(requestedLocale)) return requestedLocale;
@@ -1142,8 +1045,12 @@ function createMemoryI18n() {
       return resolveTranslations(locale) ?? {};
     },
     loadTranslations(locale, data) {
-      const existing = translations.get(locale) ?? {};
-      translations.set(locale, { ...existing, ...data });
+      const existing = translations.get(locale);
+      if (existing) {
+        translations.set(locale, deepMerge(existing, data));
+      } else {
+        translations.set(locale, { ...data });
+      }
     },
     getLocales() {
       return [...translations.keys()];
@@ -1232,6 +1139,9 @@ var ObjectKernel = class {
       registerService: (name, service) => {
         this.registerService(name, service);
       },
+      registerServiceFactory: (name, factory, lifecycle, dependencies) => {
+        this.registerServiceFactory(name, factory, lifecycle, dependencies);
+      },
       getService: (name) => {
         const service = this.services.get(name);
         if (service) {
@@ -1285,6 +1195,9 @@ var ObjectKernel = class {
       getServices: () => {
         return new Map(this.services);
       },
+      getServiceScoped: (name, scopeId) => {
+        return this.pluginLoader.getService(name, scopeId);
+      },
       logger: this.logger,
       getKernel: () => this
       // Type compatibility
@@ -1426,6 +1339,7 @@ var ObjectKernel = class {
         const result = await this.startPluginWithTimeout(plugin);
         if (!result.success) {
           this.logger.error(`Plugin startup failed: ${plugin.name}`, result.error);
+          console.error(`[Kernel] Plugin startup failed: ${plugin.name}`, result.error instanceof Error ? result.error.message : result.error, result.error instanceof Error ? result.error.stack : "");
           if (this.config.rollbackOnFailure) {
             this.logger.warn("Rolling back started plugins...");
             await this.rollbackStartedPlugins();
@@ -1458,17 +1372,19 @@ var ObjectKernel = class {
     try {
       const shutdownPromise = this.performShutdown();
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
+        const t = setTimeout(() => {
           reject(new Error("Shutdown timeout exceeded"));
         }, this.config.shutdownTimeout);
+        if (t.unref) t.unref();
       });
       await Promise.race([shutdownPromise, timeoutPromise]);
       this.state = "stopped";
       this.logger.info("\u2705 Graceful shutdown complete");
     } catch (error) {
-      this.logger.error("Shutdown error - forcing stop", error);
+      this.logger.error("Shutdown timed out \u2014 forcing exit", error);
       this.state = "stopped";
-      throw error;
+      await this.logger.destroy();
+      process.exit(1);
     } finally {
       await this.logger.destroy();
     }
@@ -1508,6 +1424,13 @@ var ObjectKernel = class {
   async getServiceAsync(name, scopeId) {
     return await this.pluginLoader.getService(name, scopeId);
   }
+  /**
+   * Clear all scoped service instances for a given scope (e.g., projectId).
+   * Releases driver connections and metadata caches for idle projects.
+   */
+  clearScope(scopeId) {
+    this.pluginLoader.clearScope(scopeId);
+  }
   /**
    * Check if kernel is running
    */
@@ -3087,6 +3010,12 @@ var SecurePluginContext = class {
   getKernel() {
     return this.baseContext.getKernel();
   }
+  registerServiceFactory(name, factory, lifecycle, dependencies) {
+    this.baseContext.registerServiceFactory(name, factory, lifecycle, dependencies);
+  }
+  getServiceScoped(name, scopeId) {
+    return this.baseContext.getServiceScoped(name, scopeId);
+  }
 };
 function createPluginPermissionEnforcer(logger) {
   return new PluginPermissionEnforcer(logger);
@@ -4756,272 +4685,6 @@ var NamespaceResolver = class {
     return `${shortName}_${ns}`;
   }
 };
-
-// src/package-manager.ts
-var PackageManager = class {
-  constructor(logger, options = {}) {
-    this.packages = /* @__PURE__ */ new Map();
-    this.snapshots = /* @__PURE__ */ new Map();
-    this.logger = logger.child({ component: "PackageManager" });
-    this.dependencyResolver = new DependencyResolver(logger);
-    this.namespaceResolver = new NamespaceResolver(logger);
-    this.platformVersion = options.platformVersion || "3.0.0";
-  }
-  /**
-   * Install a package with full dependency resolution and namespace checking.
-   */
-  async install(packageId, version, manifest) {
-    this.logger.info("Installing package", { packageId, version });
-    if (this.packages.has(packageId)) {
-      const existing = this.packages.get(packageId);
-      if (existing.status === "installed") {
-        return {
-          success: false,
-          packageId,
-          version,
-          installedDependencies: [],
-          namespaceConflicts: [],
-          errorMessage: `Package ${packageId}@${existing.version} is already installed. Use upgrade instead.`
-        };
-      }
-    }
-    const engine = manifest.engine?.objectstack;
-    if (engine) {
-      const platformSemver = SemanticVersionManager.parse(this.platformVersion);
-      if (!SemanticVersionManager.satisfies(platformSemver, engine)) {
-        return {
-          success: false,
-          packageId,
-          version,
-          installedDependencies: [],
-          namespaceConflicts: [],
-          errorMessage: `Package requires platform ${engine}, but current platform is v${this.platformVersion}`
-        };
-      }
-    }
-    const namespaces = this.namespaceResolver.extractNamespaces(manifest);
-    const nsCheck = this.namespaceResolver.checkAvailability(packageId, namespaces);
-    if (!nsCheck.available) {
-      return {
-        success: false,
-        packageId,
-        version,
-        installedDependencies: [],
-        namespaceConflicts: nsCheck.conflicts.map((c) => ({
-          namespace: c.namespace,
-          existingPackageId: c.existingPackageId
-        })),
-        errorMessage: `Namespace conflicts detected: ${nsCheck.conflicts.map((c) => c.namespace).join(", ")}`
-      };
-    }
-    const deps = manifest.dependencies;
-    const depNames = deps ? Object.keys(deps) : [];
-    const missingDeps = depNames.filter((d) => !this.packages.has(d));
-    if (missingDeps.length > 0) {
-      return {
-        success: false,
-        packageId,
-        version,
-        installedDependencies: [],
-        namespaceConflicts: [],
-        errorMessage: `Missing dependencies: ${missingDeps.join(", ")}`
-      };
-    }
-    this.packages.set(packageId, {
-      packageId,
-      version,
-      manifest,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "installed",
-      namespaces,
-      dependencies: depNames
-    });
-    this.namespaceResolver.register(packageId, namespaces);
-    this.logger.info("Package installed", { packageId, version, namespaces: namespaces.length });
-    return {
-      success: true,
-      packageId,
-      version,
-      installedDependencies: depNames,
-      namespaceConflicts: []
-    };
-  }
-  /**
-   * Uninstall a package, checking for dependents first.
-   */
-  async uninstall(packageId) {
-    const pkg = this.packages.get(packageId);
-    if (!pkg) {
-      return { success: false, errorMessage: `Package ${packageId} is not installed` };
-    }
-    const dependents = [];
-    for (const [id, record] of this.packages) {
-      if (id !== packageId && record.dependencies.includes(packageId)) {
-        dependents.push(id);
-      }
-    }
-    if (dependents.length > 0) {
-      return {
-        success: false,
-        errorMessage: `Cannot uninstall ${packageId}: depended upon by ${dependents.join(", ")}`
-      };
-    }
-    this.namespaceResolver.unregister(packageId);
-    this.packages.delete(packageId);
-    this.snapshots.delete(packageId);
-    this.logger.info("Package uninstalled", { packageId });
-    return { success: true };
-  }
-  /**
-   * Upgrade a package: snapshot → update → register.
-   */
-  async upgrade(packageId, newVersion, newManifest) {
-    const existing = this.packages.get(packageId);
-    if (!existing) {
-      return {
-        success: false,
-        packageId,
-        fromVersion: "",
-        toVersion: newVersion,
-        snapshot: { packageId, previousVersion: "", previousManifest: {}, previousNamespaces: [], installedAt: "", createdAt: (/* @__PURE__ */ new Date()).toISOString() },
-        errorMessage: `Package ${packageId} is not installed`
-      };
-    }
-    const snapshot = {
-      packageId,
-      previousVersion: existing.version,
-      previousManifest: existing.manifest,
-      previousNamespaces: [...existing.namespaces],
-      installedAt: existing.installedAt,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    this.snapshots.set(packageId, snapshot);
-    const engine = newManifest.engine?.objectstack;
-    if (engine) {
-      const platformSemver = SemanticVersionManager.parse(this.platformVersion);
-      if (!SemanticVersionManager.satisfies(platformSemver, engine)) {
-        return {
-          success: false,
-          packageId,
-          fromVersion: existing.version,
-          toVersion: newVersion,
-          snapshot,
-          errorMessage: `New version requires platform ${engine}, current is v${this.platformVersion}`
-        };
-      }
-    }
-    const newNamespaces = this.namespaceResolver.extractNamespaces(newManifest);
-    this.namespaceResolver.unregister(packageId);
-    const nsCheck = this.namespaceResolver.checkAvailability(packageId, newNamespaces);
-    if (!nsCheck.available) {
-      this.namespaceResolver.register(packageId, existing.namespaces);
-      return {
-        success: false,
-        packageId,
-        fromVersion: existing.version,
-        toVersion: newVersion,
-        snapshot,
-        errorMessage: `Namespace conflicts in new version: ${nsCheck.conflicts.map((c) => c.namespace).join(", ")}`
-      };
-    }
-    this.namespaceResolver.register(packageId, newNamespaces);
-    const deps = newManifest.dependencies;
-    this.packages.set(packageId, {
-      packageId,
-      version: newVersion,
-      manifest: newManifest,
-      installedAt: existing.installedAt,
-      status: "installed",
-      namespaces: newNamespaces,
-      dependencies: deps ? Object.keys(deps) : []
-    });
-    this.logger.info("Package upgraded", { packageId, from: existing.version, to: newVersion });
-    return {
-      success: true,
-      packageId,
-      fromVersion: existing.version,
-      toVersion: newVersion,
-      snapshot
-    };
-  }
-  /**
-   * Rollback a package to its pre-upgrade snapshot.
-   */
-  async rollback(packageId) {
-    const snapshot = this.snapshots.get(packageId);
-    if (!snapshot) {
-      return {
-        success: false,
-        packageId,
-        restoredVersion: "",
-        errorMessage: `No upgrade snapshot found for ${packageId}`
-      };
-    }
-    this.namespaceResolver.unregister(packageId);
-    this.namespaceResolver.register(packageId, snapshot.previousNamespaces);
-    const deps = snapshot.previousManifest.dependencies;
-    this.packages.set(packageId, {
-      packageId,
-      version: snapshot.previousVersion,
-      manifest: snapshot.previousManifest,
-      installedAt: snapshot.installedAt,
-      status: "installed",
-      namespaces: snapshot.previousNamespaces,
-      dependencies: deps ? Object.keys(deps) : []
-    });
-    this.snapshots.delete(packageId);
-    this.logger.info("Package rolled back", { packageId, to: snapshot.previousVersion });
-    return {
-      success: true,
-      packageId,
-      restoredVersion: snapshot.previousVersion
-    };
-  }
-  /**
-   * Get an installed package record.
-   */
-  getPackage(packageId) {
-    return this.packages.get(packageId);
-  }
-  /**
-   * List all installed packages.
-   */
-  listPackages() {
-    return Array.from(this.packages.values());
-  }
-  /**
-   * Resolve dependencies for a set of packages.
-   */
-  resolveDependencies(packages) {
-    return this.dependencyResolver.resolve(packages);
-  }
-  /**
-   * Check namespace availability for a package's metadata.
-   */
-  checkNamespaces(packageId, config) {
-    const namespaces = this.namespaceResolver.extractNamespaces(config);
-    const result = this.namespaceResolver.checkAvailability(packageId, namespaces);
-    return {
-      available: result.available,
-      conflicts: result.conflicts.map((c) => ({
-        namespace: c.namespace,
-        existingPackageId: c.existingPackageId
-      }))
-    };
-  }
-  /**
-   * Get the namespace resolver instance.
-   */
-  getNamespaceResolver() {
-    return this.namespaceResolver;
-  }
-  /**
-   * Get a snapshot for a given package (if available).
-   */
-  getSnapshot(packageId) {
-    return this.snapshots.get(packageId);
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiRegistry,
@@ -5033,7 +4696,6 @@ var PackageManager = class {
   ObjectKernel,
   ObjectKernelBase,
   ObjectLogger,
-  PackageManager,
   PluginConfigValidator,
   PluginHealthMonitor,
   PluginLoader,