@zucker-framework/network 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,351 @@
+import { OnModuleDestroy, Provider, DynamicModule } from '@nestjs/common';
+
+/**
+ * 网络组件类型标识。
+ *
+ * 对应 jetlinks NetworkType — 用于区分 TCP / HTTP / MQTT / WebSocket 等
+ * 不同网络组件，以字符串 id 作为唯一键。
+ *
+ * 与 jetlinks 的差异：去掉了 Java 枚举字典依赖，改用纯接口 + 工厂函数。
+ */
+interface NetworkType {
+    /** 类型唯一标识，如 'TCP_SERVER'、'HTTP_CLIENT' */
+    readonly id: string;
+    /** 可读名称（可选，默认等于 id） */
+    readonly name: string;
+}
+/**
+ * 用 id 创建一个 NetworkType（等价 jetlinks `NetworkType.of(id)`）。
+ */
+declare function networkType(id: string, name?: string): NetworkType;
+/**
+ * 内置网络类型常量，对应 jetlinks DefaultNetworkType 的通用子集。
+ * IoT 专用类型（CoAP 等）不迁移。
+ */
+declare const NetworkTypes: {
+    readonly TCP_CLIENT: NetworkType;
+    readonly TCP_SERVER: NetworkType;
+    readonly HTTP_CLIENT: NetworkType;
+    readonly HTTP_SERVER: NetworkType;
+    readonly MQTT_CLIENT: NetworkType;
+    readonly MQTT_SERVER: NetworkType;
+    readonly WEB_SOCKET_CLIENT: NetworkType;
+    readonly WEB_SOCKET_SERVER: NetworkType;
+    readonly UDP: NetworkType;
+};
+/**
+ * 动态类型注册表 — 对齐 jetlinks NetworkTypes 的 register/lookup 模式。
+ *
+ * 允许运行时注册自定义网络类型（如 CoAP、自定义协议等），
+ * 与 jetlinks 中 NetworkTypes.register() 语义一致。
+ */
+declare class NetworkTypeRegistry {
+    private readonly types;
+    constructor();
+    /** 注册网络类型 — 对齐 jetlinks NetworkTypes.register() */
+    register(type: NetworkType): void;
+    /** 批量注册 */
+    registerAll(types: NetworkType[]): void;
+    /** 根据 ID 查找网络类型 — 对齐 jetlinks NetworkTypes.lookup() */
+    lookup(id: string): NetworkType | undefined;
+    /** 获取所有已注册的网络类型 — 对齐 jetlinks NetworkTypes.get() */
+    getAll(): NetworkType[];
+}
+/** 全局网络类型注册表单例 */
+declare const networkTypeRegistry: NetworkTypeRegistry;
+
+/**
+ * 传输协议抽象。
+ *
+ * 对应 jetlinks NetworkTransport（TCP / UDP）以及 NetworkConfig.schema
+ * （http / mqtt / ws 等应用层协议）。
+ *
+ * 在 zucker 中将两层合并为一个 Transport 枚举 + schema 字段，
+ * 使消费方只需关心一个类型。
+ */
+/** 底层传输协议 */
+type TransportProtocol = 'TCP' | 'UDP';
+/**
+ * 传输描述 — 包含底层协议 + 应用层 schema。
+ *
+ * 例如 MQTT over TCP: `{ protocol: 'TCP', schema: 'mqtt' }`
+ */
+interface Transport {
+    /** 底层协议：TCP 或 UDP */
+    readonly protocol: TransportProtocol;
+    /** 应用层 schema，如 http / mqtt / ws */
+    readonly schema: string;
+}
+declare function createTransport(protocol: TransportProtocol, schema: string): Transport;
+/** 常见传输常量 */
+declare const Transports: {
+    readonly TCP: Transport;
+    readonly UDP: Transport;
+    readonly HTTP: Transport;
+    readonly HTTPS: Transport;
+    readonly MQTT: Transport;
+    readonly MQTTS: Transport;
+    readonly WS: Transport;
+    readonly WSS: Transport;
+};
+
+/**
+ * 网络组件根接口。
+ *
+ * 对应 jetlinks `Network` — 所有具体网络实现（TCP Server、MQTT Client 等）
+ * 的统一抽象。提供生命周期管理（shutdown / isAlive / isAutoReload）。
+ */
+interface Network {
+    /** 网络组件实例唯一标识 */
+    readonly id: string;
+    /** 网络类型 */
+    readonly type: NetworkType;
+    /** 关闭网络组件，释放底层资源 */
+    shutdown(): Promise<void> | void;
+    /** 组件是否存活 */
+    isAlive(): boolean;
+    /**
+     * 当 isAlive() 返回 false 时，是否由 NetworkManager 自动重新加载。
+     * 默认 false。
+     */
+    isAutoReload(): boolean;
+}
+/**
+ * 服务端网络组件，额外暴露绑定地址。
+ *
+ * 对应 jetlinks `ServerNetwork`。
+ */
+interface ServerNetwork extends Network {
+    /** 绑定的 host:port；如未绑定返回 undefined */
+    getBindAddress(): {
+        host: string;
+        port: number;
+    } | undefined;
+}
+
+/**
+ * 网络组件配置基础接口。
+ *
+ * 对应 jetlinks `NetworkConfig` — 抽象出所有网络组件共有的配置属性。
+ */
+interface NetworkConfig {
+    /** 配置唯一标识 */
+    readonly id: string;
+    /** 传输协议 */
+    readonly transport: Transport;
+    /** 是否启用 TLS/DTLS 安全加密 */
+    readonly secure: boolean;
+    /** 安全证书标识（secure 为 true 时必须） */
+    readonly certId?: string;
+}
+/**
+ * 服务端网络配置。
+ *
+ * 对应 jetlinks `ServerNetworkConfig`。
+ */
+interface ServerNetworkConfig extends NetworkConfig {
+    /** 监听地址 */
+    readonly host: string;
+    /** 监听端口 */
+    readonly port: number;
+}
+/**
+ * 客户端网络配置。
+ *
+ * 对应 jetlinks `ClientNetworkConfig`。
+ */
+interface ClientNetworkConfig extends NetworkConfig {
+    /** 远端地址 */
+    readonly remoteHost: string;
+    /** 远端端口 */
+    readonly remotePort: number;
+}
+/**
+ * 通用可序列化的网络属性，对应 jetlinks `NetworkProperties`。
+ *
+ * 与 jetlinks 完全对齐：type + configurations map 的组合
+ * 让 NetworkProvider 可以按需反序列化成具体 Config。
+ */
+interface NetworkProperties {
+    /** 配置 ID */
+    id: string;
+    /** 网络类型标识 */
+    type: string;
+    /** 配置名称 */
+    name: string;
+    /** 是否启用 */
+    enabled: boolean;
+    /** 自由 KV 配置 — 不同网络类型内容不同 */
+    configurations: Record<string, unknown>;
+}
+
+/**
+ * 网络组件提供商 SPI。
+ *
+ * 对应 jetlinks `NetworkProvider<P>` — 每种网络类型注册一个 Provider，
+ * 负责根据配置创建/重载网络实例。
+ *
+ * 泛型 P 为具体的配置类型（如 TcpServerConfig、MqttClientConfig）。
+ *
+ * 与 jetlinks 的差异：
+ * - 去掉 Reactor Mono，使用 async/Promise
+ * - 去掉 ConfigMetadata（Java UI 元数据，在 TS 中用 JSON Schema 替代）
+ */
+interface NetworkProvider<P = unknown> {
+    /** 该 Provider 支持的网络类型 */
+    readonly type: NetworkType;
+    /** 根据具体配置创建网络组件 */
+    createNetwork(config: P): Promise<Network>;
+    /** 重载已有网络组件（热更新配置） */
+    reload(network: Network, config: P): Promise<Network>;
+    /**
+     * 将通用 NetworkProperties 转换为具体配置对象 P。
+     * 对应 jetlinks `NetworkProvider.createConfig(NetworkProperties)`。
+     */
+    createConfig(properties: NetworkProperties): Promise<P>;
+    /**
+     * 网络组件是否可被多个消费者复用。
+     *
+     * 例如 TCP Server 通常不可复用（一个端口只能被一个网关占用），
+     * 而 HTTP Client 可复用。
+     * 默认 false。
+     */
+    isReusable(): boolean;
+}
+
+/**
+ * 网络组件配置管理接口 — 用于从持久层获取 NetworkProperties。
+ *
+ * 对应 jetlinks `NetworkConfigManager`。
+ * 具体实现由应用层提供（数据库、文件等）。
+ */
+interface NetworkConfigManager {
+    getConfig(type: NetworkType, id: string): Promise<NetworkProperties | undefined>;
+}
+/**
+ * 网络管理器接口。
+ *
+ * 对应 jetlinks `NetworkManager` — 统一管理多种类型的网络组件实例，
+ * 提供按类型+ID 获取、重载、关闭、销毁等操作。
+ */
+interface INetworkManager {
+    /** 按类型和 ID 获取网络组件（懒创建） */
+    getNetwork<T extends Network = Network>(type: NetworkType, id: string): Promise<T>;
+    /** 获取所有已创建的网络组件 */
+    getNetworks(): Network[];
+    /** 获取所有已注册的 Provider */
+    getProviders(): NetworkProvider[];
+    /** 按类型 ID 获取 Provider */
+    getProvider(typeId: string): NetworkProvider | undefined;
+    /** 重载指定网络组件 */
+    reload(type: NetworkType, id: string): Promise<void>;
+    /** 关闭指定网络组件（不移除缓存） */
+    shutdown(type: NetworkType, id: string): Promise<void>;
+    /** 销毁指定网络组件（关闭并移除缓存） */
+    destroy(type: NetworkType, id: string): Promise<void>;
+}
+/**
+ * 默认网络管理器实现。
+ *
+ * 对应 jetlinks `DefaultNetworkManager` — 通过 Provider SPI 按需创建
+ * 网络组件实例，内部按 type + id 缓存。
+ *
+ * 与 jetlinks 的差异：
+ * - 去掉了 Spring BeanPostProcessor 自动发现，改为手动 registerProvider
+ * - 去掉了 EventBus 集群同步（zucker 已有 @zucker-framework/cluster）
+ * - 健康检查用 setInterval 而非 Flux.interval
+ */
+declare class DefaultNetworkManager implements INetworkManager, OnModuleDestroy {
+    private readonly configManager;
+    private readonly logger;
+    /** type-id -> Provider */
+    private readonly providers;
+    /** type-id -> (network-id -> Network) */
+    private readonly store;
+    private checkTimer;
+    constructor(configManager: NetworkConfigManager);
+    registerProvider(provider: NetworkProvider<unknown>): void;
+    getNetwork<T extends Network = Network>(type: NetworkType, id: string): Promise<T>;
+    getNetworks(): Network[];
+    getProviders(): NetworkProvider[];
+    getProvider(typeId: string): NetworkProvider | undefined;
+    reload(type: NetworkType, id: string): Promise<void>;
+    shutdown(type: NetworkType, id: string): Promise<void>;
+    destroy(type: NetworkType, id: string): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    private getNetworkStore;
+    private requireProvider;
+    private createFromConfig;
+    /**
+     * 定期检查网络组件存活状态 — 与 jetlinks checkNetwork() 逻辑对齐。
+     */
+    private checkNetworks;
+}
+
+/**
+ * 消息编解码器抽象。
+ *
+ * 对应 jetlinks `DeviceMessageCodec` 的通用子集 — 去掉了 IoT 设备
+ * 消息特定部分，保留通用的 encode / decode / transport 关联。
+ *
+ * 在 zucker 中，Codec 用于任意协议的消息序列化/反序列化，
+ * 例如 MQTT payload 解析、TCP 帧编解码等。
+ */
+
+/**
+ * 编解码上下文 — 携带编解码时可能需要的环境信息。
+ */
+interface CodecContext {
+    /** 当前网络组件 ID */
+    readonly networkId?: string;
+    /** 额外上下文 KV */
+    readonly attributes: Record<string, unknown>;
+}
+/**
+ * 消息编解码器。
+ *
+ * 泛型参数：
+ * - TEncoded  : 编码后的格式（如 Buffer、string）
+ * - TDecoded  : 解码后的业务对象
+ */
+interface Codec<TEncoded = Buffer, TDecoded = unknown> {
+    /** 编解码器标识 */
+    readonly id: string;
+    /** 该编解码器绑定的传输协议 */
+    readonly transport: Transport;
+    /** 将业务对象编码为传输格式 */
+    encode(message: TDecoded, context?: CodecContext): Promise<TEncoded> | TEncoded;
+    /** 将传输格式解码为业务对象 */
+    decode(payload: TEncoded, context?: CodecContext): Promise<TDecoded> | TDecoded;
+}
+/**
+ * JSON 编解码器 — 最常见的实现，将对象序列化为 JSON Buffer。
+ */
+declare class JsonCodec<T = unknown> implements Codec<Buffer, T> {
+    readonly id: string;
+    readonly transport: Transport;
+    constructor(id: string, transport: Transport);
+    encode(message: T): Buffer;
+    decode(payload: Buffer): T;
+}
+
+declare const NETWORK_MANAGER: unique symbol;
+declare const NETWORK_CONFIG_MANAGER: unique symbol;
+/**
+ * Zucker 网络模块。
+ *
+ * 使用 `forRoot` 注册时，需提供 `NetworkConfigManager` 实现。
+ *
+ * ```ts
+ * ZuckerNetworkModule.forRoot({
+ *   configManager: MyNetworkConfigManager,
+ * })
+ * ```
+ */
+declare class ZuckerNetworkModule {
+    static forRoot(options: {
+        configManager: Provider;
+    }): DynamicModule;
+}
+
+export { type ClientNetworkConfig, type Codec, type CodecContext, DefaultNetworkManager, type INetworkManager, JsonCodec, NETWORK_CONFIG_MANAGER, NETWORK_MANAGER, type Network, type NetworkConfig, type NetworkConfigManager, type NetworkProperties, type NetworkProvider, type NetworkType, NetworkTypes, type ServerNetwork, type ServerNetworkConfig, type Transport, type TransportProtocol, Transports, ZuckerNetworkModule, createTransport, networkType, networkTypeRegistry };

package/dist/index.js

@@ -0,0 +1,361 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DefaultNetworkManager: () => DefaultNetworkManager,
+  JsonCodec: () => JsonCodec,
+  NETWORK_CONFIG_MANAGER: () => NETWORK_CONFIG_MANAGER,
+  NETWORK_MANAGER: () => NETWORK_MANAGER,
+  NetworkTypes: () => NetworkTypes,
+  Transports: () => Transports,
+  ZuckerNetworkModule: () => ZuckerNetworkModule,
+  createTransport: () => createTransport,
+  networkType: () => networkType,
+  networkTypeRegistry: () => networkTypeRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/network-type.ts
+function networkType(id, name) {
+  return {
+    id,
+    name: name ?? id
+  };
+}
+__name(networkType, "networkType");
+var NetworkTypes = {
+  TCP_CLIENT: networkType("TCP_CLIENT", "TCP Client"),
+  TCP_SERVER: networkType("TCP_SERVER", "TCP Server"),
+  HTTP_CLIENT: networkType("HTTP_CLIENT", "HTTP Client"),
+  HTTP_SERVER: networkType("HTTP_SERVER", "HTTP Server"),
+  MQTT_CLIENT: networkType("MQTT_CLIENT", "MQTT Client"),
+  MQTT_SERVER: networkType("MQTT_SERVER", "MQTT Server"),
+  WEB_SOCKET_CLIENT: networkType("WEB_SOCKET_CLIENT", "WebSocket Client"),
+  WEB_SOCKET_SERVER: networkType("WEB_SOCKET_SERVER", "WebSocket Server"),
+  UDP: networkType("UDP", "UDP")
+};
+var NetworkTypeRegistry = class NetworkTypeRegistry2 {
+  static {
+    __name(this, "NetworkTypeRegistry");
+  }
+  types = /* @__PURE__ */ new Map();
+  constructor() {
+    for (const t of Object.values(NetworkTypes)) {
+      this.types.set(t.id.toUpperCase(), t);
+    }
+  }
+  /** 注册网络类型 — 对齐 jetlinks NetworkTypes.register() */
+  register(type) {
+    this.types.set(type.id.toUpperCase(), type);
+  }
+  /** 批量注册 */
+  registerAll(types) {
+    for (const t of types) {
+      this.register(t);
+    }
+  }
+  /** 根据 ID 查找网络类型 — 对齐 jetlinks NetworkTypes.lookup() */
+  lookup(id) {
+    return this.types.get(id.toUpperCase());
+  }
+  /** 获取所有已注册的网络类型 — 对齐 jetlinks NetworkTypes.get() */
+  getAll() {
+    return Array.from(this.types.values());
+  }
+};
+var networkTypeRegistry = new NetworkTypeRegistry();
+
+// src/transport.ts
+function createTransport(protocol, schema) {
+  return {
+    protocol,
+    schema
+  };
+}
+__name(createTransport, "createTransport");
+var Transports = {
+  TCP: createTransport("TCP", "tcp"),
+  UDP: createTransport("UDP", "udp"),
+  HTTP: createTransport("TCP", "http"),
+  HTTPS: createTransport("TCP", "https"),
+  MQTT: createTransport("TCP", "mqtt"),
+  MQTTS: createTransport("TCP", "mqtts"),
+  WS: createTransport("TCP", "ws"),
+  WSS: createTransport("TCP", "wss")
+};
+
+// src/network-manager.ts
+var import_common = require("@nestjs/common");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var DefaultNetworkManager = class _DefaultNetworkManager {
+  static {
+    __name(this, "DefaultNetworkManager");
+  }
+  configManager;
+  logger = new import_common.Logger(_DefaultNetworkManager.name);
+  /** type-id -> Provider */
+  providers = /* @__PURE__ */ new Map();
+  /** type-id -> (network-id -> Network) */
+  store = /* @__PURE__ */ new Map();
+  checkTimer;
+  constructor(configManager) {
+    this.configManager = configManager;
+    this.checkTimer = setInterval(() => {
+      this.checkNetworks().catch((err) => this.logger.error("Network health-check failed", err));
+    }, 1e4);
+  }
+  /* ------------------------------------------------------------------ */
+  /*  Provider 注册                                                      */
+  /* ------------------------------------------------------------------ */
+  registerProvider(provider) {
+    this.providers.set(provider.type.id, provider);
+    this.logger.log(`NetworkProvider registered: ${provider.type.id}`);
+  }
+  /* ------------------------------------------------------------------ */
+  /*  INetworkManager 实现                                               */
+  /* ------------------------------------------------------------------ */
+  async getNetwork(type, id) {
+    const networkMap = this.getNetworkStore(type.id);
+    let network = networkMap.get(id);
+    if (network) return network;
+    network = await this.createFromConfig(type, id);
+    networkMap.set(id, network);
+    return network;
+  }
+  getNetworks() {
+    const result = [];
+    for (const map of this.store.values()) {
+      for (const n of map.values()) {
+        result.push(n);
+      }
+    }
+    return result;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  getProvider(typeId) {
+    return this.providers.get(typeId);
+  }
+  async reload(type, id) {
+    const provider = this.requireProvider(type.id);
+    const props = await this.configManager.getConfig(type, id);
+    if (!props || !props.enabled) return;
+    const config = await provider.createConfig(props);
+    const networkMap = this.getNetworkStore(type.id);
+    const existing = networkMap.get(id);
+    const network = existing ? await provider.reload(existing, config) : await provider.createNetwork(config);
+    networkMap.set(id, network);
+  }
+  async shutdown(type, id) {
+    const network = this.getNetworkStore(type.id).get(id);
+    if (network) {
+      await network.shutdown();
+    }
+  }
+  async destroy(type, id) {
+    const networkMap = this.getNetworkStore(type.id);
+    const network = networkMap.get(id);
+    if (network) {
+      networkMap.delete(id);
+      await network.shutdown();
+    }
+  }
+  /* ------------------------------------------------------------------ */
+  /*  生命周期                                                           */
+  /* ------------------------------------------------------------------ */
+  async onModuleDestroy() {
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+    const shutdowns = [];
+    for (const map of this.store.values()) {
+      for (const network of map.values()) {
+        shutdowns.push(Promise.resolve(network.shutdown()).catch((err) => this.logger.error(`Failed to shutdown network ${network.id}`, err)));
+      }
+    }
+    await Promise.all(shutdowns);
+    this.store.clear();
+  }
+  /* ------------------------------------------------------------------ */
+  /*  内部方法                                                           */
+  /* ------------------------------------------------------------------ */
+  getNetworkStore(typeId) {
+    let map = this.store.get(typeId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.store.set(typeId, map);
+    }
+    return map;
+  }
+  requireProvider(typeId) {
+    const provider = this.providers.get(typeId);
+    if (!provider) {
+      throw new Error(`Unsupported network type: ${typeId}`);
+    }
+    return provider;
+  }
+  async createFromConfig(type, id) {
+    const provider = this.requireProvider(type.id);
+    const props = await this.configManager.getConfig(type, id);
+    if (!props || !props.enabled) {
+      throw new Error(`Network config not found or disabled: ${type.id}/${id}`);
+    }
+    const config = await provider.createConfig(props);
+    return provider.createNetwork(config);
+  }
+  /**
+  * 定期检查网络组件存活状态 — 与 jetlinks checkNetwork() 逻辑对齐。
+  */
+  async checkNetworks() {
+    for (const [typeId, networkMap] of this.store) {
+      const provider = this.providers.get(typeId);
+      if (!provider) continue;
+      for (const [id, network] of networkMap) {
+        if (network.isAlive() || !network.isAutoReload()) continue;
+        try {
+          const props = await this.configManager.getConfig(network.type, id);
+          if (!props || !props.enabled) continue;
+          const config = await provider.createConfig(props);
+          const reloaded = await provider.reload(network, config);
+          networkMap.set(id, reloaded);
+          this.logger.log(`Reloaded network: ${typeId}/${id}`);
+        } catch (err) {
+          this.logger.warn(`Failed to reload network ${typeId}/${id}`, err);
+        }
+      }
+    }
+  }
+};
+DefaultNetworkManager = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof NetworkConfigManager === "undefined" ? Object : NetworkConfigManager
+  ])
+], DefaultNetworkManager);
+
+// src/codec.ts
+var JsonCodec = class {
+  static {
+    __name(this, "JsonCodec");
+  }
+  id;
+  transport;
+  constructor(id, transport) {
+    this.id = id;
+    this.transport = transport;
+  }
+  encode(message) {
+    return Buffer.from(JSON.stringify(message));
+  }
+  decode(payload) {
+    return JSON.parse(payload.toString("utf-8"));
+  }
+};
+
+// src/network.module.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var NETWORK_MANAGER = /* @__PURE__ */ Symbol("NETWORK_MANAGER");
+var NETWORK_CONFIG_MANAGER = /* @__PURE__ */ Symbol("NETWORK_CONFIG_MANAGER");
+var ZuckerNetworkModule = class _ZuckerNetworkModule {
+  static {
+    __name(this, "ZuckerNetworkModule");
+  }
+  static forRoot(options) {
+    const configManagerProvider = typeof options.configManager === "function" ? {
+      provide: NETWORK_CONFIG_MANAGER,
+      useClass: options.configManager
+    } : options.configManager;
+    const networkManagerProvider = {
+      provide: NETWORK_MANAGER,
+      useFactory: /* @__PURE__ */ __name((configManager) => {
+        return new DefaultNetworkManager(configManager);
+      }, "useFactory"),
+      inject: [
+        NETWORK_CONFIG_MANAGER
+      ]
+    };
+    return {
+      module: _ZuckerNetworkModule,
+      global: true,
+      providers: [
+        configManagerProvider,
+        networkManagerProvider
+      ],
+      exports: [
+        NETWORK_MANAGER,
+        NETWORK_CONFIG_MANAGER
+      ]
+    };
+  }
+};
+ZuckerNetworkModule = _ts_decorate2([
+  (0, import_common2.Module)({})
+], ZuckerNetworkModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultNetworkManager,
+  JsonCodec,
+  NETWORK_CONFIG_MANAGER,
+  NETWORK_MANAGER,
+  NetworkTypes,
+  Transports,
+  ZuckerNetworkModule,
+  createTransport,
+  networkType,
+  networkTypeRegistry
+});