@zero-bits/kernel 1.0.0

package/dist/chunk-ETCJDJTI.cjs

@@ -0,0 +1,482 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/types.ts
+var PluginError = class extends Error {
+  constructor(pluginName, message) {
+    super(message);
+    this.name = "PluginError";
+    this.pluginName = pluginName;
+  }
+};
+var PluginNetworkError = class extends PluginError {
+  constructor(pluginName, url, cause) {
+    super(pluginName, `[Kernel] \u63D2\u4EF6 [${pluginName}] \u7F51\u7EDC\u52A0\u8F7D\u5931\u8D25\uFF0CURL: ${url}`);
+    this.name = "PluginNetworkError";
+    if (cause) this.cause = cause;
+  }
+};
+var PluginTimeoutError = class extends PluginError {
+  constructor(pluginName, timeout) {
+    super(pluginName, `[Kernel] \u63D2\u4EF6 [${pluginName}] \u52A0\u8F7D\u8D85\u65F6\uFF08>${timeout}ms\uFF09`);
+    this.name = "PluginTimeoutError";
+  }
+};
+var PluginDependencyError = class extends PluginError {
+  constructor(pluginName, dependency) {
+    super(pluginName, `[Kernel] \u63D2\u4EF6 [${pluginName}] \u7F3A\u5C11\u4F9D\u8D56: [${dependency}]\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u8C03\u7528 regSharedModule \u6CE8\u5165`);
+    this.name = "PluginDependencyError";
+    this.dependency = dependency;
+  }
+};
+var PluginExecutionError = class extends PluginError {
+  constructor(pluginName, cause) {
+    super(pluginName, `[Kernel] \u63D2\u4EF6 [${pluginName}] \u6267\u884C\u521D\u59CB\u5316\u5931\u8D25`);
+    this.name = "PluginExecutionError";
+    if (cause) this.cause = cause;
+  }
+};
+var KernelNotInitializedError = class extends Error {
+  constructor() {
+    super("[Kernel] \u5185\u6838\u5F15\u64CE\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 initKernel() \u6216 createKernel()");
+    this.name = "KernelNotInitializedError";
+  }
+};
+
+// src/core/core.ts
+function toPluginError(pluginName, err) {
+  if (err instanceof PluginError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  return new PluginError(pluginName, message);
+}
+function withTimeout(promise, ms, error) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(error), ms);
+  });
+  promise.catch(() => {
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var Kernel = class {
+  /**
+   * 构造函数
+   * @param options 内核配置
+   * @default timeout: 10000
+   * @default retryCount: 2
+   * @default nonce: ''
+   * @default debug: true
+   * @default namespace: ''
+   * @default logger: console
+   * @default onLoadStart: () => {}
+   * @default onLoadSuccess: () => {}
+   * @default onLoadError: () => {}
+   */
+  constructor(options) {
+    this.modules = /* @__PURE__ */ new Map();
+    this.ownHandlers = /* @__PURE__ */ new Map();
+    this.initialized = false;
+    if (!_optionalChain([options, 'optionalAccess', _2 => _2.namespace])) {
+      throw new Error("[SmartHub] \u5FC5\u987B\u914D\u7F6E namespace \u5168\u79F0 (\u4F8B\u5982: __SMART_HUB___DEFINE)");
+    }
+    this.logger = _optionalChain([options, 'optionalAccess', _3 => _3.logger]) || console;
+    this.config = {
+      timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.timeout]), () => ( 1e4)),
+      retryCount: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.retryCount]), () => ( 2)),
+      nonce: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.nonce]), () => ( "")),
+      debug: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.debug]), () => ( true)),
+      namespace: options.namespace,
+      logger: this.logger,
+      onLoadStart: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.onLoadStart]), () => ( (() => {
+      }))),
+      onLoadSuccess: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.onLoadSuccess]), () => ( (() => {
+      }))),
+      onLoadError: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _10 => _10.onLoadError]), () => ( (() => {
+      })))
+    };
+    this.initGlobalInterceptor();
+  }
+  /**
+   * 获取全局Pending Map
+   * @returns 全局Pending Map
+   */
+  get globalPendingMap() {
+    if (typeof window === "undefined") return void 0;
+    const defineFn = window[this.config.namespace];
+    return defineFn ? defineFn._pendingMap : void 0;
+  }
+  /**
+   * 获取全局资源并发锁
+   */
+  get globalLocks() {
+    if (typeof window === "undefined") return /* @__PURE__ */ new Map();
+    const nsLocks = `${this.config.namespace}_LOCKS`;
+    if (!window[nsLocks]) {
+      window[nsLocks] = /* @__PURE__ */ new Map();
+    }
+    return window[nsLocks];
+  }
+  /**
+   * 初始化全局拦截器
+   */
+  initGlobalInterceptor() {
+    if (typeof window === "undefined") return;
+    const ns = this.config.namespace;
+    if (!window[ns]) {
+      const defineFn = (pluginName, deps, factory) => {
+        const handlers = _optionalChain([defineFn, 'access', _11 => _11._pendingMap, 'optionalAccess', _12 => _12.get, 'call', _13 => _13(pluginName)]);
+        if (handlers && handlers.size > 0) {
+          handlers.forEach((handler) => handler(deps, factory));
+          handlers.clear();
+        } else {
+          console.warn(`[SmartHub] \u6536\u5230\u672A\u77E5\u7684\u63D2\u4EF6 [${pluginName}] define \u8C03\u7528`);
+        }
+      };
+      defineFn._pendingMap = /* @__PURE__ */ new Map();
+      window[ns] = defineFn;
+    }
+    this.initialized = true;
+  }
+  /**
+   * 判断内核是否已初始化
+   * @returns true 如果内核已初始化，否则 false
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * 注册共享模块
+   * @param name 模块名称
+   * @param instance 模块实例
+   * @param options 模块配置
+   * @default force: false
+   */
+  regSharedModule(name, instance, options) {
+    if (this.modules.has(name) && !_optionalChain([options, 'optionalAccess', _14 => _14.force])) {
+      if (this.config.debug) {
+        this.logger.warn(`[SmartHub] \u5171\u4EAB\u6A21\u5757 [${name}] \u5DF2\u6CE8\u518C\uFF0C\u5982\u9700\u8986\u76D6\u8BF7\u4F20\u5165 { force: true }`);
+      }
+      return;
+    }
+    this.modules.set(name, {
+      module: instance,
+      _promise: Promise.resolve(instance),
+      status: "resolved"
+    });
+  }
+  /**
+   * 注入脚本（带自毁机制与并发锁）
+   * @param url 脚本地址
+   * @param pluginName 插件名称
+   * @returns Promise对象
+   */
+  injectScript(url, pluginName) {
+    const locks = this.globalLocks;
+    if (locks.has(url)) return locks.get(url);
+    const promise = new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = url;
+      script.async = true;
+      if (this.config.nonce) script.nonce = this.config.nonce;
+      const cleanup = () => {
+        script.onload = null;
+        script.onerror = null;
+        locks.delete(url);
+        if (script.parentNode) script.parentNode.removeChild(script);
+      };
+      script.onload = () => {
+        cleanup();
+        resolve();
+      };
+      script.onerror = (event) => {
+        cleanup();
+        reject(new PluginNetworkError(pluginName, url, event));
+      };
+      document.head.appendChild(script);
+    });
+    locks.set(url, promise);
+    return promise;
+  }
+  /**
+   * 注入样式（带并发锁，防止 FOUC）
+   * @param url 样式地址
+   * @param pluginName 插件名称
+   * @returns Promise对象
+   */
+  injectStyle(url, pluginName) {
+    const locks = this.globalLocks;
+    if (locks.has(url)) return locks.get(url);
+    const existing = document.querySelector(`link[href="${url}"][rel="stylesheet"]`);
+    if (existing) return Promise.resolve();
+    const promise = new Promise((resolve, reject) => {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = url;
+      if (this.config.nonce) link.nonce = this.config.nonce;
+      const cleanup = () => {
+        link.onload = null;
+        link.onerror = null;
+        locks.delete(url);
+      };
+      link.onload = () => {
+        cleanup();
+        resolve();
+      };
+      link.onerror = (event) => {
+        cleanup();
+        if (link.parentNode) link.parentNode.removeChild(link);
+        reject(new PluginNetworkError(pluginName, url, event));
+      };
+      document.head.appendChild(link);
+    });
+    locks.set(url, promise);
+    return promise;
+  }
+  /**
+   * 带重试的函数执行器
+   * @param fn 需要执行的函数
+   * @param pluginName 插件名称
+   * @returns Promise对象
+   */
+  async withRetry(fn, pluginName) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.retryCount; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (attempt < this.config.retryCount) {
+          await new Promise((r) => setTimeout(r, 100 * Math.pow(2, attempt)));
+          if (this.config.debug) {
+            this.logger.warn(`[SmartHub] \u63D2\u4EF6 [${pluginName}] \u7B2C ${attempt + 1} \u6B21\u91CD\u8BD5\u52A0\u8F7D...`);
+          }
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * 解析工厂函数（支持异步依赖树）
+   * @param pluginName 插件名称
+   * @param deps 依赖项
+   * @param factory 工厂函数
+   * @returns Promise对象
+   */
+  async resolveFactory(pluginName, deps, factory) {
+    let resolvedDeps;
+    try {
+      resolvedDeps = await Promise.all(deps.map((dep) => {
+        const entry = this.modules.get(dep);
+        if (!entry) throw new PluginDependencyError(pluginName, dep);
+        return entry._promise;
+      }));
+    } catch (err) {
+      throw err;
+    }
+    try {
+      return factory(...resolvedDeps);
+    } catch (err) {
+      throw new PluginExecutionError(pluginName, err);
+    }
+  }
+  /**
+   * 注册待处理函数
+   * @param pluginName 插件名称
+   * @returns Promise对象
+   */
+  registerPendingHandler(pluginName) {
+    const handler = (deps, factory) => {
+      const entry = this.modules.get(pluginName);
+      if (entry) entry._defineCalled = true;
+      this.resolveFactory(pluginName, deps, factory).then((mod) => {
+        const entry2 = this.modules.get(pluginName);
+        if (entry2) {
+          entry2.module = mod;
+          entry2.status = "resolved";
+          _optionalChain([entry2, 'access', _15 => _15._resolve, 'optionalCall', _16 => _16(mod)]);
+        }
+      }).catch((err) => {
+        const entry2 = this.modules.get(pluginName);
+        if (entry2) {
+          entry2.status = "rejected";
+          _optionalChain([entry2, 'access', _17 => _17._reject, 'optionalCall', _18 => _18(err)]);
+        }
+      });
+      this.ownHandlers.delete(pluginName);
+    };
+    const ns = this.config.namespace;
+    const defineFn = window[ns];
+    if (!defineFn) throw new Error(`[SmartHub] \u5168\u5C40\u62E6\u622A\u5668 ${ns} \u672A\u521D\u59CB\u5316`);
+    if (!defineFn._pendingMap) {
+      defineFn._pendingMap = /* @__PURE__ */ new Map();
+    }
+    const globalMap = defineFn._pendingMap;
+    if (!globalMap.has(pluginName)) {
+      globalMap.set(pluginName, /* @__PURE__ */ new Set());
+    }
+    globalMap.get(pluginName).add(handler);
+    this.ownHandlers.set(pluginName, handler);
+    return handler;
+  }
+  /**
+   * 加载插件
+   * @param pluginName 插件名称
+   * @param options 插件配置
+   * @returns Promise对象
+   */
+  async loadPlugin(pluginName, options) {
+    if (!this.initialized) throw new KernelNotInitializedError();
+    const url = typeof options === "string" ? options : options.url;
+    const styleUrls = typeof options === "string" ? [] : options.styleUrls || [];
+    const cached = this.modules.get(pluginName);
+    if (cached && (cached.status === "resolved" || cached.status === "pending") && cached.url === url) {
+      return cached._promise;
+    }
+    if (cached && cached.url !== url) this.unloadPlugin(pluginName);
+    this.config.onLoadStart(pluginName);
+    const deferred = createDeferred();
+    this.modules.set(pluginName, {
+      module: null,
+      _promise: deferred.promise,
+      _resolve: deferred.resolve,
+      _reject: deferred.reject,
+      status: "pending",
+      _defineCalled: false,
+      url
+    });
+    let handler;
+    try {
+      handler = this.registerPendingHandler(pluginName);
+      await this.withRetry(
+        () => withTimeout(
+          Promise.all([
+            this.injectScript(url, pluginName),
+            ...styleUrls.map((styleUrl) => this.injectStyle(styleUrl, pluginName))
+          ]),
+          this.config.timeout,
+          new PluginTimeoutError(pluginName, this.config.timeout)
+        ),
+        pluginName
+      );
+      const entry = this.modules.get(pluginName);
+      if (!entry._defineCalled) {
+        throw new PluginExecutionError(pluginName, `Plugin script loaded but ${this.config.namespace} was not called.`);
+      }
+      const mod = await withTimeout(
+        entry._promise,
+        this.config.timeout,
+        new PluginTimeoutError(pluginName, this.config.timeout)
+      );
+      this.config.onLoadSuccess(pluginName);
+      return mod;
+    } catch (err) {
+      _optionalChain([this, 'access', _19 => _19.globalPendingMap, 'optionalAccess', _20 => _20.get, 'call', _21 => _21(pluginName), 'optionalAccess', _22 => _22.delete, 'call', _23 => _23(handler)]);
+      this.ownHandlers.delete(pluginName);
+      const entry = this.modules.get(pluginName);
+      if (entry) {
+        entry.status = "rejected";
+        _optionalChain([entry, 'access', _24 => _24._reject, 'optionalCall', _25 => _25(err)]);
+      }
+      const pluginErr = toPluginError(pluginName, err);
+      this.config.onLoadError(pluginName, pluginErr);
+      throw pluginErr;
+    }
+  }
+  /**
+   * 卸载插件
+   * @param pluginName 插件名称
+   */
+  unloadPlugin(pluginName) {
+    this.modules.delete(pluginName);
+    const handler = this.ownHandlers.get(pluginName);
+    if (handler) {
+      _optionalChain([this, 'access', _26 => _26.globalPendingMap, 'optionalAccess', _27 => _27.get, 'call', _28 => _28(pluginName), 'optionalAccess', _29 => _29.delete, 'call', _30 => _30(handler)]);
+      this.ownHandlers.delete(pluginName);
+    }
+  }
+  /**
+   * 预加载远端插件资源到浏览器缓存（不执行）
+   * @param options 插件地址或配置
+   */
+  preloadPlugin(options) {
+    if (typeof document === "undefined") return;
+    const url = typeof options === "string" ? options : options.url;
+    const styleUrls = typeof options === "string" ? [] : options.styleUrls || [];
+    const preloadResource = (href, as) => {
+      if (document.querySelector(`link[href="${href}"][rel="preload"]`)) return;
+      const link = document.createElement("link");
+      link.rel = "preload";
+      link.href = href;
+      link.as = as;
+      if (this.config.nonce) link.nonce = this.config.nonce;
+      document.head.appendChild(link);
+    };
+    if (url) preloadResource(url, "script");
+    styleUrls.forEach((styleUrl) => preloadResource(styleUrl, "style"));
+  }
+  /**
+   * 销毁内核实例
+   */
+  destroy() {
+    this.ownHandlers.forEach((handler, pluginName) => {
+      _optionalChain([this, 'access', _31 => _31.globalPendingMap, 'optionalAccess', _32 => _32.get, 'call', _33 => _33(pluginName), 'optionalAccess', _34 => _34.delete, 'call', _35 => _35(handler)]);
+    });
+    this.ownHandlers.clear();
+    this.modules.clear();
+    this.initialized = false;
+  }
+};
+function createKernel(options) {
+  return new Kernel(options);
+}
+
+// src/core/index.ts
+var globalKernel = null;
+function initKernel(options) {
+  if (globalKernel) return console.warn("[SmartHub] initKernel() \u5DF2\u6267\u884C\u8FC7\uFF0C\u8BF7\u52FF\u91CD\u590D\u8C03\u7528");
+  globalKernel = createKernel(options);
+}
+function regSharedModule(name, instance, options) {
+  if (!globalKernel) {
+    console.warn(`[SmartHub] \u5168\u5C40\u5185\u6838\u672A\u521D\u59CB\u5316\uFF0C\u81EA\u52A8\u4EE5\u9ED8\u8BA4\u914D\u7F6E\u521D\u59CB\u5316...`);
+    globalKernel = createKernel();
+  }
+  globalKernel.regSharedModule(name, instance, options);
+}
+async function loadRemotePlugin(pluginName, options) {
+  if (!globalKernel) {
+    throw new Error("[SmartHub] \u5185\u6838\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u8C03\u7528 initKernel()");
+  }
+  return globalKernel.loadPlugin(pluginName, options);
+}
+function preloadRemotePlugin(options) {
+  if (!globalKernel) {
+    console.warn("[SmartHub] \u5168\u5C40\u5185\u6838\u672A\u521D\u59CB\u5316\uFF0C\u81EA\u52A8\u4EE5\u9ED8\u8BA4\u914D\u7F6E\u521D\u59CB\u5316...");
+    globalKernel = createKernel();
+  }
+  globalKernel.preloadPlugin(options);
+}
+function getGlobalKernel() {
+  return globalKernel;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.PluginError = PluginError; exports.PluginNetworkError = PluginNetworkError; exports.PluginTimeoutError = PluginTimeoutError; exports.PluginDependencyError = PluginDependencyError; exports.PluginExecutionError = PluginExecutionError; exports.KernelNotInitializedError = KernelNotInitializedError; exports.createKernel = createKernel; exports.initKernel = initKernel; exports.regSharedModule = regSharedModule; exports.loadRemotePlugin = loadRemotePlugin; exports.preloadRemotePlugin = preloadRemotePlugin; exports.getGlobalKernel = getGlobalKernel;

package/dist/core/index.cjs

@@ -0,0 +1,28 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkETCJDJTIcjs = require('../chunk-ETCJDJTI.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.KernelNotInitializedError = _chunkETCJDJTIcjs.KernelNotInitializedError; exports.PluginDependencyError = _chunkETCJDJTIcjs.PluginDependencyError; exports.PluginError = _chunkETCJDJTIcjs.PluginError; exports.PluginExecutionError = _chunkETCJDJTIcjs.PluginExecutionError; exports.PluginNetworkError = _chunkETCJDJTIcjs.PluginNetworkError; exports.PluginTimeoutError = _chunkETCJDJTIcjs.PluginTimeoutError; exports.createKernel = _chunkETCJDJTIcjs.createKernel; exports.getGlobalKernel = _chunkETCJDJTIcjs.getGlobalKernel; exports.initKernel = _chunkETCJDJTIcjs.initKernel; exports.loadRemotePlugin = _chunkETCJDJTIcjs.loadRemotePlugin; exports.preloadRemotePlugin = _chunkETCJDJTIcjs.preloadRemotePlugin; exports.regSharedModule = _chunkETCJDJTIcjs.regSharedModule;

package/dist/core/index.d.cts

@@ -0,0 +1,58 @@
+import { K as KernelOptions, a as KernelInstance, P as PluginLoadOptions } from '../types-JlxTjSfC.cjs';
+export { b as KernelLogger, c as KernelNotInitializedError, M as ModuleEntry, d as PluginDependencyError, e as PluginError, f as PluginExecutionError, g as PluginNetworkError, h as PluginTimeoutError } from '../types-JlxTjSfC.cjs';
+
+/**
+ * 创建内核实例
+ * @param options 内核配置
+ * @returns 内核实例
+ */
+declare function createKernel(options?: KernelOptions): KernelInstance;
+
+/**
+ * 初始化全局内核引擎
+ * @param options 内核配置项
+ * - timeout: 网络请求超时时间（毫秒），默认 10000
+ * - retryCount: 网络请求重试次数，默认 2
+ * - namespace: 插件命名空间，默认 '__KERNEL__'
+ * - debug: 是否开启调试模式，默认 true
+ * - logger: 自定义日志处理器
+ * - onLoadStart: 插件加载开始时的钩子
+ * - onLoadSuccess: 插件加载成功后的钩子
+ * - onLoadError: 插件加载失败后的全局错误钩子
+ */
+declare function initKernel(options?: KernelOptions): void;
+/**
+ * 注册共享模块到全局内核
+ * @param name 模块名
+ * @param instance 模块实例
+ * @param options 选项
+ * - force: 是否强制覆盖已存在的同名模块，默认为 false
+ */
+declare function regSharedModule(name: string, instance: any, options?: {
+    force?: boolean;
+}): void;
+/**
+ * 通过全局内核加载远端插件
+ * @param pluginName 插件名
+ * @param options 插件加载选项
+ * - url: 插件脚本地址
+ * - styleUrls: 插件样式地址列表
+ * - type: 插件模块类型，'umd' 使用全局 define，'esm' 使用原生 import，默认 'umd'
+ * @returns 插件实例
+ */
+declare function loadRemotePlugin<T = any>(pluginName: string, options: PluginLoadOptions): Promise<T>;
+/**
+ * 预加载远端插件（通过 <link rel="preload"> 加载到浏览器缓存，但不执行）
+ * @param options 插件加载选项
+ * - url: 插件脚本地址
+ * - styleUrls: 插件样式地址列表
+ * - type: 插件模块类型，'umd' 使用全局 define，'esm' 使用原生 import，默认 'umd'
+ */
+declare function preloadRemotePlugin(options: PluginLoadOptions): void;
+/**
+ * 获取全局内核实例（需已调用 initKernel()）
+ * 可用于直接调用 unloadPlugin() / destroy() 等方法
+ */
+declare function getGlobalKernel(): KernelInstance | null;
+
+export { KernelInstance, KernelOptions, PluginLoadOptions, createKernel, getGlobalKernel, initKernel, loadRemotePlugin, preloadRemotePlugin, regSharedModule };

package/dist/core/index.d.ts

@@ -0,0 +1,58 @@
+import { K as KernelOptions, a as KernelInstance, P as PluginLoadOptions } from '../types-JlxTjSfC.js';
+export { b as KernelLogger, c as KernelNotInitializedError, M as ModuleEntry, d as PluginDependencyError, e as PluginError, f as PluginExecutionError, g as PluginNetworkError, h as PluginTimeoutError } from '../types-JlxTjSfC.js';
+
+/**
+ * 创建内核实例
+ * @param options 内核配置
+ * @returns 内核实例
+ */
+declare function createKernel(options?: KernelOptions): KernelInstance;
+
+/**
+ * 初始化全局内核引擎
+ * @param options 内核配置项
+ * - timeout: 网络请求超时时间（毫秒），默认 10000
+ * - retryCount: 网络请求重试次数，默认 2
+ * - namespace: 插件命名空间，默认 '__KERNEL__'
+ * - debug: 是否开启调试模式，默认 true
+ * - logger: 自定义日志处理器
+ * - onLoadStart: 插件加载开始时的钩子
+ * - onLoadSuccess: 插件加载成功后的钩子
+ * - onLoadError: 插件加载失败后的全局错误钩子
+ */
+declare function initKernel(options?: KernelOptions): void;
+/**
+ * 注册共享模块到全局内核
+ * @param name 模块名
+ * @param instance 模块实例
+ * @param options 选项
+ * - force: 是否强制覆盖已存在的同名模块，默认为 false
+ */
+declare function regSharedModule(name: string, instance: any, options?: {
+    force?: boolean;
+}): void;
+/**
+ * 通过全局内核加载远端插件
+ * @param pluginName 插件名
+ * @param options 插件加载选项
+ * - url: 插件脚本地址
+ * - styleUrls: 插件样式地址列表
+ * - type: 插件模块类型，'umd' 使用全局 define，'esm' 使用原生 import，默认 'umd'
+ * @returns 插件实例
+ */
+declare function loadRemotePlugin<T = any>(pluginName: string, options: PluginLoadOptions): Promise<T>;
+/**
+ * 预加载远端插件（通过 <link rel="preload"> 加载到浏览器缓存，但不执行）
+ * @param options 插件加载选项
+ * - url: 插件脚本地址
+ * - styleUrls: 插件样式地址列表
+ * - type: 插件模块类型，'umd' 使用全局 define，'esm' 使用原生 import，默认 'umd'
+ */
+declare function preloadRemotePlugin(options: PluginLoadOptions): void;
+/**
+ * 获取全局内核实例（需已调用 initKernel()）
+ * 可用于直接调用 unloadPlugin() / destroy() 等方法
+ */
+declare function getGlobalKernel(): KernelInstance | null;
+
+export { KernelInstance, KernelOptions, PluginLoadOptions, createKernel, getGlobalKernel, initKernel, loadRemotePlugin, preloadRemotePlugin, regSharedModule };

package/dist/core/index.js

@@ -0,0 +1,28 @@
+import {
+  KernelNotInitializedError,
+  PluginDependencyError,
+  PluginError,
+  PluginExecutionError,
+  PluginNetworkError,
+  PluginTimeoutError,
+  createKernel,
+  getGlobalKernel,
+  initKernel,
+  loadRemotePlugin,
+  preloadRemotePlugin,
+  regSharedModule
+} from "../chunk-D4E5XKWD.js";
+export {
+  KernelNotInitializedError,
+  PluginDependencyError,
+  PluginError,
+  PluginExecutionError,
+  PluginNetworkError,
+  PluginTimeoutError,
+  createKernel,
+  getGlobalKernel,
+  initKernel,
+  loadRemotePlugin,
+  preloadRemotePlugin,
+  regSharedModule
+};