@deepseek-ai/dsh-client-hmr 0.0.1-rc.1

package/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, DeepSeek
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/client/hmr/README.md
+README.md: 9228292547376d3fbb0ea5ce56b9e0a35ced17b2
+README.zh.md: ea62600911458556a3dcc7c46854e97db751c3ef

package/README.md

@@ -0,0 +1,21 @@
+# @deepseek-ai/dsh-client-hmr
+
+English | [中文](README.zh.md)
+
+Hot reload for script-loaded client plugins. A static-arrival entry composed only into `--dev` graphs (`dsh web --dev`); production graphs omit the row, so the shell-bundled code stays inert.
+
+The browser half subscribes to the system SSE channel (`GET /plugins/events`) and reloads one plugin per `rebuilt` frame through a serialized queue. The sequence per frame — `invalidate`, `prefetch` (load and register the new bundle while the old fiber still serves), `registry.delete` (before the fiber: a bare fiber dispose trips the vendored Loader's self-dispose branch, which would mark the entry disabled), drain the old fiber, delete `entry.fiber`, remove owned `<style data-plugin>` tags, `entry.refresh()` re-imports and remounts, `fiber.await()` rethrows startup failures loud. Dependents reload through cordis itself: a fiber's activation epoch strings its service providers' uids, so replacing a provider's fiber cascades every dependent with zero client-side graph analysis. The node half detects rebuilds with one interval that stat-polls each graph bundle from a synchronous baseline, immediately re-hashes after adding a row, retains missing rows as dirty, and broadcasts only real rev changes; any tsdown watch process producing the bundle therefore triggers HMR with no builder→host channel.
+
+## Model Experience
+
+None, as the reload driver is browser-side machinery; nothing here reaches a model request.
+
+#### KV Cache effect
+
+None; this package neither assembles nor sends a provider request.
+
+## Known Limitations and Deferred Work
+
+- **Reload is coarse by design** — a fresh fiber and fresh components; React state inside the reloaded plugin is lost while the data layer (connection/runtime fibers, Session objects) is untouched. react-refresh-grade state preservation conflicts with "re-executing the bundle re-runs the factory" and is deliberately out.
+- **No failure rollback** — a reload that fails leaves the entry FAILED and visible in the loader status projection; the previous bundle is not restored automatically.
+- **Graph rev is not refreshed by rebuilt frames** — the stale rev is harmless because the bundle endpoint serves no-cache; only reconnect refreshes it.

package/README.zh.md

@@ -0,0 +1,21 @@
+# @deepseek-ai/dsh-client-hmr
+
+[English](README.md) | 中文
+
+为通过脚本加载的客户端插件提供热重载。该静态加载配置项只组合进 `--dev` 图（`dsh web --dev`）；生产图省略该项，因此打包进 shell 的代码保持不活动。
+
+浏览器侧订阅系统 SSE（Server-Sent Events）通道（`GET /plugins/events`），每个 `rebuilt` 帧重载一个插件，并通过队列串行执行。每帧的顺序是：`invalidate`、`prefetch`（旧 fiber 仍在服务时加载并注册新组合包）、`registry.delete`（在 fiber dispose（资源释放）之前执行：仅 dispose fiber 会触发 vendored Loader 的 self-dispose 分支，把配置项标为禁用）、排空旧 fiber、删除 `entry.fiber`、移除自身拥有的 `<style data-plugin>` 标签、通过 `entry.refresh()` 重新导入并挂载、通过 `fiber.await()` 直接重新抛出启动失败。依赖方由 Cordis 自身重载：fiber 的激活 epoch 会串联其服务提供方的 uid，因此替换提供方 fiber 会级联所有依赖方，无需客户端图分析。node 侧使用一个 interval 检测重建：从同步基线开始 stat-poll 每个图组合包；新增一行后立即重新计算 hash；缺失行保持 dirty；只广播真实 rev 变更。因此，任何生成组合包的 tsdown watch 进程都能触发 HMR（热模块替换），无需 builder→host 通道。
+
+## 模型体验
+
+无。重载驱动器属于浏览器侧机制；这里没有任何内容进入模型请求。
+
+#### KV Cache 影响
+
+无；该包（package）既不组装也不发送提供方请求。
+
+## 已知限制与暂缓事项
+
+- **重载有意保持粗粒度**：会创建全新的 fiber 和组件；重载插件中的 React 状态会丢失，数据层（连接 fiber、运行时 fiber 和 Session 对象）不受影响。react-refresh 级状态保留与「重新执行组合包会重新运行 factory」冲突，因此有意排除。
+- **失败时不回滚**：失败的重载会使配置项处于 FAILED 状态，并在 loader 状态投影中显示；系统不会自动恢复先前组合包。
+- **重建帧不会刷新图 rev**：陈旧 rev 无害，因为组合包端点以 no-cache 提供内容；只有重新连接时才会刷新。

package/lib/client.js

@@ -0,0 +1,96 @@
+window.__ModuleLoader__.load({
+	id: "@deepseek-ai/dsh-client-hmr",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		//#region lib/types/events.js
+		/**
+		* Wire protocol of the `/plugins/events` dev SSE channel — single source for
+		* both halves of this package. Frames still cross a wire boundary: the
+		* browser half validates them at its JSON parse point; sharing the type keeps
+		* the two ends from drifting, not from parsing.
+		*/
+		/** System SSE endpoint pushing graph/rebuilt frames (wire protocol constant). */
+		const EVENTS_ENDPOINT = "/plugins/events";
+		//#endregion
+		//#region lib/types/client/index.js
+		/** Cordis plugin name. */
+		const name = "client-hmr";
+		/** Required services: the vendored Loader (entry governance) and the client module system (boot provide, service name `modules`). */
+		const inject = ["loader", "modules"];
+		/** Find the loader entry whose module specifier is `id` (entry tree ids are random; the package name lives in `options.name`). */
+		function findEntry(loader, id) {
+			for (const entry of loader.entries()) if (entry.options.name === id) return entry;
+		}
+		/** Remove every `<style data-plugin>` tag owned by `id` (attribute compared verbatim — no CSS-selector escaping pitfalls). */
+		function removeOwnedStyles(id) {
+			for (const el of document.querySelectorAll("style[data-plugin]")) if (el.getAttribute("data-plugin") === id) el.remove();
+		}
+		/**
+		* Mount the HMR driver: subscribe to the system SSE channel and hot-swap
+		* rebuilt entries.
+		* @param ctx - plugin context with `loader` and `modules` available.
+		*/
+		function apply(ctx) {
+			const modLoader = ctx.modules;
+			const loader = ctx.loader;
+			async function reload(id) {
+				const entry = findEntry(loader, id);
+				if (entry === void 0) {
+					ctx.logger.warn(`client-hmr: rebuilt frame for unknown entry "${id}" (not in the loader tree)`);
+					return;
+				}
+				modLoader.invalidate(id);
+				await modLoader.prefetch(id);
+				const oldFiber = entry.fiber;
+				if (oldFiber !== void 0) {
+					const runtime = oldFiber.runtime;
+					if (runtime !== null) entry.ctx.registry.delete(runtime.callback);
+					while (oldFiber.inertia !== void 0) await oldFiber.inertia;
+					delete entry.fiber;
+				}
+				removeOwnedStyles(id);
+				await entry.refresh();
+				await entry.fiber?.await();
+			}
+			let queue = Promise.resolve();
+			const handle = (frame) => {
+				switch (frame.type) {
+					case "rebuilt":
+						queue = queue.then(() => reload(frame.id)).catch((error) => {
+							ctx.logger.error(`client-hmr: reload of "${frame.id}" failed`);
+							ctx.logger.error(error);
+						});
+						break;
+					case "graph": break;
+					default: break;
+				}
+			};
+			ctx.effect(() => {
+				const source = new EventSource(EVENTS_ENDPOINT);
+				source.addEventListener("message", (event) => {
+					let frame;
+					try {
+						frame = JSON.parse(event.data);
+					} catch {
+						ctx.logger.warn(`client-hmr: unparseable event frame: ${event.data}`);
+						return;
+					}
+					handle(frame);
+				});
+				return () => {
+					source.close();
+				};
+			}, "client-hmr: event source");
+		}
+		//#endregion
+		exports.EVENTS_ENDPOINT = EVENTS_ENDPOINT;
+		exports.apply = apply;
+		exports.inject = inject;
+		exports.name = name;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map

package/lib/index.js

@@ -0,0 +1,160 @@
+import { statSync } from "node:fs";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/events.js
+/**
+* Wire protocol of the `/plugins/events` dev SSE channel — single source for
+* both halves of this package. Frames still cross a wire boundary: the
+* browser half validates them at its JSON parse point; sharing the type keeps
+* the two ends from drifting, not from parsing.
+*/
+/** System SSE endpoint pushing graph/rebuilt frames (wire protocol constant). */
+const EVENTS_ENDPOINT = "/plugins/events";
+//#endregion
+//#region lib/types/index.js
+/**
+* HMR plugin, node half: the host end of the dev reload chain. One interval
+* stat-polls every graph row's client bundle (polling by design: network
+* mounts deliver no inotify events), reports content changes through
+* `clientModuleHost.rebuilt(id)`, and serves the `/plugins/events` SSE channel
+* broadcasting graph/rebuilt frames to the browser half (src/client/).
+* Dev-only row: prod compositions never mount this plugin.
+*/
+/** Cordis plugin name. */
+const name = "client-hmr";
+/** Required services: the web plugin table and the route registry. */
+const inject = ["clientModuleHost", "httpServer"];
+const Config = z.object({ pollIntervalMs: z.number().step(1).min(1).default(500) });
+/** Serialize one frame as an SSE data line. */
+function sseData(frame) {
+	return `data: ${JSON.stringify(frame)}\n\n`;
+}
+/**
+* Mount the dev chain: bundle watches, rebuilt reporting, and the SSE channel.
+* @param ctx - host plugin context carrying clientModuleHost and httpServer.
+* @param config - validated {@link Config}.
+*/
+function apply(ctx, config) {
+	const pollIntervalMs = config.pollIntervalMs;
+	const watched = /* @__PURE__ */ new Map();
+	const rehash = (id, watch, current) => {
+		try {
+			ctx.clientModuleHost.rebuilt(id);
+		} catch (error) {
+			if (error.code === "ENOENT") {
+				watch.dirty = true;
+				return;
+			}
+			ctx.logger.warn(error);
+		}
+		watch.mtimeMs = current.mtimeMs;
+		watch.size = current.size;
+		watch.dirty = false;
+	};
+	const watchRow = (id, path) => {
+		let baseline;
+		try {
+			baseline = statSync(path);
+		} catch (error) {
+			watched.set(id, {
+				path,
+				mtimeMs: 0,
+				size: 0,
+				dirty: true
+			});
+			if (error.code !== "ENOENT") ctx.logger.warn(error);
+			return;
+		}
+		const watch = {
+			path,
+			mtimeMs: baseline.mtimeMs,
+			size: baseline.size,
+			dirty: false
+		};
+		watched.set(id, watch);
+		rehash(id, watch, baseline);
+	};
+	const pollWatches = () => {
+		for (const [id, watch] of watched) {
+			let current;
+			try {
+				current = statSync(watch.path);
+			} catch (error) {
+				watch.dirty = true;
+				if (error.code !== "ENOENT") ctx.logger.warn(error);
+				continue;
+			}
+			if (!watch.dirty && current.mtimeMs === watch.mtimeMs && current.size === watch.size) continue;
+			rehash(id, watch, current);
+		}
+	};
+	const syncWatches = () => {
+		const rows = /* @__PURE__ */ new Map();
+		for (const row of ctx.clientModuleHost.graph().entries) {
+			const path = ctx.clientModuleHost.clientPath(row.id);
+			if (path !== void 0) rows.set(row.id, path);
+		}
+		for (const [id, watch] of watched) {
+			if (rows.get(id) === watch.path) continue;
+			watched.delete(id);
+		}
+		for (const [id, path] of rows) if (!watched.has(id)) watchRow(id, path);
+	};
+	ctx.effect(() => {
+		syncWatches();
+		const unsubscribe = ctx.clientModuleHost.onGraphChanged(syncWatches);
+		const timer = setInterval(pollWatches, pollIntervalMs);
+		timer.unref();
+		return () => {
+			unsubscribe();
+			clearInterval(timer);
+			watched.clear();
+		};
+	}, "client-hmr: bundle watches");
+	const connections = /* @__PURE__ */ new Set();
+	const connect = (res) => {
+		res.writeHead(200, {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			"connection": "keep-alive"
+		});
+		res.write(": connected\n\n");
+		res.write(sseData({
+			type: "graph",
+			graph: ctx.clientModuleHost.graph()
+		}));
+		connections.add(res);
+		res.on("close", () => {
+			connections.delete(res);
+		});
+	};
+	ctx.effect(() => {
+		const disposeRoute = ctx.httpServer.register({
+			kind: "exact",
+			path: EVENTS_ENDPOINT,
+			handler: (req, res) => {
+				if (req.method !== "GET" && req.method !== "HEAD") {
+					res.writeHead(405);
+					res.end();
+					return;
+				}
+				connect(res);
+			}
+		});
+		const unsubscribe = ctx.clientModuleHost.onRebuilt((id, rev) => {
+			const line = sseData({
+				type: "rebuilt",
+				id,
+				rev
+			});
+			for (const res of connections) res.write(line);
+		});
+		return () => {
+			unsubscribe();
+			disposeRoute();
+			for (const res of connections) res.destroy();
+			connections.clear();
+		};
+	}, "client-hmr: /plugins/events channel");
+}
+//#endregion
+export { Config, EVENTS_ENDPOINT, apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,48 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-hmr`.
+* @module @deepseek-ai/dsh-client-hmr/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-hmr";
+/** Cordis companion plugin name. */
+const name = "client-hmr-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** Live fs.watchFile pollers (this package is the composition's only stat-poll user). */
+function statWatchers() {
+	return process.getActiveResourcesInfo().filter((kind) => kind === "StatWatcher").length;
+}
+/**
+* Owned relation: every bundle stat watcher the node half starts must die
+* with its fiber — a surviving poller would keep re-hashing bundles for a
+* torn-down dev chain forever. Checked as a baseline delta: the StatWatcher
+* count observed at fiber creation must be restored once disposal has drained
+* the fiber's effects (`internal/plugin` fires at dispose start; the microtask
+* hop lets the disposer queue its unload before `fiber.await()` joins it).
+* SSE-connection and listener teardown live inside the same ctx.effect
+* disposers, so the watcher count is the relation's observable proxy.
+*/
+const install = (ctx, fail) => {
+	const baselines = /* @__PURE__ */ new WeakMap();
+	ctx.on("internal/plugin", async (fiber) => {
+		if (fiber.name !== "client-hmr") return;
+		if (fiber.uid !== null) {
+			baselines.set(fiber, statWatchers());
+			return;
+		}
+		const baseline = baselines.get(fiber);
+		if (baseline === void 0) return;
+		await Promise.resolve();
+		await fiber.await();
+		const remaining = statWatchers();
+		if (remaining > baseline) fail(`client-hmr fiber disposed but ${remaining - baseline} bundle stat watcher(s) survived teardown`);
+	}, { global: true });
+};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/client/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * client-hmr, browser half: hot-reload driver for client plugin entries.
+ *
+ * Listens on the host's system SSE channel (`GET /plugins/events`); on a
+ * `rebuilt` frame it reloads the entry's bundle and swaps the cordis
+ * fiber in place. Every graph entry is a plugin bundle
+ * — `immediately` rows differ only in stage-one prefetch (a boot
+ * optimization), so all rostered plugin packages share these reload semantics;
+ * normal packages (react family, cordis, shell, pure libs) are not entries
+ * and shell changes still mean a page reload. Cascade is zero-touch:
+ * downstream fibers key their activation epoch on provider fiber uids
+ * (vendor/cordis/src/fiber.ts `_refresh`), so replacing a provider fiber
+ * re-cascades natively — reloading a data-layer plugin (connection/runtime)
+ * cascades into its UI dependents with no HMR-side bookkeeping.
+ *
+ * Reload order (lazy CJS table): invalidate (drop the stale factory and
+ * materialized record) → prefetch (load and register the fresh
+ * factory) → registry-first teardown → drain old fiber unload → remove
+ * owned `<style data-plugin>` tags → `entry.refresh()` materializes the new
+ * factory. Invalidate MUST precede prefetch: a live factory makes prefetch
+ * a no-op, and re-executing a bundle over an undeleted registration is a
+ * loud duplicate. The swap is safe because execution is pure registration
+ * under the lazy model — every module side effect (CSS injection included)
+ * lives in the factory closure and runs at materialization, inside
+ * refresh(). That also keeps the CSS ordering guarantee: owned styles are
+ * removed after the old fiber's disposers drained (SlotCore one-owner
+ * unregister) and before materialization re-injects tags under the same
+ * stable tag ids.
+ *
+ * Failure window: if prefetch rejects after invalidate, the module is left
+ * unregistered while the OLD fiber keeps running untouched (teardown never
+ * started) — degraded but recoverable, the next rebuilt frame retries from
+ * scratch. Consistent with the no-rollback policy below. Known dev-only
+ * race: a rebuilt frame overlapping a still-in-flight boot arrival shares
+ * that arrival's task and may materialize the pre-rebuild bytes; the next
+ * rebuilt frame self-heals.
+ *
+ * Why not the naive `entry.fiber.dispose()` → `entry.refresh()` path:
+ * 1. `Entry.fiber` is never cleared on dispose (vendor/loader/src/config/
+ *    entry.ts assigns it only in `_init`), so `refresh()` hits its
+ *    `if (this.fiber) return` guard and no-ops.
+ * 2. A bare `fiber.dispose()` lands in Loader's self-dispose branch
+ *    (vendor/loader/src/index.ts `internal/plugin` case 4: the registry
+ *    still holds the runtime at emit time), which flags the entry
+ *    `disabled: true` — permanently.
+ * vendor/hmr's reload skeleton documents the fix: delete the runtime record
+ * FIRST (`registry.delete` → case 4 returns early, the entry stays enabled),
+ * then rebuild. `entry.fiber` is additionally cleared so
+ * `entry.refresh()` re-imports and re-plugins through the Loader's own
+ * `_init` (entry-resolved config, automatic `fiber.entry` rebinding) instead
+ * of hand-rolling `registry.plugin`. Client entries have exactly one fiber
+ * per runtime, so `registry.delete` never collaterally disposes siblings.
+ *
+ * Self-reload: this plugin is itself a graph entry, so a rebuilt frame may
+ * name it. The in-flight reload keeps running in the old bundle's closure
+ * (its EventSource closes with the old fiber's effects); the new bundle's
+ * apply opens a fresh channel. Frames arriving during the gap are lost —
+ * acceptable for the dev channel, the next rebuild renotifies.
+ *
+ * Failure policy: no rollback. An import failure leaves the entry
+ * fiberless (the next rebuilt frame retries from scratch); an apply failure
+ * leaves a FAILED fiber for the shell's status projection. Both log loudly.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export type { PluginsEventFrame } from '../events.ts';
+export { EVENTS_ENDPOINT } from '../events.ts';
+/** Cordis plugin name. */
+export declare const name = "client-hmr";
+/** Required services: the vendored Loader (entry governance) and the client module system (boot provide, service name `modules`). */
+export declare const inject: string[];
+/**
+ * Mount the HMR driver: subscribe to the system SSE channel and hot-swap
+ * rebuilt entries.
+ * @param ctx - plugin context with `loader` and `modules` available.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/events.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Wire protocol of the `/plugins/events` dev SSE channel — single source for
+ * both halves of this package. Frames still cross a wire boundary: the
+ * browser half validates them at its JSON parse point; sharing the type keeps
+ * the two ends from drifting, not from parsing.
+ */
+import type { WebBootGraph } from '@deepseek-ai/dsh-client-modules';
+/** One SSE frame: the full graph on connect, or one rebuilt bundle notice. */
+export type PluginsEventFrame = {
+    type: 'graph';
+    graph: WebBootGraph;
+} | {
+    type: 'rebuilt';
+    id: string;
+    rev: string;
+};
+/** System SSE endpoint pushing graph/rebuilt frames (wire protocol constant). */
+export declare const EVENTS_ENDPOINT = "/plugins/events";
+//# sourceMappingURL=events.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export type { PluginsEventFrame } from './events.ts';
+export { EVENTS_ENDPOINT } from './events.ts';
+/** Cordis plugin name. */
+export declare const name = "client-hmr";
+/** Required services: the web plugin table and the route registry. */
+export declare const inject: string[];
+/** Plugin config, validated by the same-named schemastery schema. */
+export interface Config {
+    /** Bundle stat-poll interval in milliseconds (default 500, the build-side watcher's polling default). */
+    pollIntervalMs?: number;
+}
+export declare const Config: z<Config>;
+/**
+ * Mount the dev chain: bundle watches, rebuilt reporting, and the SSE channel.
+ * @param ctx - host plugin context carrying clientModuleHost and httpServer.
+ * @param config - validated {@link Config}.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-hmr`.
+ * @module @deepseek-ai/dsh-client-hmr/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-hmr-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@deepseek-ai/dsh-client-hmr",
+  "description": "Dev-only hot-reload driver for script-loaded client entries: SSE rebuilt frames → invalidate/prefetch → fiber swap through the vendored Loader entry",
+  "version": "0.0.1-rc.1",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/hmr"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "inject": [],
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.1-rc.1",
+    "@deepseek-ai/dsh-client-modules": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.1-rc.1",
+    "@deepseek-ai/dsh-client-modules": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.1",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ]
+}