@proteus-vue/hmr 0.1.0

package/README.md

@@ -0,0 +1,122 @@
+# @proteus-vue/hmr
+
+Proteus HMR 运行时（devtools-plus **G-34 M1**）——HMR payload 协议 + 运行时 + Vue `import.meta.hot` 适配 + WebSocket 客户端 + 安全 reload。**开发期工具链**，不随业务产物发布；**零依赖**（全部接口注入式），纯逻辑可单测（Web 端优先）。
+
+## 导出
+
+| API | 说明 |
+|-----|------|
+| `createHmrRuntime(options)` | **HMR Runtime 核心**：接收增量 payload → 分派（vue/js 热替换 / native-binding 安全 reload / css-asset 资源替换）+ 按 id 防乱序 + 状态保留 + 严格规则 + 可观测事件；**`applyBatch` 批量接口**（同文件合并只保留最终状态 + 按 id 排序） |
+| `createHmrClient(options)` | **WebSocket 客户端**：连接 Dev Server → payload 分发到 runtime；断线指数退避重连（maxAttempts 上限）；`createSocket` 注入可单测 |
+| `createVueHotAdapter(options)` | **Vue `import.meta.hot` 适配**：accept/dispose/invalidate 语义面 + `applyWithState` 状态保留（dispose 快照 → 新模块恢复，Flutter Hot Reload 体验）；无 hot 环境安全降级 no-op |
+| `createSafeReload(options)` | **安全 reload**（HMR002）：保存状态（collect 注入；M3 原生侧联动 Router G-32 栈序列化）→ reload → 恢复；Web 实现用 sessionStorage + location.reload |
+
+## 子路径：`@proteus-vue/hmr/dev-server`（Node 侧，G-34 收尾）
+
+| API | 说明 |
+|-----|------|
+| `createHmrDevServer(options)` | **HMR Dev Server**：WS 服务端（host 缺省 127.0.0.1）+ 文件 watch 防抖管线 + **增量编译回调注入**（`compile(files) → HmrPayload[]`）→ 广播；链路：保存文件 → watch 收集 → 防抖合并 → 增量编译 → WS 广播 → 客户端 Runtime 应用；`port 0` 随机端口 + 实际端口 getter |
+
+```ts
+import { createHmrDevServer } from '@proteus-vue/hmr/dev-server'
+
+const server = createHmrDevServer({
+  port: 5174,
+  watchRoots: ['pages', 'src'],
+  debounceMs: 300,
+  compile: (files) => files.filter((f) => f.endsWith('.vue')).map((f) => ({
+    id: ++id, file: relative(root, f), type: 'vue', action: 'update', timestamp: Date.now(),
+    code: compileVueSfc(readFileSync(f, 'utf-8')).js, // 单文件增量编译
+  })),
+  onEvent: (e) => console.log('[hmr]', e.type),
+})
+await server.start() // WS 监听 + watch 启动
+```
+
+## 子路径：`@proteus-vue/hmr/cdp`（G-34 M2：DevTools 桥接）
+
+| API | 说明 |
+|-----|------|
+| `createCdpBridge(options)` | **CDP 桥接**：处理 CDP 命令子集（`Runtime.enable/disable/evaluate` + `Proteus.enable/disable/getStyleGates` 自定义域，未知方法 -32601）+ Proteus 事件（TraceBus trace / HMR hmr / style-gate）→ CDP 消息转译（`Runtime.consoleAPICalled` + 结构化 `Proteus.event` / `Proteus.styleGate`）；`styleGateBufferSize` 环形缓冲（`Proteus.getStyleGates` 查询）；注入式（transport/subscribe/evaluate） |
+
+```ts
+import { createCdpBridge } from '@proteus-vue/hmr/cdp'
+
+const bridge = createCdpBridge({
+  transport: { send: (m) => ws.send(JSON.stringify(m)) }, // CDP 客户端通道
+  evaluate: async (expr) => (0, eval)(expr),             // Runtime.evaluate
+})
+bridge.handleMessage({ id: 1, method: 'Runtime.enable' })
+bridge.push({ kind: 'trace', event: traceEvent })        // TraceBus 事件接入
+bridge.push({ kind: 'style-gate', record: gateRecord })  // Style Gate 可视化
+```
+
+## 子路径：`@proteus-vue/hmr/style-gate`（G-34 M2：Style Safety 可视化数据源）
+
+| API | 说明 |
+|-----|------|
+| `collectStyleGateRecords(style, options)` | **样式闸门链可视化**：每条样式经 白名单 → 校验 → 平台收窄 三道闸门的完整轨迹（`StyleGateRecord { gates, decision: pass\|narrow\|drop, nativeValues, rejectReason }`）；`allPlatforms` 产出五端原生值映射（联动 `@proteus-vue/runtime/style-safety`） |
+
+```ts
+import { collectStyleGateRecords } from '@proteus-vue/hmr/style-gate'
+
+const records = collectStyleGateRecords({ width: '100px', display: 'flex' }, { platform: 'skyline', allPlatforms: true })
+// width  → decision: 'narrow'，nativeValues.skyline = 100（px → 数值）
+// display→ decision: 'drop'，rejectReason 含 STS004（FORBIDDEN）
+```
+
+★生产接入参考 `examples/scripts/dev-mp.ts`（dev-mp 已内置 HMR dev server：改 .vue → compileVueSfc 增量 → WS 广播，E2E 实测闭环通过）。
+
+## 类型
+
+- `HmrPayload`：`{ id, file, type: 'vue'|'js'|'css'|'asset'|'native-binding', code?, timestamp, action: 'update'|'reload' }`——一次增量更新的传输单元
+- `HmrEvent`：可观测事件（connected/disconnected/reconnecting/payload/apply/rule/error）——**原则 #3 编译透明的 DevTools 数据源**
+- `HmrTransport` / `HmrWebSocketLike` / `SafeReload`：结构类型，注入式零硬依赖
+
+## 严格规则
+
+| 编号 | 规则 | 处理 |
+|------|------|------|
+| HMR001 | 替换前存在未清理的模块实例（副作用未 dispose） | warn（`checkSideEffects` 可关） |
+| HMR002 | 原生 binding 变更无法热替换 | 自动安全 reload |
+| HMR003 | 状态丢失检测（reload/应用失败/缺 code） | warn + 降级安全 reload（`checkStateLoss` 可关） |
+
+## 使用
+
+```ts
+import { createHmrRuntime, createHmrClient, createSafeReload } from '@proteus-vue/hmr'
+
+// 1. 运行时（模块应用器 + 安全 reload + 可观测）
+const runtime = createHmrRuntime({
+  applyModule(file, code) {
+    // vue/js：应用新模块（Vite import.meta.hot / 编译产物替换）
+    return applyVueModule(file, code) // 失败返回 false → 自动降级安全 reload
+  },
+  reload: safeReload.reload,
+  onEvent: (e) => console.log('[hmr]', e), // DevTools 面板数据源
+})
+
+// 2. Dev Server 推送 → WS 客户端（自动重连）
+const client = createHmrClient({
+  url: 'ws://localhost:5174/__proteus_hmr__',
+  runtime,
+})
+client.connect()
+```
+
+## 性能预算（G-34 §6）
+
+| 指标 | 预算 | 现状 |
+|------|------|------|
+| HMR 编译耗时 | < 50ms | 🔶 编译侧增量未落地（dev-mp 全量重建 + M8 缓存） |
+| 推送到渲染 | < 100ms | ✅ 1000 payload 批量应用实测 < 100ms（单测基准断言） |
+| 安全 reload | < 2s | 🔶 未验证（Web 实现为 location.reload） |
+| DevTools 开销 | < 5% CPU | 🔶 M2 面板未落地 |
+
+**运行时侧已做优化**：批量 payload 同文件合并（一次保存多文件变更 → 只保留最终状态，中间态丢弃）+ 乱序 batch 按 id 全局排序 + 单条消息可带 payload 数组（client 自动走 `applyBatch`）。
+
+## 后续里程碑
+
+- **M2** DevTools 桥接（CDP + Style Safety 可视化）
+- **M3** 原生侧安全 reload（iOS/Android/鸿蒙，联动 App Renderer + Router G-32）
+- **M4** 原生视图检查器 + LeakRegistry 集成

package/dist/cdp/index.d.ts

@@ -0,0 +1,63 @@
+import type { HmrEvent } from '../types';
+import type { StyleGateRecord } from '../style-gate';
+/** TraceBus 事件形状（结构类型：@proteus-vue/devtools-runtime 的 TraceEvent 天然符合） */
+export interface TraceEventLike {
+    source: string;
+    phase: string;
+    name: string;
+    payload?: unknown;
+    timestamp: number;
+    traceId?: string;
+}
+/** Proteus 开发事件（桥接输入：trace / hmr / style-gate 三类） */
+export type ProteusDevEvent = {
+    kind: 'trace';
+    event: TraceEventLike;
+} | {
+    kind: 'hmr';
+    event: HmrEvent;
+} | {
+    kind: 'style-gate';
+    record: StyleGateRecord;
+};
+/** CDP 消息（标准 JSON-RPC 形状：请求/响应 { id } / 事件推送 { method, params } 无 id） */
+export interface CdpMessage {
+    id?: number;
+    method?: string;
+    params?: Record<string, unknown>;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+/** CDP 客户端传输（注入：WS / 内存通道均可） */
+export interface CdpTransport {
+    send(message: CdpMessage): void;
+}
+export interface CdpBridgeOptions {
+    /** 客户端传输 */
+    transport: CdpTransport;
+    /** Runtime.evaluate 执行器（缺省拒绝——未注入时返回 error） */
+    evaluate?: (expression: string) => Promise<unknown>;
+    /** ★应用信息提供器（Proteus.appInfo 命令——面板 pages/依赖图数据；缺省返回空对象） */
+    appInfo?: () => unknown;
+    /** StyleGateRecord 环形缓冲上限（缺省 500；Proteus.getStyleGates 查询用） */
+    styleGateBufferSize?: number;
+    /** 可观测（桥接自身事件：client 命令/推送） */
+    onEvent?: (event: {
+        type: 'command' | 'push';
+        method: string;
+    }) => void;
+}
+export interface CdpBridge {
+    /** 处理客户端一条命令（响应经 transport.send 回发） */
+    handleMessage(message: CdpMessage): void;
+    /** 推送 Proteus 事件（按客户端 enable 状态转 CDP 消息） */
+    push(event: ProteusDevEvent): void;
+    /** 查询已收集的 StyleGateRecord 缓冲 */
+    styleGates(): StyleGateRecord[];
+    readonly runtimeEnabled: boolean;
+    readonly proteusEnabled: boolean;
+}
+export declare function createCdpBridge(options: CdpBridgeOptions): CdpBridge;

package/dist/cdp/index.js

@@ -0,0 +1,109 @@
+// src/cdp/index.ts
+function createCdpBridge(options) {
+  const { transport, onEvent } = options;
+  const evaluate = options.evaluate ?? (() => Promise.reject(new Error("Runtime.evaluate \u672A\u6CE8\u5165\u6267\u884C\u5668")));
+  const bufferSize = options.styleGateBufferSize ?? 500;
+  let runtimeEnabled = false;
+  let proteusEnabled = false;
+  const gateBuffer = [];
+  function reply(id, result) {
+    if (id === void 0) return;
+    transport.send({ id, result });
+  }
+  function replyError(id, code, message) {
+    if (id === void 0) return;
+    transport.send({ id, error: { code, message } });
+  }
+  function handleMessage(message) {
+    const { id, method } = message;
+    if (!method) {
+      replyError(id, -32600, "Invalid Request\uFF1A\u7F3A method");
+      return;
+    }
+    onEvent?.({ type: "command", method });
+    switch (method) {
+      case "Runtime.enable":
+        runtimeEnabled = true;
+        reply(id, {});
+        return;
+      case "Runtime.disable":
+        runtimeEnabled = false;
+        reply(id, {});
+        return;
+      case "Proteus.enable":
+        proteusEnabled = true;
+        reply(id, {});
+        return;
+      case "Proteus.disable":
+        proteusEnabled = false;
+        reply(id, {});
+        return;
+      case "Runtime.evaluate": {
+        const expression = String(message.params?.expression ?? "");
+        void evaluate(expression).then((value) => reply(id, { result: { type: "string", value: JSON.stringify(value) } })).catch((err) => replyError(id, -32e3, String(err instanceof Error ? err.message : err)));
+        return;
+      }
+      case "Proteus.getStyleGates":
+        reply(id, { records: gateBuffer });
+        return;
+      case "Proteus.appInfo":
+        reply(id, options.appInfo ? options.appInfo() : {});
+        return;
+      default:
+        replyError(id, -32601, `Method not found: ${method}`);
+    }
+  }
+  function push(event) {
+    if (event.kind === "style-gate") {
+      const record = event.record;
+      gateBuffer.push(record);
+      if (gateBuffer.length > bufferSize) gateBuffer.splice(0, gateBuffer.length - bufferSize);
+      if (proteusEnabled) {
+        onEvent?.({ type: "push", method: "Proteus.styleGate" });
+        transport.send({ method: "Proteus.styleGate", params: { record } });
+      }
+      return;
+    }
+    const source = event.kind === "trace" ? event.event.source : "hmr";
+    const name = event.kind === "trace" ? event.event.name : event.event.type;
+    const timestamp = event.kind === "trace" ? event.event.timestamp : Date.now();
+    if (runtimeEnabled) {
+      onEvent?.({ type: "push", method: "Runtime.consoleAPICalled" });
+      transport.send({
+        method: "Runtime.consoleAPICalled",
+        params: {
+          type: "info",
+          args: [{ type: "string", value: `[${source}] ${name}` }],
+          timestamp
+        }
+      });
+    }
+    if (proteusEnabled) {
+      onEvent?.({ type: "push", method: "Proteus.event" });
+      transport.send({
+        method: "Proteus.event",
+        params: {
+          source,
+          name,
+          phase: event.kind === "trace" ? event.event.phase : void 0,
+          payload: event.kind === "trace" ? event.event.payload : event.event,
+          timestamp
+        }
+      });
+    }
+  }
+  return {
+    handleMessage,
+    push,
+    styleGates: () => gateBuffer,
+    get runtimeEnabled() {
+      return runtimeEnabled;
+    },
+    get proteusEnabled() {
+      return proteusEnabled;
+    }
+  };
+}
+export {
+  createCdpBridge
+};

package/dist/client.d.ts

@@ -0,0 +1,37 @@
+import type { HmrEvent } from './types';
+import type { HmrRuntime } from './runtime';
+/** WebSocket 形状（结构类型：原生 WebSocket / mock 均可注入） */
+export interface HmrWebSocketLike {
+    onopen: (() => void) | null;
+    onmessage: ((ev: {
+        data: unknown;
+    }) => void) | null;
+    onclose: ((ev: {
+        code?: number;
+        reason?: string;
+    }) => void) | null;
+    onerror: (() => void) | null;
+    close(): void;
+}
+export interface HmrClientOptions {
+    /** Dev Server WebSocket 地址（如 ws://localhost:5174/__proteus_hmr__） */
+    url: string;
+    runtime: HmrRuntime;
+    /** WebSocket 工厂（注入可单测；缺省 new WebSocket(url)） */
+    createSocket?: (url: string) => HmrWebSocketLike;
+    /** 重连：maxAttempts（缺省 -1 无限）+ baseDelayMs（指数退避 baseDelayMs * 2^attempt，缺省 500） */
+    reconnect?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+    };
+    onEvent?: (event: HmrEvent) => void;
+}
+export interface HmrClient {
+    connect(): void;
+    disconnect(): void;
+    /** 当前是否已连接 */
+    readonly connected: boolean;
+    /** 已尝试的重连次数 */
+    readonly attempt: number;
+}
+export declare function createHmrClient(options: HmrClientOptions): HmrClient;

package/dist/dev-server/index.d.ts

@@ -0,0 +1,66 @@
+import type { HmrPayload } from '../types';
+/** Dev Server 可观测事件（原则 #3 编译透明：编译→推送全链路可见） */
+export type HmrDevServerEvent = {
+    type: 'listening';
+    port: number;
+} | {
+    type: 'client-connect';
+    clientCount: number;
+} | {
+    type: 'client-disconnect';
+    clientCount: number;
+} | {
+    type: 'files-changed';
+    files: string[];
+} | {
+    type: 'compiled';
+    payloads: HmrPayload[];
+} | {
+    type: 'broadcast';
+    payloads: HmrPayload[];
+} | {
+    type: 'error';
+    message: string;
+};
+export interface HmrDevServerOptions {
+    /** WS 监听端口（0 = 随机） */
+    port: number;
+    /** WS 监听主机（缺省 127.0.0.1——开发工具本机服务；★显式 IPv4 避免双栈 `::` 绑定下 IPv4 连接不达） */
+    host?: string;
+    /** 监听根目录（文件变更触发增量编译 + 广播） */
+    watchRoots: string[];
+    /** 忽略规则（返回 true 跳过；缺省忽略 node_modules/dist/.git 与隐藏文件） */
+    ignore?: (file: string) => boolean;
+    /** 防抖毫秒（缺省 300——一次保存的多文件变更合并为一批） */
+    debounceMs?: number;
+    /** ★增量编译回调：变更文件集合 → 增量 payload（编译侧注入） */
+    compile: (files: string[]) => HmrPayload[];
+    /** ★DevTools 面板 CDP 桥：Runtime.evaluate 执行器（可选——未注入时面板 evaluate 返回错误） */
+    evaluate?: (expression: string) => Promise<unknown>;
+    /** ★DevTools 面板 CDP 桥：应用信息提供器（Proteus.appInfo 命令——面板 pages/依赖图数据源；缺省返回空对象） */
+    appInfo?: () => unknown;
+    /** 外部 TraceBus 事件注入（可选——面板 Proteus.event 通道数据源） */
+    traceSource?: () => Array<{
+        source: string;
+        phase: string;
+        name: string;
+        payload?: unknown;
+        timestamp: number;
+        traceId?: string;
+    }>;
+    /** 可观测 */
+    onEvent?: (event: HmrDevServerEvent) => void;
+}
+export interface HmrDevServer {
+    /** 启动（WS 监听 + watch） */
+    start(): Promise<void>;
+    /** 停止（关闭 WS + 解绑 watch） */
+    close(): Promise<void>;
+    /** 手动广播 payload（不经过编译管线） */
+    broadcast(payloads: HmrPayload[]): void;
+    /** WS 端口 */
+    readonly port: number;
+    /** 当前连接客户端数 */
+    readonly clientCount: number;
+}
+export declare function createHmrDevServer(options: HmrDevServerOptions): HmrDevServer;

package/dist/dev-server/index.js

@@ -0,0 +1,263 @@
+// src/dev-server/index.ts
+import fs from "node:fs";
+import path from "node:path";
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/cdp/index.ts
+function createCdpBridge(options) {
+  const { transport, onEvent } = options;
+  const evaluate = options.evaluate ?? (() => Promise.reject(new Error("Runtime.evaluate \u672A\u6CE8\u5165\u6267\u884C\u5668")));
+  const bufferSize = options.styleGateBufferSize ?? 500;
+  let runtimeEnabled = false;
+  let proteusEnabled = false;
+  const gateBuffer = [];
+  function reply(id, result) {
+    if (id === void 0) return;
+    transport.send({ id, result });
+  }
+  function replyError(id, code, message) {
+    if (id === void 0) return;
+    transport.send({ id, error: { code, message } });
+  }
+  function handleMessage(message) {
+    const { id, method } = message;
+    if (!method) {
+      replyError(id, -32600, "Invalid Request\uFF1A\u7F3A method");
+      return;
+    }
+    onEvent?.({ type: "command", method });
+    switch (method) {
+      case "Runtime.enable":
+        runtimeEnabled = true;
+        reply(id, {});
+        return;
+      case "Runtime.disable":
+        runtimeEnabled = false;
+        reply(id, {});
+        return;
+      case "Proteus.enable":
+        proteusEnabled = true;
+        reply(id, {});
+        return;
+      case "Proteus.disable":
+        proteusEnabled = false;
+        reply(id, {});
+        return;
+      case "Runtime.evaluate": {
+        const expression = String(message.params?.expression ?? "");
+        void evaluate(expression).then((value) => reply(id, { result: { type: "string", value: JSON.stringify(value) } })).catch((err) => replyError(id, -32e3, String(err instanceof Error ? err.message : err)));
+        return;
+      }
+      case "Proteus.getStyleGates":
+        reply(id, { records: gateBuffer });
+        return;
+      case "Proteus.appInfo":
+        reply(id, options.appInfo ? options.appInfo() : {});
+        return;
+      default:
+        replyError(id, -32601, `Method not found: ${method}`);
+    }
+  }
+  function push(event) {
+    if (event.kind === "style-gate") {
+      const record = event.record;
+      gateBuffer.push(record);
+      if (gateBuffer.length > bufferSize) gateBuffer.splice(0, gateBuffer.length - bufferSize);
+      if (proteusEnabled) {
+        onEvent?.({ type: "push", method: "Proteus.styleGate" });
+        transport.send({ method: "Proteus.styleGate", params: { record } });
+      }
+      return;
+    }
+    const source = event.kind === "trace" ? event.event.source : "hmr";
+    const name = event.kind === "trace" ? event.event.name : event.event.type;
+    const timestamp = event.kind === "trace" ? event.event.timestamp : Date.now();
+    if (runtimeEnabled) {
+      onEvent?.({ type: "push", method: "Runtime.consoleAPICalled" });
+      transport.send({
+        method: "Runtime.consoleAPICalled",
+        params: {
+          type: "info",
+          args: [{ type: "string", value: `[${source}] ${name}` }],
+          timestamp
+        }
+      });
+    }
+    if (proteusEnabled) {
+      onEvent?.({ type: "push", method: "Proteus.event" });
+      transport.send({
+        method: "Proteus.event",
+        params: {
+          source,
+          name,
+          phase: event.kind === "trace" ? event.event.phase : void 0,
+          payload: event.kind === "trace" ? event.event.payload : event.event,
+          timestamp
+        }
+      });
+    }
+  }
+  return {
+    handleMessage,
+    push,
+    styleGates: () => gateBuffer,
+    get runtimeEnabled() {
+      return runtimeEnabled;
+    },
+    get proteusEnabled() {
+      return proteusEnabled;
+    }
+  };
+}
+
+// src/dev-server/index.ts
+function defaultIgnore(file) {
+  const name = path.basename(file);
+  if (name.startsWith(".")) return true;
+  return /(^|[\\/])(node_modules|dist|\.git)([\\/]|$)/.test(file);
+}
+function createHmrDevServer(options) {
+  const { port, watchRoots, compile, onEvent } = options;
+  const host = options.host ?? "127.0.0.1";
+  const debounceMs = options.debounceMs ?? 300;
+  const ignore = options.ignore ?? defaultIgnore;
+  let wss = null;
+  const watchers = [];
+  const clients = /* @__PURE__ */ new Set();
+  const bridges = /* @__PURE__ */ new Map();
+  let timer = null;
+  const pendingFiles = /* @__PURE__ */ new Set();
+  function emit(event) {
+    onEvent?.(event);
+  }
+  function pushBridges(devEvent) {
+    for (const bridge of bridges.values()) bridge.push(devEvent);
+  }
+  function pushTraceEvents() {
+    const traces = options.traceSource?.();
+    if (!traces) return;
+    for (const t of traces) {
+      pushBridges({ kind: "trace", event: t });
+    }
+  }
+  function flush() {
+    timer = null;
+    const files = Array.from(pendingFiles).filter((f) => {
+      try {
+        return fs.existsSync(f) && fs.statSync(f).isFile();
+      } catch {
+        return false;
+      }
+    });
+    pendingFiles.clear();
+    if (files.length === 0) return;
+    emit({ type: "files-changed", files });
+    pushBridges({ kind: "trace", event: { source: "compiler", phase: "start", name: "watch files", payload: { count: files.length }, timestamp: Date.now() } });
+    let payloads;
+    try {
+      payloads = compile(files);
+    } catch (err) {
+      emit({ type: "error", message: `\u589E\u91CF\u7F16\u8BD1\u5931\u8D25\uFF1A${String(err)}` });
+      return;
+    }
+    if (payloads.length === 0) return;
+    emit({ type: "compiled", payloads });
+    pushBridges({ kind: "trace", event: { source: "compiler", phase: "end", name: "incremental compile", payload: { count: payloads.length }, timestamp: Date.now() } });
+    broadcast(payloads);
+  }
+  function schedule(file) {
+    if (ignore(file)) return;
+    pendingFiles.add(file);
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(flush, debounceMs);
+  }
+  function watchRoot(dir) {
+    if (!fs.existsSync(dir)) return;
+    try {
+      const watcher = fs.watch(dir, { recursive: true }, (_ev, file) => {
+        if (file) schedule(path.join(dir, file.toString()));
+      });
+      watchers.push(watcher);
+    } catch {
+    }
+  }
+  function broadcast(payloads) {
+    emit({ type: "broadcast", payloads });
+    pushBridges({ kind: "trace", event: { source: "hmr", phase: "point", name: "hmr broadcast", payload: { count: payloads.length }, timestamp: Date.now() } });
+    const data = JSON.stringify(payloads.length === 1 ? payloads[0] : payloads);
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) client.send(data);
+    }
+  }
+  return {
+    get port() {
+      const addr = wss?.address();
+      return typeof addr === "object" && addr !== null ? addr.port : options.port;
+    },
+    get clientCount() {
+      return clients.size;
+    },
+    async start() {
+      if (wss) return;
+      wss = new WebSocketServer({ port, host });
+      wss.on("connection", (socket) => {
+        clients.add(socket);
+        emit({ type: "client-connect", clientCount: clients.size });
+        const bridge = createCdpBridge({
+          transport: {
+            send: (m) => {
+              if (socket.readyState === WebSocket.OPEN) socket.send(JSON.stringify(m));
+            }
+          },
+          evaluate: options.evaluate,
+          appInfo: options.appInfo
+        });
+        bridges.set(socket, bridge);
+        socket.on("message", (data) => {
+          try {
+            const msg = JSON.parse(String(data));
+            if (msg && typeof msg === "object" && "method" in msg) bridge.handleMessage(msg);
+          } catch {
+          }
+        });
+        socket.on("close", () => {
+          clients.delete(socket);
+          bridges.delete(socket);
+          emit({ type: "client-disconnect", clientCount: clients.size });
+        });
+        pushTraceEvents();
+      });
+      await new Promise((resolve) => {
+        wss?.once("listening", () => {
+          emit({ type: "listening", port });
+          resolve();
+        });
+      });
+      for (const root of watchRoots) {
+        if (fs.existsSync(root)) watchRoot(root);
+      }
+    },
+    async close() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      pendingFiles.clear();
+      for (const watcher of watchers) watcher.close();
+      watchers.length = 0;
+      for (const client of clients) client.close();
+      clients.clear();
+      if (wss) {
+        await new Promise((resolve) => {
+          wss?.close(() => resolve());
+          setTimeout(() => resolve(), 100);
+        });
+        wss = null;
+      }
+    },
+    broadcast
+  };
+}
+export {
+  createHmrDevServer
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { HmrEvent, HmrPayload, HmrTransport, SafeReload } from './types';
+export { createHmrRuntime } from './runtime';
+export type { HmrRuntime, HmrRuntimeOptions, HmrBatchResult } from './runtime';
+export { createVueHotAdapter } from './vue-adapter';
+export type { VueHotAdapter, VueHotAdapterOptions, VueHotApiLike } from './vue-adapter';
+export { createHmrClient } from './client';
+export type { HmrClient, HmrClientOptions, HmrWebSocketLike } from './client';
+export { createSafeReload } from './safe-reload';
+export type { SafeReloadOptions } from './safe-reload';

package/dist/index.js

@@ -0,0 +1,273 @@
+// src/runtime.ts
+function createHmrRuntime(options) {
+  const { applyModule, reload, onEvent } = options;
+  const checkSideEffects = options.checkSideEffects !== false;
+  const checkStateLoss = options.checkStateLoss !== false;
+  let lastId = -1;
+  const snapshots = /* @__PURE__ */ new Map();
+  const applied = /* @__PURE__ */ new Set();
+  function emit(event) {
+    onEvent?.(event);
+  }
+  function apply(payload) {
+    if (payload.id <= lastId) {
+      emit({ type: "apply", file: payload.file, result: "skipped" });
+      return;
+    }
+    lastId = payload.id;
+    emit({ type: "payload", payload });
+    if (payload.action === "reload") {
+      if (checkStateLoss && snapshots.has(payload.file)) {
+        emit({ type: "rule", rule: "HMR003", file: payload.file, message: "reload \u524D\u5B58\u5728\u672A\u6062\u590D\u72B6\u6001\u5FEB\u7167\u2014\u2014\u72B6\u6001\u5C06\u4E22\u5931" });
+      }
+      emit({ type: "apply", file: payload.file, result: "reload" });
+      reload();
+      return;
+    }
+    switch (payload.type) {
+      case "vue":
+      case "js": {
+        if (!payload.code) {
+          emit({ type: "rule", rule: "HMR003", file: payload.file, message: "payload \u7F3A code\u2014\u2014\u65E0\u6CD5\u70ED\u66FF\u6362\uFF0C\u964D\u7EA7\u5B89\u5168 reload" });
+          emit({ type: "apply", file: payload.file, result: "reload" });
+          reload();
+          return;
+        }
+        let ok = false;
+        try {
+          ok = applyModule(payload.file, payload.code);
+        } catch (err) {
+          emit({ type: "error", file: payload.file, message: `\u6A21\u5757\u5E94\u7528\u5F02\u5E38\uFF1A${String(err)}` });
+        }
+        if (ok) {
+          applied.add(payload.file);
+          emit({ type: "apply", file: payload.file, result: "ok" });
+        } else {
+          emit({ type: "rule", rule: "HMR003", file: payload.file, message: "\u6A21\u5757\u5E94\u7528\u5931\u8D25\u2014\u2014\u72B6\u6001\u65E0\u6CD5\u4FDD\u7559\uFF0C\u964D\u7EA7\u5B89\u5168 reload" });
+          emit({ type: "apply", file: payload.file, result: "reload" });
+          reload();
+        }
+        return;
+      }
+      case "native-binding": {
+        emit({ type: "rule", rule: "HMR002", file: payload.file, message: "\u539F\u751F binding \u53D8\u66F4\u2014\u2014\u89E6\u53D1\u5B89\u5168 reload" });
+        emit({ type: "apply", file: payload.file, result: "reload" });
+        reload();
+        return;
+      }
+      case "css":
+      case "asset": {
+        applied.add(payload.file);
+        emit({ type: "apply", file: payload.file, result: "ok" });
+        return;
+      }
+      default: {
+        emit({ type: "apply", file: payload.file, result: "skipped" });
+      }
+    }
+  }
+  function applyBatch(payloads) {
+    const latest = /* @__PURE__ */ new Map();
+    let merged = 0;
+    for (const p of payloads) {
+      if (latest.has(p.file)) merged += 1;
+      latest.set(p.file, p);
+    }
+    const ordered = Array.from(latest.values()).sort((a, b) => a.id - b.id);
+    let appliedCount = 0;
+    for (const p of ordered) {
+      const before = lastId;
+      apply(p);
+      if (lastId !== before) appliedCount += 1;
+    }
+    return { total: payloads.length, merged, applied: appliedCount };
+  }
+  function snapshotState(file, state) {
+    if (checkSideEffects && snapshots.has(file)) {
+      emit({ type: "rule", rule: "HMR001", file, message: "\u66FF\u6362\u524D\u5B58\u5728\u672A\u6E05\u7406\u7684\u6A21\u5757\u5B9E\u4F8B\uFF08\u526F\u4F5C\u7528\u672A dispose\uFF09" });
+    }
+    snapshots.set(file, state);
+  }
+  function restoreState(file) {
+    const state = snapshots.get(file);
+    snapshots.delete(file);
+    return state;
+  }
+  function reset() {
+    snapshots.clear();
+    applied.clear();
+    lastId = -1;
+  }
+  return {
+    apply,
+    applyBatch,
+    snapshotState,
+    restoreState,
+    appliedFiles: () => Array.from(applied),
+    reset,
+    get lastAppliedId() {
+      return lastId;
+    }
+  };
+}
+
+// src/vue-adapter.ts
+function createVueHotAdapter(options) {
+  const getHot = options.getHot ?? (() => void 0);
+  const { runtime, file } = options;
+  return {
+    get enabled() {
+      return getHot() !== void 0;
+    },
+    accept(cb) {
+      const hot = getHot();
+      if (!hot) return;
+      hot.accept(() => {
+        cb?.();
+      });
+    },
+    dispose(snapshot) {
+      const hot = getHot();
+      if (!hot) return;
+      hot.dispose(() => {
+        runtime.snapshotState(file, snapshot());
+      });
+    },
+    applyWithState(snapshot, restore) {
+      const hot = getHot();
+      if (!hot) return;
+      hot.dispose(() => {
+        runtime.snapshotState(file, snapshot());
+      });
+      hot.accept(() => {
+        const state = runtime.restoreState(file);
+        restore(state ?? {});
+      });
+    },
+    invalidate() {
+      const hot = getHot();
+      if (!hot) return;
+      hot.invalidate();
+    }
+  };
+}
+
+// src/client.ts
+function createHmrClient(options) {
+  const { url, runtime, onEvent } = options;
+  const createSocket = options.createSocket ?? ((u) => new WebSocket(u));
+  const maxAttempts = options.reconnect?.maxAttempts ?? -1;
+  const baseDelayMs = options.reconnect?.baseDelayMs ?? 500;
+  let socket = null;
+  let isOpen = false;
+  let closedByUser = false;
+  let attempt = 0;
+  let reconnectTimer = null;
+  function emit(event) {
+    onEvent?.(event);
+  }
+  function open() {
+    let sock;
+    try {
+      sock = createSocket(url);
+    } catch (err) {
+      emit({ type: "error", message: `WebSocket \u521B\u5EFA\u5931\u8D25\uFF1A${String(err)}` });
+      scheduleReconnect();
+      return;
+    }
+    socket = sock;
+    sock.onopen = () => {
+      attempt = 0;
+      isOpen = true;
+      emit({ type: "connected" });
+    };
+    sock.onmessage = (ev) => {
+      try {
+        const data = JSON.parse(String(ev.data));
+        if (Array.isArray(data)) runtime.applyBatch(data);
+        else runtime.apply(data);
+      } catch (err) {
+        emit({ type: "error", message: `payload \u89E3\u6790\u5931\u8D25\uFF1A${String(err)}` });
+      }
+    };
+    sock.onclose = (ev) => {
+      isOpen = false;
+      emit({ type: "disconnected", reason: ev.reason });
+      if (!closedByUser) scheduleReconnect();
+    };
+    sock.onerror = () => {
+    };
+  }
+  function scheduleReconnect() {
+    if (closedByUser) return;
+    if (maxAttempts >= 0 && attempt >= maxAttempts) {
+      emit({ type: "error", message: `\u91CD\u8FDE\u8D85\u8FC7\u6700\u5927\u6B21\u6570\uFF08${maxAttempts}\uFF09` });
+      return;
+    }
+    const delayMs = baseDelayMs * 2 ** attempt;
+    attempt += 1;
+    emit({ type: "reconnecting", attempt, delayMs });
+    reconnectTimer = setTimeout(() => {
+      open();
+    }, delayMs);
+  }
+  return {
+    connect() {
+      closedByUser = false;
+      isOpen = false;
+      open();
+    },
+    disconnect() {
+      closedByUser = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      socket?.close();
+      socket = null;
+      isOpen = false;
+    },
+    get connected() {
+      return isOpen;
+    },
+    get attempt() {
+      return attempt;
+    }
+  };
+}
+
+// src/safe-reload.ts
+function createSafeReload(options = {}) {
+  const storage = options.storage !== void 0 ? options.storage : typeof sessionStorage !== "undefined" ? sessionStorage : null;
+  const storageKey = options.storageKey ?? "__proteus_hmr_state__";
+  const reloadPage = options.reloadPage ?? (() => location.reload());
+  const collect = options.collect ?? (() => ({ url: location.pathname + location.search }));
+  return {
+    saveState() {
+      const state = collect();
+      if (storage) storage.set(storageKey, JSON.stringify(state));
+      return state;
+    },
+    restoreState(state) {
+      if (state) return state;
+      if (!storage) return void 0;
+      const raw = storage.get(storageKey);
+      if (!raw) return void 0;
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return void 0;
+      }
+    },
+    reload() {
+      this.saveState();
+      reloadPage();
+    }
+  };
+}
+export {
+  createHmrClient,
+  createHmrRuntime,
+  createSafeReload,
+  createVueHotAdapter
+};

package/dist/runtime.d.ts

@@ -0,0 +1,39 @@
+import type { HmrEvent, HmrPayload, SafeReload } from './types';
+export interface HmrRuntimeOptions {
+    /** 模块应用器：vue/js 新代码 → 是否应用成功（false/抛错 → 安全 reload 兜底） */
+    applyModule: (file: string, code: string) => boolean;
+    /** 安全 reload（HMR002：native-binding 变更 / action=reload / 应用失败兜底） */
+    reload: SafeReload['reload'];
+    /** 可观测回调（原则 #3：HMR 过程可见） */
+    onEvent?: (event: HmrEvent) => void;
+    /** HMR001 规则开关（副作用未清理检测，默认开） */
+    checkSideEffects?: boolean;
+    /** HMR003 规则开关（状态丢失检测，默认开） */
+    checkStateLoss?: boolean;
+}
+export interface HmrRuntime {
+    /** 应用一个 payload（幂等；按 id 防乱序/重复） */
+    apply(payload: HmrPayload): void;
+    /** 批量应用（★性能优化）：同文件合并只保留最终状态 + 按 id 排序后逐个 apply */
+    applyBatch(payloads: HmrPayload[]): HmrBatchResult;
+    /** 模块替换前状态快照（dispose 回调中调用）；前一个实例未恢复时触发 HMR001 */
+    snapshotState(file: string, state: Record<string, unknown>): void;
+    /** 新模块挂载时恢复状态（返回快照；无快照返回 undefined） */
+    restoreState(file: string): Record<string, unknown> | undefined;
+    /** 已应用模块文件列表 */
+    appliedFiles(): string[];
+    /** 重置（断开连接/会话结束时） */
+    reset(): void;
+    /** 最近应用 payload id */
+    readonly lastAppliedId: number;
+}
+/** 批量应用结果（★性能可观测） */
+export interface HmrBatchResult {
+    /** 输入 payload 总数 */
+    total: number;
+    /** 同文件合并丢弃数（只保留最终状态） */
+    merged: number;
+    /** 实际应用数 */
+    applied: number;
+}
+export declare function createHmrRuntime(options: HmrRuntimeOptions): HmrRuntime;

package/dist/safe-reload.d.ts

@@ -0,0 +1,15 @@
+import type { SafeReload } from './types';
+export interface SafeReloadOptions {
+    /** 状态收集器（缺省：location 快照；M3 原生侧：Router G-32 栈序列化 + 页面状态） */
+    collect?: () => Record<string, unknown>;
+    /** 存储（缺省 sessionStorage；可注入 mock 单测） */
+    storage?: {
+        get(key: string): string | null;
+        set(key: string, value: string): void;
+    } | null;
+    /** 页面刷新（缺省 location.reload；可注入） */
+    reloadPage?: () => void;
+    /** 存储键（缺省 __proteus_hmr_state__） */
+    storageKey?: string;
+}
+export declare function createSafeReload(options?: SafeReloadOptions): SafeReload;

package/dist/style-gate/index.d.ts

@@ -0,0 +1,29 @@
+import type { StylePlatform } from '@proteus-vue/runtime/style-safety';
+export type StyleGateName = 'whitelist' | 'validator' | 'narrowing';
+/** 单条闸门判定 */
+export interface StyleGateStep {
+    gate: StyleGateName;
+    decision: 'pass' | 'reject' | 'narrow';
+    detail: string;
+}
+/** 样式闸门记录（可视化单元） */
+export interface StyleGateRecord {
+    prop: string;
+    value: unknown;
+    /** 闸门链判定轨迹 */
+    gates: StyleGateStep[];
+    /** 最终决策：pass（原样）/ narrow（平台值映射）/ drop（拒绝丢弃） */
+    decision: 'pass' | 'narrow' | 'drop';
+    /** narrow 时的各端原生值映射 */
+    nativeValues?: Partial<Record<StylePlatform, unknown>>;
+    /** drop 时的拒绝原因 */
+    rejectReason?: string;
+}
+export interface CollectStyleGateOptions {
+    /** 收窄平台（缺省 'web'——单平台决策链） */
+    platform?: StylePlatform;
+    /** 是否同时产出全部平台原生值映射（allPlatforms 时 nativeValues 全量五端） */
+    allPlatforms?: boolean;
+}
+/** 样式对象 → 闸门记录[]（每 prop 一条完整决策链） */
+export declare function collectStyleGateRecords(style: Record<string, unknown>, options?: CollectStyleGateOptions): StyleGateRecord[];

package/dist/style-gate/index.js

@@ -0,0 +1,55 @@
+// src/style-gate/index.ts
+import { ALLOWED_STYLE_PROPS, validateProp, narrowValue } from "@proteus-vue/runtime/style-safety";
+var ALL_PLATFORMS = ["web", "skyline", "ios", "android", "harmony"];
+function whitelistReason(prop, level) {
+  if (level === "SEMANTIC_ONLY") return `${prop} \u5FC5\u987B\u7528 p-* \u8BED\u4E49\u7EC4\u4EF6\uFF08STS003\uFF09`;
+  if (level === "FORBIDDEN") return `${prop} \u5DF2\u7981\u7528\uFF08STS004\uFF09`;
+  return `${prop} \u4E0D\u5728\u6837\u5F0F\u767D\u540D\u5355\uFF08STS001\uFF09`;
+}
+function collectStyleGateRecords(style, options = {}) {
+  const platform = options.platform ?? "web";
+  const records = [];
+  for (const [prop, value] of Object.entries(style)) {
+    const gates = [];
+    const level = ALLOWED_STYLE_PROPS[prop];
+    if (level === void 0 || level === "SEMANTIC_ONLY" || level === "FORBIDDEN") {
+      const reason = whitelistReason(prop, level ?? "");
+      gates.push({ gate: "whitelist", decision: "reject", detail: reason });
+      records.push({ prop, value, gates, decision: "drop", rejectReason: reason });
+      continue;
+    }
+    gates.push({ gate: "whitelist", decision: "pass", detail: "\u767D\u540D\u5355\u653E\u884C" });
+    const result = validateProp(prop, value, platform);
+    if (!result.valid) {
+      const reason = result.reason || `\u503C\u7C7B\u578B\u975E\u6CD5: ${String(value)}`;
+      gates.push({ gate: "validator", decision: "reject", detail: reason });
+      records.push({ prop, value, gates, decision: "drop", rejectReason: reason });
+      continue;
+    }
+    gates.push({ gate: "validator", decision: "pass", detail: "\u7C7B\u578B\u6821\u9A8C\u901A\u8FC7" });
+    const nativeValues = {};
+    let changedAny = false;
+    for (const p of ALL_PLATFORMS) {
+      if (!options.allPlatforms && p !== platform) continue;
+      const n = narrowValue(prop, value, p);
+      nativeValues[p] = n.valid ? n.value : value;
+      if (n.valid && n.value !== value) changedAny = true;
+    }
+    const changed = result.value !== value || changedAny;
+    if (changed) {
+      gates.push({
+        gate: "narrowing",
+        decision: "narrow",
+        detail: `\u5E73\u53F0\u6536\u7A84\uFF08${platform}\uFF09\uFF1A${JSON.stringify(result.value)}`
+      });
+      records.push({ prop, value, gates, decision: "narrow", nativeValues: options.allPlatforms ? nativeValues : { [platform]: result.value } });
+    } else {
+      gates.push({ gate: "narrowing", decision: "pass", detail: "\u65E0\u9700\u6536\u7A84\uFF08\u539F\u6837\u900F\u4F20\uFF09" });
+      records.push({ prop, value, gates, decision: "pass", nativeValues: options.allPlatforms ? nativeValues : { [platform]: result.value } });
+    }
+  }
+  return records;
+}
+export {
+  collectStyleGateRecords
+};

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+/** HMR 可观测事件（原则 #3 编译透明：HMR 过程可见——DevTools 面板数据源） */
+export type HmrEvent = {
+    type: 'connected';
+} | {
+    type: 'disconnected';
+    reason?: string;
+} | {
+    type: 'reconnecting';
+    attempt: number;
+    delayMs: number;
+} | {
+    type: 'payload';
+    payload: HmrPayload;
+} | {
+    type: 'apply';
+    file: string;
+    result: 'ok' | 'skipped' | 'reload';
+} | {
+    type: 'rule';
+    rule: 'HMR001' | 'HMR002' | 'HMR003';
+    file: string;
+    message: string;
+} | {
+    type: 'error';
+    file?: string;
+    message: string;
+};
+/** HMR payload：一次增量更新的传输单元 */
+export interface HmrPayload {
+    /** 单调递增 id（客户端按序应用；乱序/重复丢弃） */
+    id: number;
+    /** 变更文件（相对工程根路径） */
+    file: string;
+    /** 变更类型 */
+    type: 'vue' | 'js' | 'css' | 'asset' | 'native-binding';
+    /** 新模块代码（vue/js 必带；css/asset 可选——资源替换由宿主处理） */
+    code?: string;
+    /** 编译时间戳 */
+    timestamp: number;
+    /** 动作：update（热替换）/ reload（整体刷新） */
+    action: 'update' | 'reload';
+}
+/** 传输通道（结构类型：WebSocket / SSE / 自研均可注入） */
+export interface HmrTransport {
+    send(payload: HmrPayload): void;
+    onMessage(cb: (payload: HmrPayload) => void): void;
+    onStatus(cb: (online: boolean) => void): void;
+    close(): void;
+}
+/** 安全 reload 接口（HMR002：原生 binding 变更等不可热替换场景） */
+export interface SafeReload {
+    /** 保存当前状态（路由栈 + 页面状态；M3 原生侧联动 Router G-32 栈序列化） */
+    saveState(): Record<string, unknown>;
+    /** 恢复状态（传入已保存状态；缺省读存储） */
+    restoreState(state?: Record<string, unknown>): Record<string, unknown> | undefined;
+    /** 安全 reload：保存 → reload（恢复由新会话完成） */
+    reload(): void;
+}

package/dist/vue-adapter.d.ts

@@ -0,0 +1,28 @@
+import type { HmrRuntime } from './runtime';
+/** import.meta.hot 的形状（Vite 注入；结构类型，可注入 mock 单测） */
+export interface VueHotApiLike {
+    accept(deps?: string[] | ((mod: unknown) => void), cb?: (mod: unknown) => void): void;
+    dispose(cb: (data: Record<string, unknown>) => void): void;
+    invalidate(): void;
+}
+export interface VueHotAdapterOptions {
+    /** HMR Runtime（snapshot/restore 状态保留） */
+    runtime: HmrRuntime;
+    /** 当前模块文件路径（相对工程根） */
+    file: string;
+    /** import.meta.hot 提供者（Vite 中传 import.meta.hot；缺省 no-op——非 dev 环境安全降级） */
+    getHot?: () => VueHotApiLike | undefined;
+}
+export interface VueHotAdapter {
+    /** 是否存在 hot 环境（Vite dev） */
+    readonly enabled: boolean;
+    /** accept：注册组件更新回调（新模块应用后触发） */
+    accept(cb?: () => void): void;
+    /** dispose：组件替换前状态快照（Flutter Hot Reload 体验） */
+    dispose(snapshot: () => Record<string, unknown>): void;
+    /** 组合：dispose 快照 + accept 恢复（状态保留一键式） */
+    applyWithState(snapshot: () => Record<string, unknown>, restore: (state: Record<string, unknown>) => void): void;
+    /** invalidate：声明不可热替换 → 触发整页刷新 */
+    invalidate(): void;
+}
+export declare function createVueHotAdapter(options: VueHotAdapterOptions): VueHotAdapter;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@proteus-vue/hmr",
+  "version": "0.1.0",
+  "description": "Proteus HMR 运行时（devtools-plus G-34 M1）：HMR payload 协议 + 状态保留 + Vue import.meta.hot 适配 + WebSocket 客户端 + 安全 reload——开发期工具链，不随业务产物发布",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./dev-server": {
+      "types": "./dist/dev-server/index.d.ts",
+      "import": "./dist/dev-server/index.js",
+      "default": "./dist/dev-server/index.js"
+    },
+    "./cdp": {
+      "types": "./dist/cdp/index.d.ts",
+      "import": "./dist/cdp/index.js",
+      "default": "./dist/cdp/index.js"
+    },
+    "./style-gate": {
+      "types": "./dist/style-gate/index.d.ts",
+      "import": "./dist/style-gate/index.js",
+      "default": "./dist/style-gate/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json --emitDeclarationOnly && esbuild src/index.ts --bundle --format=esm --platform=node --outfile=dist/index.js && esbuild src/dev-server/index.ts --bundle --format=esm --platform=node --outfile=dist/dev-server/index.js --external:ws && esbuild src/cdp/index.ts --bundle --format=esm --platform=node --outfile=dist/cdp/index.js --external:@proteus-vue/runtime --external:ws && esbuild src/style-gate/index.ts --bundle --format=esm --platform=node --outfile=dist/style-gate/index.js --external:@proteus-vue/runtime"
+  },
+  "dependencies": {
+    "@proteus-vue/runtime": "0.2.0-beta.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}