@hile/micro 1.0.1

package/README.md

@@ -0,0 +1,111 @@
+# @hile/micro
+
+基于 `@hile/message-loader` 与 `@hile/message-ws` 的轻量级 **WebSocket 服务注册与发现**：用固定格式的连接 URL 标识对端，`Registry` 按逻辑 namespace 记录实例，`Application` 从注册中心拉取地址并缓存到远端服务的会话。
+
+## 安装
+
+```bash
+pnpm add @hile/micro
+```
+
+依赖：`@hile/message-loader`、`@hile/message-ws`、`ws`（随 workspace 一并解析）。
+
+---
+
+## 能做什么？
+
+| 组件 | 作用 |
+|------|------|
+| `Server` | 监听 WebSocket；解析路径中的调用方地址与可选分段；对内用 `register`/`dispatch` 处理 `{ url, data }` |
+| `Client` | 连到远端 `Server`，`request`/`push` 走 `MessageModem`，`dispose()` 会关闭底层连接 |
+| `Registry` | 固定 namespace `'registry'`；实例上线/下线更新 namespace→地址集合；`/-/find` **随机** 返回其中一个地址 |
+| `Application` | 启动后连接 Registry；`get(ns)` 查询并 **缓存** 到目标服务的 `Client`，断连后清空缓存 |
+
+连接串格式（出站）：
+
+`ws://目标主机:端口/{本机广告IPv4}/{本机监听端口}/{本机namespace}`
+
+其中广告 IPv4 由 `getLocalIPv4()` 取第一个非回环网卡地址；多网卡或容器环境可能需要后续版本支持显式 `advertiseHost`（当前未暴露）。
+
+出站 `connect` 默认 **5 秒**握手超时，超时报错 `Connection timeout`。
+
+---
+
+## 快速示例
+
+### 1. Registry
+
+```typescript
+import { Registry } from '@hile/micro';
+
+const registry = new Registry();
+await registry.listen(9000);
+```
+
+### 2. 服务提供方（被其它 Application 发现的进程）
+
+```typescript
+import { Application } from '@hile/micro';
+
+const provider = new Application({
+  namespace: 'payments',
+  registry: { host: '127.0.0.1', port: 9000 },
+});
+
+await provider.listen(9100);
+
+provider.register('/charge', async ({ data }) => {
+  return { charged: true, amount: data.amount };
+});
+```
+
+### 3. 调用方（通过 Registry 解析地址）
+
+```typescript
+import { Application } from '@hile/micro';
+
+const consumer = new Application({
+  namespace: 'checkout',
+  registry: { host: '127.0.0.1', port: 9000 },
+});
+
+await consumer.listen(9200);
+
+const remote = await consumer.get('payments');
+const { response } = remote.request('/charge', { amount: 100 });
+const result = await response<{ charged: boolean; amount: number }>();
+console.log(result);
+```
+
+### 关闭
+
+`listen` 返回的 teardown 函数会关闭 WebSocketServer 并对已有 `Client` 调用 `dispose()`：
+
+```typescript
+const stop = await provider.listen(9100);
+// ...
+await stop();
+```
+
+---
+
+## 与 Hile core 的关系
+
+`@hile/micro` **不依赖** `@hile/core`，可与任意 Node.js 进程或在未来由 `defineService` 包装后接入 Hile 容器。
+
+---
+
+## 文档策略
+
+| 文档 | 读者 | 用途 |
+|------|------|------|
+| 本 README | 使用者 | 安装、概念、示例 |
+| `SKILL.md` | AI / 贡献者 | 路由约定、类型、反模式、测试门禁 |
+
+仓库线上文档见 Mintlify：**API 参考 → @hile/micro**（若已启用）。
+
+---
+
+## License
+
+MIT

package/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: micro
+description: Code generation and contribution rules for @hile/micro. Use when editing this package or when the user asks about @hile/micro patterns or API.
+---
+
+# @hile/micro
+
+本文档面向 **AI 编码模型** 与 **贡献者**：在修改或生成 `@hile/micro` 相关代码前必读，保证与现有 WebSocket 路由、注册中心与 `MessageLoader` 约定一致。
+
+---
+
+## 1. 架构总览
+
+`@hile/micro` 在 `@hile/message-loader` + `@hile/message-ws` 之上提供 **轻量级进程间服务发现与会话**：
+
+- **`Server`**：基于 `ws` 的 `WebSocketServer`，用 **URL 路径** 携带对端身份与命名空间；对内用 `MessageLoader.register` / `dispatch` 处理消息路由。
+- **`Client`**：连接到远端 `Server`，`request(url, data)` / `push(url, data)` 将负载交给本端 `Server.dispatch`；`dispose()` 会移除监听并 **关闭底层 WebSocket**，避免 `listen` 关闭阶段挂住。
+- **`Registry`**：固定 `namespace` 为 `'registry'`，维护「逻辑 namespace → 一组 `host:port`」；`/-/find` 在集合中 **随机** 返回一条地址（见 `selectRandomRegistryAddress`）。
+- **`Application`**：`Server` 的子类；`listen(port)` 后自动 `connect` 到注册中心；`get(targetNamespace)` 向注册中心查询并 **缓存** 到目标服务的 `Client`，目标断连后删除缓存以便下次重新发现。
+
+依赖链：
+
+```
+MessageLoader (路由) + MessageWs (请求/响应传输)
+  └── Server / Client
+        ├── Registry
+        └── Application
+```
+
+---
+
+## 2. 路由与 URL 约定（强约束）
+
+### 2.1 入站连接路径
+
+对端发起连接时的 URL 必须为：
+
+```text
+ws://{listenHost}:{listenPort}/{callerHost}/{callerPort}/{...extras}
+```
+
+解析规则见 `Server.onConnected`：
+
+- 至少 **三段** 路径：`callerHost`、`callerPort` 以及后续 `extras`（可为空）。
+- `extras` 以 `/` 分段，在 `events.emit('connect', client, extras)` 中交给业务；**Registry** 用 `extras.join('/')` 作为 **服务逻辑 namespace**。
+
+生成侧：`Server.connect()` 使用：
+
+```text
+ws://{host}:{port}/${this.ipv4}/${this.port}/${this.namespace}
+```
+
+其中 `this.ipv4` 来自 `getLocalIPv4()`（见 `utils.ts`），`this.port` 为当前 `listen` 端口，`this.namespace` 为构造传入的字符串（如 `provider`、`consumer`、`registry`）。
+
+### 2.2 MessageLoader 路由
+
+- 对内消息体为 `{ url, data }`，与 `Client.exec` 一致。
+- `Registry` 注册：`register<RegistryFindData>('/-/find', handler)`，请求体 `{ namespace: string }`。
+
+---
+
+## 3. 类型与关键 API（生成代码须一致）
+
+```typescript
+// registry.ts
+export interface RegistryFindData {
+  namespace: string;
+}
+
+export interface RegistryAddress {
+  host: string;
+  port: number;
+}
+
+export function selectRandomRegistryAddress(
+  keys: Iterable<string>,
+): RegistryAddress | undefined;
+
+export class Registry extends Server { /* ... */ }
+
+// application.ts
+export type ApplicationProps = {
+  namespace: string;
+  registry: RegistryAddress;
+} & MessageLoaderProps;
+
+export class Application extends Server {
+  listen(port: number): Promise<() => Promise<void>>;
+  get(namespace: string): Promise<Client>;
+}
+
+// server.ts — connect 第三参仅用于测试或内部，默认超时 5s
+protected async connect(host: string, port: number, timeout?: number): Promise<Client>;
+
+// client.ts
+export class Client extends MessageWs {
+  request(url: string, data: any, timeout?: number): ReturnType<MessageWs['_send']>;
+  push(url: string, data: any, timeout?: number): void;
+  dispose(): void;
+}
+```
+
+`Application` 内部缓存查找状态为 `IDLE` → `PENDING` → `READY`：首次 `get` 必须从 `IDLE` 触发 `findFromRegistry`，禁止再出现「初始状态与触发条件不匹配」导致永久挂起。
+
+---
+
+## 4. 代码生成模板与规则
+
+### 4.1 Registry 服务端
+
+```typescript
+const registry = new Registry();
+const dispose = await registry.listen(registryPort);
+// shutdown: await dispose();
+```
+
+### 4.2 可被发现的服务（Application）
+
+```typescript
+const app = new Application({
+  namespace: 'my-service',
+  registry: { host: '127.0.0.1', port: registryPort },
+});
+const dispose = await app.listen(appPort);
+
+app.register('/hello', async ({ data }) => {
+  return { ok: true, data };
+});
+
+const peer = await otherApp.get('my-service');
+const { response } = peer.request('/hello', { x: 1 });
+const result = await response();
+```
+
+### 4.2 连接超时
+
+`Server.connect` 默认 **5 秒** 内未完成握手则 `reject(new Error('Connection timeout'))`。自定义第三参仅限受保护方法与测试辅助类，不要在公开 API 上强制调用方传入。
+
+### 4.3 随机选择
+
+`/-/find` 返回的地址必须来自 Registry 内存集合内的 `host:port` 键；新增选择策略时需保持 **Registry 端无额外状态机**（尽量无 cursor），除非你同时补充设计与测试。
+
+---
+
+## 5. 反模式（禁止）
+
+- 修改 WebSocket URL 三段式约定却不同时更新 **`Server.onConnected`** 与 **`Server.connect`** 的拼接格式。
+- 在 `Registry` 中按 `Set` **迭代顺序** 固定返回「第一个」实例（破坏负载分散）；除非你明确改需求并改写测试。
+- `Client`/`Server` **`dispose`** 后不关闭 **`ws`**（会导致 **`WebSocketServer.close`** 长时间等待）；本包已在 `Client.dispose` 内关闭socket，不要随意删除。
+- 假设 `host:port` 串可无损表达 **IPv6**（当前实现按 **首个 `:` 分割**，仅适合 IPv4 或不含冒号的 host）。
+- `Application.props.registry` **不要传错端口**；丢失与注册中心的连接时依赖 `reconnectToRegistry`，不要在外部缓存 `registry` Client 绕过重连语义。
+
+---
+
+## 6. 测试与改动范围
+
+- 包内测试：`packages/micro/src/index.test.ts`（Vitest）。
+- 修改行为时至少覆盖：**随机选择 helper**、`Application` 端到端发现、**连接超时**。
+- 发布前在项目根或通过 filter 运行：`pnpm --filter @hile/micro test` 与 `pnpm --filter @hile/micro build`。

package/dist/application.d.ts

@@ -0,0 +1,19 @@
+import { Client } from './client.js';
+import { Server } from './server.js';
+import { MessageLoaderProps } from '@hile/message-loader';
+import { RegistryAddress } from './registry.js';
+export type ApplicationProps = {
+    namespace: string;
+    registry: RegistryAddress;
+} & MessageLoaderProps;
+export declare class Application extends Server {
+    private registry?;
+    private reconnectTimeout?;
+    private readonly _registry_address;
+    private readonly namespaces;
+    constructor(props: ApplicationProps);
+    listen(port: number): Promise<() => Promise<void>>;
+    private reconnectToRegistry;
+    private findFromRegistry;
+    get(namespace: string): Promise<Client>;
+}

package/dist/application.js

@@ -0,0 +1,91 @@
+import { Server } from './server.js';
+var RegistryLookupStatus;
+(function (RegistryLookupStatus) {
+    RegistryLookupStatus[RegistryLookupStatus["IDLE"] = 0] = "IDLE";
+    RegistryLookupStatus[RegistryLookupStatus["PENDING"] = 1] = "PENDING";
+    RegistryLookupStatus[RegistryLookupStatus["READY"] = 2] = "READY";
+})(RegistryLookupStatus || (RegistryLookupStatus = {}));
+export class Application extends Server {
+    registry;
+    reconnectTimeout;
+    _registry_address;
+    namespaces = new Map();
+    constructor(props) {
+        const { namespace, registry, ...loaderProps } = props;
+        super(namespace, loaderProps);
+        this._registry_address = registry;
+    }
+    async listen(port) {
+        const callback = await super.listen(port);
+        await this.reconnectToRegistry();
+        return async () => {
+            if (this.reconnectTimeout)
+                clearTimeout(this.reconnectTimeout);
+            await callback();
+        };
+    }
+    async reconnectToRegistry() {
+        const registry = await this.connect(this._registry_address.host, this._registry_address.port);
+        registry.events.on('disconnect', () => {
+            this.registry = undefined;
+            const reconnect = () => {
+                this.reconnectToRegistry().catch(e => {
+                    this.reconnectTimeout = setTimeout(reconnect, 3000);
+                });
+            };
+            reconnect();
+        });
+        this.registry = registry;
+    }
+    async findFromRegistry(namespace) {
+        if (!this.registry)
+            throw new Error('Registry not found');
+        const { response } = this.registry.request('/-/find', { namespace });
+        return await response();
+    }
+    get(namespace) {
+        if (!this.namespaces.has(namespace)) {
+            this.namespaces.set(namespace, {
+                host: '',
+                port: 0,
+                status: RegistryLookupStatus.IDLE,
+                handlers: new Set(),
+            });
+        }
+        const stack = this.namespaces.get(namespace);
+        const key = `${stack.host}:${stack.port}`;
+        if (stack.status === RegistryLookupStatus.READY && this.clients.has(key)) {
+            return Promise.resolve(this.clients.get(key));
+        }
+        return new Promise((resolve, reject) => {
+            stack.handlers.add([resolve, reject]);
+            if (stack.status === RegistryLookupStatus.IDLE) {
+                stack.status = RegistryLookupStatus.PENDING;
+                this.findFromRegistry(namespace).then(data => {
+                    if (!data)
+                        return Promise.reject(new Error('Namespace not found'));
+                    return this.connect(data.host, data.port).then(client => {
+                        stack.host = data.host;
+                        stack.port = data.port;
+                        stack.status = RegistryLookupStatus.READY;
+                        for (const [resolve] of stack.handlers.values()) {
+                            resolve(client);
+                        }
+                        return client;
+                    });
+                }).then(client => {
+                    client.events.on('disconnect', () => {
+                        if (this.namespaces.has(namespace)) {
+                            this.namespaces.delete(namespace);
+                        }
+                    });
+                }).catch(e => {
+                    this.namespaces.delete(namespace);
+                    for (const [_, reject] of stack.handlers.values()) {
+                        reject(e);
+                    }
+                }).finally(() => stack.handlers.clear());
+            }
+        });
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,29 @@
+import { MessageWs } from "@hile/message-ws";
+import { Server } from './server.js';
+import { WebSocket } from 'ws';
+import { EventEmitter } from 'node:events';
+export interface ClientProps {
+    host: string;
+    port: number;
+    server: Server;
+    ws: WebSocket;
+}
+export declare class Client extends MessageWs {
+    private readonly server;
+    private readonly socket;
+    readonly host: string;
+    readonly port: number;
+    private _online;
+    readonly events: EventEmitter<any>;
+    constructor(props: ClientProps);
+    protected exec(data: {
+        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;
+    dispose(): void;
+}

package/dist/client.js

@@ -0,0 +1,44 @@
+import { MessageWs } from "@hile/message-ws";
+import { WebSocket } from 'ws';
+import { EventEmitter } from 'node:events';
+export class Client extends MessageWs {
+    server;
+    socket;
+    host;
+    port;
+    _online = true;
+    events = new EventEmitter();
+    constructor(props) {
+        const { server, ws, host, port } = props;
+        super(ws);
+        this.server = server;
+        this.socket = ws;
+        this.host = host;
+        this.port = port;
+        this.events.on('connect', () => this._online = true);
+        this.events.on('disconnect', () => this._online = false);
+    }
+    async exec(data) {
+        if (!this._online)
+            throw new Error('Client is not online');
+        return this.server.dispatch(data.url, data.data, {
+            client: this,
+        });
+    }
+    request(url, data, timeout) {
+        if (!this._online)
+            throw new Error('Client is not online');
+        return this._send({ url, data }, timeout);
+    }
+    push(url, data, timeout) {
+        if (!this._online)
+            throw new Error('Client is not online');
+        return this._push({ url, data }, timeout);
+    }
+    dispose() {
+        super.dispose();
+        if (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING) {
+            this.socket.close();
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './server.js';
+export * from './client.js';
+export * from './application.js';
+export * from './registry.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './server.js';
+export * from './client.js';
+export * from './application.js';
+export * from './registry.js';

package/dist/registry.d.ts

@@ -0,0 +1,15 @@
+import { MessageLoaderProps } from '@hile/message-loader';
+import { Server } from './server.js';
+export interface RegistryFindData {
+    namespace: string;
+}
+export interface RegistryAddress {
+    host: string;
+    port: number;
+}
+export declare function selectRandomRegistryAddress(keys: Iterable<string>): RegistryAddress | undefined;
+export declare class Registry extends Server {
+    private readonly namespaces;
+    constructor(props?: MessageLoaderProps);
+    onFind(): void;
+}

package/dist/registry.js

@@ -0,0 +1,48 @@
+import { Server } from './server.js';
+export function selectRandomRegistryAddress(keys) {
+    const addresses = Array.from(keys).map((key) => {
+        const [host, port] = key.split(':');
+        return { host, port: Number(port) };
+    });
+    if (addresses.length === 0)
+        return;
+    const index = Math.floor(Math.random() * addresses.length);
+    return addresses[index];
+}
+export class Registry extends Server {
+    namespaces = new Map();
+    constructor(props) {
+        super('registry', props);
+        this.events.on('connect', (client, extras) => {
+            const key = client.host + ':' + client.port;
+            const namespace = extras.join('/');
+            if (!this.namespaces.has(namespace)) {
+                this.namespaces.set(namespace, new Set());
+            }
+            this.namespaces.get(namespace).add(key);
+        });
+        this.events.on('disconnect', (client, extras) => {
+            const key = client.host + ':' + client.port;
+            const namespace = extras.join('/');
+            if (this.namespaces.has(namespace)) {
+                const keys = this.namespaces.get(namespace);
+                if (keys.has(key)) {
+                    keys.delete(key);
+                    if (keys.size === 0) {
+                        this.namespaces.delete(namespace);
+                    }
+                }
+            }
+        });
+        this.onFind();
+    }
+    onFind() {
+        this.register('/-/find', async ({ data }) => {
+            const namespace = data.namespace;
+            const keys = this.namespaces.get(namespace);
+            if (!keys)
+                return;
+            return selectRandomRegistryAddress(keys);
+        });
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+import { MessageLoader, MessageLoaderProps } from "@hile/message-loader";
+import { Client } from './client.js';
+import { EventEmitter } from 'node:events';
+export declare class Server extends MessageLoader {
+    private readonly namespace;
+    private wss?;
+    port?: number;
+    protected readonly clients: Map<string, Client>;
+    private readonly ipv4;
+    readonly events: EventEmitter<any>;
+    constructor(namespace: string, props?: MessageLoaderProps);
+    private onConnected;
+    private onRegister;
+    protected connect(host: string, port: number, timeout?: number): Promise<Client>;
+    listen(port?: number): Promise<() => Promise<void>>;
+}

package/dist/server.js

@@ -0,0 +1,127 @@
+import { WebSocketServer } from 'ws';
+import { MessageLoader } from "@hile/message-loader";
+import { WebSocket } from 'ws';
+import { Client } from './client.js';
+import { getLocalIPv4 } from './utils.js';
+import { EventEmitter } from 'node:events';
+const DEFAULT_CONNECT_TIMEOUT = 5000;
+export class Server extends MessageLoader {
+    namespace;
+    wss;
+    port;
+    clients = new Map();
+    ipv4 = getLocalIPv4();
+    events = new EventEmitter();
+    constructor(namespace, props = {}) {
+        super(props);
+        this.namespace = namespace;
+        this.events.on('connect', (client, extras) => {
+            client.events.emit('connect', extras);
+        });
+        this.events.on('disconnect', (client, extras) => {
+            client.events.emit('disconnect', extras);
+        });
+    }
+    onConnected(ws, req) {
+        const path = req.url?.split('?')[0];
+        if (!path)
+            return ws.close();
+        let _path = path.startsWith('/') ? path.slice(1) : path;
+        _path = _path.endsWith('/') ? _path.slice(0, -1) : _path;
+        const sp = _path.split('/');
+        if (sp.length < 3)
+            return ws.close();
+        const [host, port, ...extras] = sp;
+        if (!host || !port)
+            return ws.close();
+        this.onRegister(ws, host, Number(port), extras);
+    }
+    onRegister(ws, host, port, extras = []) {
+        const key = `${host}:${port}`;
+        const client = new Client({ server: this, ws, host, port });
+        ws.on('close', () => {
+            if (this.clients.has(key)) {
+                this.clients.delete(key);
+            }
+            client.dispose();
+            this.events.emit('disconnect', client, extras);
+        });
+        this.clients.set(key, client);
+        this.events.emit('connect', client, extras);
+        return client;
+    }
+    async connect(host, port, timeout = DEFAULT_CONNECT_TIMEOUT) {
+        const key = `${host}:${port}`;
+        if (this.clients.has(key)) {
+            return this.clients.get(key);
+        }
+        const ws = await new Promise((resolve, reject) => {
+            const ws = new WebSocket(`ws://${host}:${port}/${this.ipv4}/${this.port}/${this.namespace}`);
+            const timer = setTimeout(() => {
+                clear();
+                ws.on('error', () => { });
+                try {
+                    ws.terminate();
+                }
+                catch { }
+                reject(new Error('Connection timeout'));
+            }, timeout).unref();
+            const clear = () => {
+                clearTimeout(timer);
+                ws.off('open', onopen);
+                ws.off('error', onerror);
+            };
+            const onerror = (err) => {
+                clear();
+                reject(err);
+            };
+            const onopen = () => {
+                clear();
+                resolve(ws);
+            };
+            ws.on('open', onopen);
+            ws.on('error', onerror);
+        });
+        return this.onRegister(ws, host, port);
+    }
+    async listen(port) {
+        this.wss = await new Promise((resolve, reject) => {
+            const wss = new WebSocketServer({ port });
+            const clear = () => {
+                wss.off('error', onerror);
+                wss.off('listening', onlistening);
+            };
+            const onerror = (err) => {
+                clear();
+                reject(err);
+            };
+            const onlistening = () => {
+                clear();
+                resolve(wss);
+            };
+            wss.on('error', onerror);
+            wss.on('listening', onlistening);
+        });
+        const onConnection = (ws, req) => this.onConnected(ws, req);
+        this.wss.on('connection', onConnection);
+        this.port = port;
+        return async () => {
+            for (const client of this.clients.values()) {
+                client.dispose();
+            }
+            this.clients.clear();
+            if (this.wss) {
+                this.wss.off('connection', onConnection);
+                await new Promise((resolve, reject) => {
+                    this.wss.close((err) => {
+                        if (err)
+                            return reject(err);
+                        resolve();
+                    });
+                });
+            }
+            this.wss = undefined;
+            this.port = undefined;
+        };
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 获取本机第一个非回环、非内部的 IPv4 地址；若无则返回 `undefined`。
+ */
+export declare function getLocalIPv4(): string | undefined;

package/dist/utils.js

@@ -0,0 +1,24 @@
+import { networkInterfaces } from 'node:os';
+function isIPv4(family) {
+    return family === 'IPv4' || family === 4;
+}
+/**
+ * 获取本机第一个非回环、非内部的 IPv4 地址；若无则返回 `undefined`。
+ */
+export function getLocalIPv4() {
+    const ifaces = networkInterfaces();
+    if (!ifaces) {
+        return undefined;
+    }
+    for (const addrs of Object.values(ifaces)) {
+        if (!addrs) {
+            continue;
+        }
+        for (const addr of addrs) {
+            if (isIPv4(addr.family) && !addr.internal) {
+                return addr.address;
+            }
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@hile/micro",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -b && fix-esm-import-path --preserve-import-type ./dist",
+    "dev": "tsc -b --watch",
+    "test": "vitest run"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "SKILL.md"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "fix-esm-import-path": "^1.10.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@hile/message-loader": "^1.0.8",
+    "@hile/message-ws": "^1.0.6",
+    "ws": "^8.19.0"
+  },
+  "gitHead": "75188f29c1a041ed596b9f8aa9ed5ab9fde1b615"
+}