@hile/micro 1.0.9 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @hile/micro
 
-基于 `@hile/message-loader` 与 `@hile/message-ws` 的轻量级 **WebSocket 微服务框架**。提供服务注册与发现、心跳保活、熔断、请求超时、自动重试、调用链路追踪等功能。
+基于 `@hile/message-loader` 与 `@hile/message-ws` 的轻量级 **WebSocket 微服务框架**。提供服务注册与发现、心跳保活、熔断、请求超时、自动重试等功能。
 
 ## 架构分层
 
@@ -16,7 +16,7 @@ MessageLoader (路由) + MessageWs (请求/响应传输)
 | **Server** | WebSocket 监听、连接管理、消息路由。不关心注册中心 |
 | **Client** | 远端 Server 的代理，提供 `request()` / `push()` 通信接口 |
 | **Registry** | 注册中心。维护 namespace → 实例列表，心跳检测剔除死实例 |
-| **Application** | 应用服务。集成注册发现、熔断、重试、追踪等功能 |
+| **Application** | 应用服务。集成注册发现、熔断、重试等功能 |
 
 一个 `Application` 实例 **同时** 扮演 provider（`register` 暴露接口）和 consumer（`get` / `call` 调用其它服务）。
 
@@ -176,28 +176,6 @@ await app.call('svc', '/api', data, 5000, 0); // 超时 5s, 不重试
 
 重试策略：失败 → `recordFailure`（peer 被排除）→ 递归 `call(retries-1)` → `getActiveExcludes` 排除已失败的 peer → Registry `/‑/find` 返回其他 peer。
 
-### Correlation ID 链路追踪
-
-`call()` 自动为每次调用注入唯一 `_correlationId`：
-
-```typescript
-provider.register('/api', async ({ data }) => {
-  console.log(data._correlationId); // 自动注入的 UUID
-});
-```
-
-行为规则：
-
-| 入参 data | 结果 |
-|-----------|------|
-| `null / undefined` | 包装为 `{ _correlationId, data: null }` |
-| 字符串 / 数字 | 包装为 `{ _correlationId, data: '原始值' }` |
-| 数组 | 包装为 `{ _correlationId, data: [原始数组] }` |
-| `{ value: 1 }` (无 `_correlationId`) | 扩展为 `{ value: 1, _correlationId: 'uuid' }` |
-| `{ _correlationId: 'trace-1' }` | 保留已有 ID，**不覆盖** |
-
-> **注意：** 原 data 对象不会被修改（使用浅拷贝 `{ ...data, _correlationId }`）。
-
 ### 健康检查
 
 每个 `Application` 自动注册 `/-/health` 端点：
@@ -380,7 +358,7 @@ class Application extends Server {
   // 获取 namespace 对应的远端 Client（缓存 + 自动发现）
   get(namespace: string, exclude?: string[]): Promise<Client>;
 
-  // 一站式调用：get + request + response + 熔断 + 重试 + 追踪
+  // 一站式调用：get + request + response + 熔断 + 重试
   call<T = any>(
     namespace: string,
     url: string,

package/SKILL.md

@@ -30,7 +30,7 @@ description: Code generation and contribution rules for @hile/micro. Use when ed
 | `Server` | `server.ts` | WebSocketServer 生命周期, 出入站连接, Client Map | 不感知 Registry |
 | `Client` | `client.ts` | 远端 Server 的 WebSocket 会话代理 | `dispose()` 必须关闭底层 socket |
 | `Registry` | `registry.ts` | namespace → Set\<host:port\>, 心跳检测, /-/find 随机返回, 环境变量管理 | 自动创建 `~/.registry/` 工作目录 |
-| `Application` | `application.ts` | 注册发现 + 熔断 + 重试 + 追踪 + 心跳 + 远程环境变量读取 | `listen()` 后自动连 Registry |
+| `Application` | `application.ts` | 注册发现 + 熔断 + 重试 + 心跳 + 远程环境变量读取 | `listen()` 后自动连 Registry |
 
 ### 应用模型
 
@@ -142,7 +142,7 @@ export class Application extends Server {
   listen(port: number): Promise<() => Promise<void>>; // 自动连 Registry + 启心跳
 
   get(namespace: string, exclude?: string[]): Promise<Client>;
-  // call() = get + request + response + correlationId + 熔断 + 重试 + 超时
+  // call() = get + request + response + 熔断 + 重试 + 超时
   call<T = any>(
     namespace: string,
     url: string,
@@ -226,27 +226,7 @@ peer 首次失败
 
 **冷卻期:** `CB_COOLDOWN_MS = 30000` (30 秒)。到期后 `getActiveExcludes` 自动清除旧条目。
 
-### 3.3 Correlation ID
-
-`call()` 自动处理 `_correlationId`：
-
-```typescript
-// 非对象/假值/数组 → 包装
-!data || typeof data !== 'object' || Array.isArray(data)
-  → data = { _correlationId: randomUUID(), data }
-
-// 对象无 _correlationId → 浅拷贝注入
-else if (!data._correlationId)
-  → data = { ...data, _correlationId: randomUUID() }
-
-// 对象已有 _correlationId → 保留（透传）
-```
-
-- 使用 `import { randomUUID } from 'node:crypto'`（Node >= 14.17）
-- 永远不修改原始 data 对象（浅拷贝 `{ ...data }`）
-- retry 递归时 data 已包含 `_correlationId`，自动透传
-
-### 3.4 请求超时
+### 3.3 请求超时
 
 **配置链：**
 
@@ -547,8 +527,6 @@ pnpm --filter @hile/micro test     # 必须全部通过
 | call() 基本调用 | `circuit breaker > call() returns data on success` |
 | 熔断排除 | `circuit breaker > excludes a failing peer and selects a different one` |
 | 全排除重置 | `circuit breaker > resets breaker when all peers are excluded` |
-| Correlation ID 注入 | `correlation ID > injects _correlationId into call() data` |
-| Correlation ID 透传 | `correlation ID > preserves existing _correlationId` |
 | 健康检查 | `health endpoint > /-/health returns status and registry state` |
 | 超时 reject | `request timeout > rejects when request exceeds the timeout` |
 | 超时充足则成功 | `request timeout > succeeds when timeout is long enough` |
@@ -585,9 +563,8 @@ pnpm --filter @hile/micro test     # 必须全部通过
 3. **不要在 `Client.dispose()` 中删除 `socket.close()`**（会导致 WebSocketServer.close 长时间等待）
 4. **不要假设 `host:port` 可无损表达 IPv6** — 使用 `[IPv6]:port` 格式，`parseAddressKey` 按最后一个 `:` 切分
 5. **不要传错 Registry 端口** — 丢失 Registry 连接时依赖 `reconnectToRegistry`，不要在外部缓存 registry Client
-6. **不要在 call() 中修改原始 data 对象** — 必须使用浅拷贝 `{ ...data, _correlationId }`
-7. **不要在其他文件中重复 Registry 的 helper 函数** — `selectRandomRegistryAddress`、`parseAddressKey`、`getRegistryConfigsDir`、`namespaceToConfigFile`、`parseConfigFilename` 都在 `registry.ts` 中导出复用
-8. **不要给 call() 增加非可选参数** — `timeout` 和 `retries` 都在尾部且保持可选，不影响现有调用
+6. **不要在其他文件中重复 Registry 的 helper 函数** — `selectRandomRegistryAddress`、`parseAddressKey`、`getRegistryConfigsDir`、`namespaceToConfigFile`、`parseConfigFilename` 都在 `registry.ts` 中导出复用
+7. **不要给 call() 增加非可选参数** — `timeout` 和 `retries` 都在尾部且保持可选，不影响现有调用
 
 ---
 
@@ -617,7 +594,7 @@ pnpm --filter @hile/micro test     # 必须全部通过
 |------|------|
 | `packages/micro/src/registry.ts` | 注册中心（含配置管理、路径工具函数） |
 | `packages/micro/src/application.ts` | 应用服务（含 getEnvVariables） |
-| `packages/micro/src/index.test.ts` | 主测试文件（28 个用例） |
+| `packages/micro/src/index.test.ts` | 主测试文件（27 个用例） |
 | `packages/micro/src/env-config.test.ts` | 配置管理测试文件（13 个用例） |
 | `packages/cli/src/index.ts` | CLI 入口（含 registry configs 子命令组） |
 | `packages/cli/src/configs.ts` | CLI 配置管理 handler（list/get/set/del） |

package/dist/application.d.ts

@@ -36,6 +36,8 @@ export declare class Application extends Server {
     private readonly namespaces;
     private static readonly CB_COOLDOWN_MS;
     private readonly circuitBreakers;
+    private readonly fallbacks;
+    private readonly topics;
     constructor(props: ApplicationProps);
     listen(port?: number): Promise<() => Promise<void>>;
     private scheduleRegistryRetry;
@@ -45,7 +47,20 @@ export declare class Application extends Server {
     private getActiveExcludes;
     private findFromRegistry;
     get(namespace: string, exclude?: string[]): Promise<Client>;
-    call<T = any>(namespace: string, url: string, data: any, timeout?: number, retries?: number): Promise<T>;
-    getEnvVariables<T extends Record<string, Record<string, any>>, const Requests extends readonly EnvRequest<T>[] = readonly EnvRequest<T>[]>(...data: Requests): Promise<GetEnvVariablesResult<T, Requests>>;
+    call<T = any>(namespace: string, url: string, data: any, options?: {
+        timeout?: number;
+        retries?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    stream(namespace: string, url: string, data: any, options?: {
+        signal?: AbortSignal;
+        retries?: number;
+    }): Promise<import('stream').Readable>;
+    publish<T = any>(topic: string, data: T): Promise<{
+        update: (payload: T) => Promise</*elided*/ any>;
+        unpublish: () => Promise</*elided*/ any>;
+    }>;
+    /** 对同一 topic 重复 subscribe 是幂等的：第二次调用只返回 unsubscribe 函数，不会注册第二个 callback */
+    subscribe<T = any>(topic: string, callback: (data: T) => any, isReconnect?: boolean): Promise<() => Promise<void>>;
 }
 export {};

package/dist/application.js

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { Server } from './server.js';
 var RegistryLookupStatus;
 (function (RegistryLookupStatus) {
@@ -48,6 +47,8 @@ export class Application extends Server {
     namespaces = new Map();
     static CB_COOLDOWN_MS = 30_000;
     circuitBreakers = new Map();
+    fallbacks = new Set();
+    topics = new Map();
     constructor(props) {
         const { namespace, registry, registryLookupTimeoutMs = 10_000, requestTimeoutMs = 30_000, ...microAndLoader } = props;
         super(namespace, microAndLoader);
@@ -55,11 +56,15 @@ export class Application extends Server {
         this._registry_address = registry;
         this._registryLookupTimeoutMs = registryLookupTimeoutMs;
         this._requestTimeoutMs = requestTimeoutMs;
-        this.register('/-/health', async () => ({
+        this.fallbacks.add(this.register('/-/health', async () => ({
             status: 'ok',
             registry: !!this.registry,
             uptime: process.uptime(),
             namespaces: [...this.namespaces.keys()],
+        })));
+        this.fallbacks.add(this.register('/-/topic/update', async ({ data }) => {
+            this.events.emit('topic:' + data.topic, data.payload);
+            return Date.now();
         }));
     }
     async listen(port = 0) {
@@ -77,7 +82,13 @@ export class Application extends Server {
             }
             throw err;
         }
+        // 这里不清理 topics 由业务方自己清理
+        // 这里也不清理 declare 和 undeclare 由业务方自己清理
         return async () => {
+            for (const fallback of this.fallbacks) {
+                fallback();
+            }
+            this.fallbacks.clear();
             this.stopped = true;
             if (this.reconnectTimeout) {
                 clearTimeout(this.reconnectTimeout);
@@ -125,6 +136,10 @@ export class Application extends Server {
                 });
             });
             this.registry = registry;
+            // 重新订阅所有 topic
+            for (const [topic, callback] of this.topics) {
+                await this.subscribe(topic, callback, true);
+            }
         })().finally(() => {
             this.registryReconnectPromise = undefined;
         });
@@ -167,8 +182,8 @@ export class Application extends Server {
     async findFromRegistry(namespace, exclude) {
         if (!this.registry)
             throw new Error('Registry not found');
-        const { response } = this.registry.request('/-/find', { namespace, exclude });
-        return await withTimeout(response(), this._registryLookupTimeoutMs, 'Registry /-/find');
+        const promise = this.registry.request('/-/find', { namespace, exclude });
+        return await withTimeout(promise, this._registryLookupTimeoutMs, 'Registry /-/find');
     }
     get(namespace, exclude) {
         if (!this.namespaces.has(namespace)) {
@@ -239,14 +254,35 @@ export class Application extends Server {
             }
         });
     }
-    async call(namespace, url, data, timeout, retries = 1) {
-        // Inject or preserve correlation ID (no mutation of original data)
-        if (!data || typeof data !== 'object' || Array.isArray(data)) {
-            data = { _correlationId: randomUUID(), data };
+    async call(namespace, url, data, options) {
+        const { timeout = this._requestTimeoutMs, retries = 1, signal } = options || {};
+        const exclude = this.getActiveExcludes(namespace);
+        let client;
+        try {
+            client = await this.get(namespace, exclude);
         }
-        else if (!data._correlationId) {
-            data = { ...data, _correlationId: randomUUID() };
+        catch {
+            this.circuitBreakers.delete(namespace);
+            client = await this.get(namespace);
         }
+        try {
+            const result = await client.request(url, data, {
+                timeout: timeout ?? this._requestTimeoutMs,
+                signal,
+            });
+            this.recordSuccess(namespace, client.host, client.port);
+            return result;
+        }
+        catch (err) {
+            this.recordFailure(namespace, client.host, client.port);
+            if (retries > 0) {
+                return this.call(namespace, url, data, { timeout, retries: retries - 1, signal });
+            }
+            throw err;
+        }
+    }
+    async stream(namespace, url, data, options) {
+        const { signal, retries = 1 } = options || {};
         const exclude = this.getActiveExcludes(namespace);
         let client;
         try {
@@ -257,28 +293,60 @@ export class Application extends Server {
             client = await this.get(namespace);
         }
         try {
-            const { response } = client.request(url, data, timeout ?? this._requestTimeoutMs);
-            const result = await response();
+            const readable = client.stream(url, data, { signal });
             this.recordSuccess(namespace, client.host, client.port);
-            return result;
+            return readable;
         }
         catch (err) {
             this.recordFailure(namespace, client.host, client.port);
             if (retries > 0) {
-                return this.call(namespace, url, data, timeout, retries - 1);
+                return this.stream(namespace, url, data, { signal, retries: retries - 1 });
             }
             throw err;
         }
     }
-    async getEnvVariables(...data) {
+    async publish(topic, data) {
         if (!this.registry)
             throw new Error('Registry not found');
-        const { response } = this.registry.request('/-/env/variables', data);
-        const configs = await response();
-        const out = {};
-        for (const { namespace, value } of configs) {
-            out[namespace] = value;
+        await this.registry.request('/-/declare', { topic, payload: data });
+        const ref = {
+            update: async (payload) => {
+                if (!this.registry)
+                    throw new Error('Registry not found');
+                await this.registry.request('/-/topic/update', { topic, payload });
+                return ref;
+            },
+            unpublish: async () => {
+                if (!this.registry)
+                    throw new Error('Registry not found');
+                await this.registry.request('/-/undeclare', { topic });
+                return ref;
+            }
+        };
+        return ref;
+    }
+    /** 对同一 topic 重复 subscribe 是幂等的：第二次调用只返回 unsubscribe 函数，不会注册第二个 callback */
+    async subscribe(topic, callback, isReconnect = false) {
+        if (!this.registry)
+            throw new Error('Registry not found');
+        const fallback = async () => {
+            if (!this.registry)
+                throw new Error('Registry not found');
+            await this.registry.request('/-/unsubscribe', { topic });
+            if (this.topics.has(topic)) {
+                const _callback = this.topics.get(topic);
+                this.events.off('topic:' + topic, _callback);
+                this.topics.delete(topic);
+            }
+        };
+        if (this.topics.has(topic) && !isReconnect)
+            return fallback;
+        const payload = await this.registry.request('/-/subscribe', { topic });
+        if (!isReconnect) {
+            this.events.on('topic:' + topic, callback);
+            this.topics.set(topic, callback);
+            callback(payload);
         }
-        return out;
+        return fallback;
     }
 }

package/dist/client.d.ts

@@ -24,10 +24,16 @@ export declare class Client extends MessageWs {
         url: string;
         data: any;
     }): Promise<any>;
-    request(url: string, data: any, timeout?: number): {
-        abort: () => void;
-        response: <U = any>() => Promise<U>;
-    };
-    push(url: string, data: any, timeout?: number): void;
+    request<T = any>(url: string, data: any, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
+    push(url: string, data: any, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): void;
+    stream(url: string, data: any, options?: {
+        signal?: AbortSignal;
+    }): import("node:stream").Readable;
     dispose(): void;
 }

package/dist/client.js

@@ -52,15 +52,20 @@ export class Client extends MessageWs {
             client: this,
         });
     }
-    request(url, data, timeout) {
+    request(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._send({ url, data }, timeout);
+        return this._send({ url, data }, options);
     }
-    push(url, data, timeout) {
+    push(url, data, options) {
         if (!this._online)
             throw new Error('Client is not online');
-        return this._push({ url, data }, timeout);
+        return this._push({ url, data }, options);
+    }
+    stream(url, data, options) {
+        if (!this._online)
+            throw new Error('Client is not online');
+        return this._stream({ url, data }, options);
     }
     dispose() {
         if (this.heartbeatTimer)

package/dist/registry.d.ts

@@ -15,15 +15,19 @@ export declare function namespaceToConfigFile(ns: string): string;
 export declare function parseConfigFilename(filename: string): string | null;
 export declare class Registry extends Server {
     private readonly namespaces;
-    private unregisterFind?;
     private readonly workspace;
     private readonly configFileSuffix;
     private readonly configs;
+    private readonly fallbacks;
+    private readonly topics;
     constructor(props?: MicroServerProps);
     watchEnvFile(): import("node:fs").FSWatcher | undefined;
     listen(port?: number): Promise<() => Promise<void>>;
-    /** 幂等：重复调用会先注销上一条 `/-/find` 再注册，避免叠多条路由 */
-    onFind(): void;
-    private mountFindHandler;
-    private registerEnvVariables;
+    private registerFindApplication;
+    private registerDeclare;
+    private registerUndeclare;
+    private registerSubscribe;
+    private registerUnsubscribe;
+    private registerReceiveTopicUpdate;
+    private publish;
 }

package/dist/registry.js

@@ -41,10 +41,11 @@ export function parseConfigFilename(filename) {
 }
 export class Registry extends Server {
     namespaces = new Map();
-    unregisterFind;
     workspace;
     configFileSuffix = '.config.yaml';
     configs = new Map();
+    fallbacks = new Set();
+    topics = new Map();
     constructor(props = {}) {
         const workspace = resolve(homedir(), '.registry');
         if (!existsSync(workspace)) {
@@ -62,6 +63,17 @@ export class Registry extends Server {
         });
         this.events.on('disconnect', (client, extras) => {
             const key = client.host + ':' + client.port;
+            // 清理 topic 中的关联
+            for (const [topic, { publishers, subscribers }] of this.topics) {
+                if (publishers.has(key))
+                    publishers.delete(key);
+                if (subscribers.has(key))
+                    subscribers.delete(key);
+                if (publishers.size === 0 && subscribers.size === 0) {
+                    this.topics.delete(topic);
+                }
+            }
+            // 清理 namespace 中的关联
             const namespace = extras.join('/');
             if (this.namespaces.has(namespace)) {
                 const keys = this.namespaces.get(namespace);
@@ -73,8 +85,12 @@ export class Registry extends Server {
                 }
             }
         });
-        this.mountFindHandler();
-        this.registerEnvVariables();
+        this.registerFindApplication();
+        this.registerDeclare();
+        this.registerUndeclare();
+        this.registerSubscribe();
+        this.registerUnsubscribe();
+        this.registerReceiveTopicUpdate();
     }
     watchEnvFile() {
         const configFile = resolve(this.workspace, 'configs');
@@ -86,18 +102,42 @@ export class Registry extends Server {
                 const config = YAML.parse(readFileSync(resolve(configFile, filename), 'utf8'));
                 if (typeof config !== 'object' || config === null)
                     continue;
-                this.configs.set(parseConfigFilename(filename), config);
+                const namespace = parseConfigFilename(filename);
+                this.configs.set(namespace, config);
+                const keys = Object.keys(config);
+                for (const key of keys) {
+                    const _key = `registry:${namespace}/${key}`;
+                    if (!this.topics.has(_key)) {
+                        this.topics.set(_key, { publishers: new Set(), subscribers: new Set(), data: config[key] });
+                    }
+                }
             }
             catch { }
         }
         return watch(configFile, (_, filename) => {
             if (!filename?.endsWith(this.configFileSuffix))
                 return;
+            const fullPath = resolve(configFile, filename);
+            if (!existsSync(fullPath)) {
+                const namespace = parseConfigFilename(filename);
+                this.configs.delete(namespace);
+                return;
+            }
             try {
-                const config = YAML.parse(readFileSync(resolve(configFile, filename), 'utf8'));
+                const config = YAML.parse(readFileSync(fullPath, 'utf8'));
                 if (typeof config !== 'object' || config === null)
                     return;
-                this.configs.set(parseConfigFilename(filename), config);
+                const namespace = parseConfigFilename(filename);
+                this.configs.set(namespace, config);
+                const keys = Object.keys(config);
+                // 只加不减
+                for (const key of keys) {
+                    const _key = `registry:${namespace}/${key}`;
+                    if (!this.topics.has(_key)) {
+                        this.topics.set(_key, { publishers: new Set(), subscribers: new Set(), data: config[key] });
+                    }
+                    this.publish(_key, config[key]);
+                }
             }
             catch { /* vim 替换文件时的中间态读错误，忽略 */ }
         });
@@ -112,19 +152,15 @@ export class Registry extends Server {
         return async () => {
             if (watcher)
                 watcher.close();
+            for (const fallback of this.fallbacks) {
+                fallback();
+            }
+            this.fallbacks.clear();
             await teardown();
         };
     }
-    /** 幂等：重复调用会先注销上一条 `/-/find` 再注册，避免叠多条路由 */
-    onFind() {
-        this.mountFindHandler();
-    }
-    mountFindHandler() {
-        if (this.unregisterFind) {
-            this.unregisterFind();
-            this.unregisterFind = undefined;
-        }
-        this.unregisterFind = this.register('/-/find', async ({ data }) => {
+    registerFindApplication() {
+        this.fallbacks.add(this.register('/-/find', async ({ data }) => {
             const namespace = data.namespace;
             let keys = this.namespaces.get(namespace);
             if (!keys)
@@ -137,23 +173,92 @@ export class Registry extends Server {
                 keys = new Set(filtered);
             }
             return selectRandomRegistryAddress(keys);
-        });
+        }));
+    }
+    registerDeclare() {
+        this.fallbacks.add(this.register('/-/declare', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic)) {
+                this.topics.set(data.topic, { publishers: new Set(), subscribers: new Set(), data: data.payload });
+            }
+            const entry = this.topics.get(data.topic);
+            const publishers = entry.publishers;
+            entry.data = data.payload;
+            publishers.add(key);
+            this.publish(data.topic, data.payload);
+            return Date.now();
+        }));
     }
-    registerEnvVariables() {
-        this.register('/-/env/variables', async ({ data }) => {
-            return data.map(({ namespace, fields }) => {
-                if (!this.configs.has(namespace)) {
-                    return { namespace, value: null };
+    registerUndeclare() {
+        this.fallbacks.add(this.register('/-/undeclare', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic))
+                return 0;
+            const entry = this.topics.get(data.topic);
+            const publishers = entry.publishers;
+            const subscribers = entry.subscribers;
+            const i = publishers.size;
+            if (publishers.has(key)) {
+                publishers.delete(key);
+                if (publishers.size === 0 && subscribers.size === 0) {
+                    this.topics.delete(data.topic);
                 }
-                if (!fields?.length)
-                    return { namespace, value: this.configs.get(namespace) };
-                const config = this.configs.get(namespace);
-                const value = {};
-                for (const field of fields) {
-                    value[field] = config[field];
+            }
+            return i - publishers.size;
+        }));
+    }
+    registerSubscribe() {
+        this.fallbacks.add(this.register('/-/subscribe', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic)) {
+                this.topics.set(data.topic, { publishers: new Set(), subscribers: new Set(), data: undefined });
+            }
+            const entry = this.topics.get(data.topic);
+            const subscribers = entry.subscribers;
+            subscribers.add(key);
+            return entry.data;
+        }));
+    }
+    registerUnsubscribe() {
+        this.fallbacks.add(this.register('/-/unsubscribe', async ({ data, client }) => {
+            const key = `${client.host}:${client.port}`;
+            if (!this.topics.has(data.topic))
+                return 0;
+            const entry = this.topics.get(data.topic);
+            const subscribers = entry.subscribers;
+            const publishers = entry.publishers;
+            const i = subscribers.size;
+            if (subscribers.has(key)) {
+                subscribers.delete(key);
+                if (subscribers.size === 0 && publishers.size === 0) {
+                    this.topics.delete(data.topic);
                 }
-                return { namespace, value };
-            });
-        });
+            }
+            return i - subscribers.size;
+        }));
+    }
+    registerReceiveTopicUpdate() {
+        this.fallbacks.add(this.register('/-/topic/update', async ({ data }) => {
+            // 转发
+            this.publish(data.topic, data.payload);
+            return Date.now();
+        }));
+    }
+    publish(topic, payload) {
+        if (!this.topics.has(topic))
+            return;
+        const entry = this.topics.get(topic);
+        const subscribers = entry.subscribers;
+        entry.data = payload;
+        for (const key of subscribers.values()) {
+            try {
+                if (this.clients.has(key)) {
+                    this.clients.get(key).push(`/-/topic/update`, { topic, payload });
+                }
+            }
+            catch {
+                // 推送失败，disconnect 事件中会清理                                                             
+            }
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/micro",
-  "version": "1.0.9",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -23,11 +23,11 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@hile/message-loader": "^1.0.8",
-    "@hile/message-ws": "^1.0.6",
+    "@hile/message-loader": "^1.0.9",
+    "@hile/message-ws": "^2.0.0",
     "internal-ip": "^9.0.0",
     "ws": "^8.19.0",
     "yaml": "^2.9.0"
   },
-  "gitHead": "fa7d6d442ab080e6a395ee2a1dacac9eae340cf6"
+  "gitHead": "d28b20bc22ee08c45cbf4596672705cb96e8e461"
 }