@monotykamary/dsh-client-web 0.1.0-rc.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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/web/README.md
+README.md: 9a58cc2d453e7301d648342d8d9a0c4e8e9d2e83
+README.zh.md: 050f98abda06cd1f8c9c632b1a1f508c64bcb3ff

package/README.md

@@ -0,0 +1,26 @@
+# @monotykamary/dsh-client-web
+
+English | [中文](README.zh.md)
+
+Web shell kernel: `new AppWebEntry(el, seams?).run()` mounts the whole client through the two-stage boot (web2). Stage one (module face): build the client module system (`@monotykamary/dsh-client-modules`) over the host-pushed entry graph (`window.__DSH_BOOT__`) and prefetch the `immediately` tier in parallel — bundle execution registers factories only. Stage two (plugin face): mount the vendored cordis Loader with the module system injected through its `internal` contract, create one loader entry per graph row plus the shell-own app-shell assembly entry (tree.import materializes each module), and gate AppRoot on the settle (loader quiesced + every entry fiber ACTIVE → full UI in one switch). Composition is entirely the host graph's: the roster and the immediately tier live in the composing app; the shell makes zero composition decisions.
+
+Shell self-sufficiency (web2 hard rule): the kernel value-imports no plugin package — the boot status store and signals are hand-rolled here (`loader-status.ts`), so the loading page works while (and especially when) plugins fail. The app-shell assembly (`@monotykamary/dsh-client-app-shell`, a shell-owned pseudo entry with no npm package behind it) is the only module registered through `registerStatic`; it inject-waits on slots/sessions/layout like any plugin.
+
+`PLATFORM_MODULES` (src/platform.ts) is the single source of truth for shared modules: seed-table keys, tsdown client externals, and the Vite alias set are its projections.
+
+The optional override parameter `seams` forwards the module system's `loadBundle` transport override (`BootSeams`) for environments where external `<script>` execution cannot reach the page context; ordinary browser callers omit it.
+
+The shell owns browser-title projection. With a selected session carrying a durable title, it renders `<session title> — <existing HTML title>` and reacts to later title revisions; no selection or a selected untitled session preserves the existing title, and shell unmount restores it. The existing HTML title remains the configurable product suffix.
+
+## Model Experience
+
+None, as the entry shell boots the browser plugin tree; nothing here reaches a model request.
+
+#### KV Cache effect
+
+None; this package neither assembles nor sends a provider request.
+
+## Known Limitations and Deferred Work
+
+- **One-shot rendering by design** — the UI waits for the boot settle; a single entry failure keeps the loading page with a loud per-entry report, no partial availability (progressive rendering returns with its own project).
+- **Narrow-window shell behavior lacks an assembled walkthrough** — ui-layout implements the concession chain, but this package has no shell-level narrow-viewport acceptance case.

package/README.zh.md

@@ -0,0 +1,26 @@
+# @monotykamary/dsh-client-web
+
+[English](README.md) | 中文
+
+Web 外壳内核：`new AppWebEntry(el, seams?).run()` 通过两阶段启动（web2）挂载整个客户端。第一阶段（模块侧）：构建客户端模块系统（`@monotykamary/dsh-client-modules`），以主机推送的配置项图（`window.__DSH_BOOT__`）为基础，并行预取 `immediately` 层级；执行组合包只会注册 factory。第二阶段（插件侧）：挂载仓库内置的 Cordis Loader，并通过其 `internal` 约定注入模块系统；为每一行图数据创建一个 loader 配置项，另创建外壳自身的 app-shell 组装配置项（tree.import 会物化各模块）；以 settle 作为 AppRoot 的门禁（loader 完全停稳 + 每个配置项 fiber 都为 ACTIVE → 一次切换显示完整 UI）。组合完全由主机图决定：花名册和 immediately 层级都位于负责组合的应用中；外壳不作任何组合决策。
+
+外壳自给自足（web2 硬性规则）：内核不对任何插件包执行值导入；启动状态 store 与信号在这里手写（`loader-status.ts`），因此即使插件失败，加载页面仍能工作，而此时这一点尤其重要。app-shell 组装（`@monotykamary/dsh-client-app-shell`，由外壳拥有、背后没有 npm 包的伪配置项）是唯一通过 `registerStatic` 注册的模块；它与任何插件一样，通过 inject 等待 slots/sessions/layout。
+
+`PLATFORM_MODULES`（src/platform.ts）是共享模块接口的唯一真源：种子表 key、tsdown 客户端 external 和 vite alias 集都是它的投影。
+
+可选的覆盖参数 `seams` 会为外部 `<script>` 执行无法到达页面上下文的环境转发模块系统的 `loadBundle` 传输覆盖（`BootSeams`）；普通浏览器调用方省略此参数。
+
+外壳拥有浏览器标题投影。选中带有持久标题的会话时，它会渲染 `<session title> — <existing HTML title>` 并响应后续标题修订；未选择会话或选中无标题会话时，会保留现有标题；外壳卸载时恢复标题。现有 HTML 标题仍是可配置的产品后缀。
+
+## 模型体验
+
+无。入口外壳负责启动浏览器插件树；这里没有任何内容进入模型请求。
+
+#### KV Cache 影响
+
+无；该包既不组装也不发送提供方请求。
+
+## 已知限制与暂缓事项
+
+- **有意采用一次性渲染**：UI 等待启动 settle；只要一个配置项失败，加载页面就会保留并逐项显示醒目的报告，不提供部分可用性（渐进式渲染将作为独立项目恢复）。
+- **窄窗口外壳行为缺少组装后演练**：ui-layout 已实现让步链，但该包没有外壳级窄视口验收用例。

package/lib/index.js

@@ -0,0 +1,436 @@
+import * as ReactJsxRuntime from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import * as Cordis from "@monotykamary/cordis";
+import { Context } from "@monotykamary/cordis";
+import Loader from "@monotykamary/cordis-plugin-loader";
+import * as ReactDomClient from "react-dom/client";
+import { createRoot } from "react-dom/client";
+import * as ModulesClient from "@monotykamary/dsh-client-modules/client";
+import { ClientModuleSystem, parseBootManifest } from "@monotykamary/dsh-client-modules/client";
+import * as WebReact from "@monotykamary/dsh-client-web-react";
+import { bindSnapshotSelector, createSlotRenderer } from "@monotykamary/dsh-client-web-react";
+import * as React from "react";
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import * as ReactDom from "react-dom";
+import * as UiSlots from "@monotykamary/dsh-client-ui-slots";
+import * as UiPrimitives from "@monotykamary/dsh-client-ui-primitives";
+import * as UiAttachment from "@monotykamary/dsh-client-ui-attachment";
+import * as SchemaForm from "@monotykamary/dsh-client-schema-form";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region lib/types/DocumentTitle.js
+/**
+* Project the selected durable session title into the browser title and
+* restore the shell's original product title when unmounted.
+* @param props - selected session title projection.
+* @returns no rendered content.
+*/
+function DocumentTitle({ title }) {
+	const original = useRef(document.title);
+	useEffect(() => {
+		document.title = title === void 0 ? original.current : `${title} — ${original.current}`;
+		return () => {
+			document.title = original.current;
+		};
+	}, [title]);
+	return null;
+}
+//#endregion
+//#region lib/types/app.js
+/**
+* Build the renderApp factory the app-shell plugin provides to AppRoot.
+* @param deps - assembly inputs.
+* @returns factory producing the real UI tree (called once per AppRoot render after settled).
+*/
+function buildRenderApp(deps) {
+	const { ctx } = deps;
+	const sessions = ctx.get("sessions");
+	if (sessions === void 0) throw new Error("shell assembly: sessions service unavailable");
+	const useSessions = bindSnapshotSelector(sessions.list);
+	const SessionDocumentTitle = () => {
+		const title = useSessions((state) => {
+			const id = state.current;
+			return id === void 0 ? void 0 : state.byId[id]?.title;
+		});
+		return jsx(DocumentTitle, { ...title === void 0 ? {} : { title } });
+	};
+	return () => jsxs(Fragment, { children: [jsx(SessionDocumentTitle, {}), ctx.slots.renderSlot("root", {})] });
+}
+//#endregion
+//#region lib/types/app-shell.js
+var app_shell_exports = /* @__PURE__ */ __exportAll({
+	APP_SHELL_ID: () => APP_SHELL_ID,
+	apply: () => apply,
+	inject: () => inject,
+	name: () => name
+});
+/** Shell-owned pseudo entry id under which the host graph mounts this plugin. */
+const APP_SHELL_ID = "@monotykamary/dsh-client-app-shell";
+/** Cordis plugin name. */
+const name = "app-shell";
+/** Services required before shell assembly. */
+const inject = [
+	"slots",
+	"sessions",
+	"layout"
+];
+/** Installs the React renderer and exposes the assembled application.
+* @param ctx - Plugin context.
+*/
+function apply(ctx) {
+	ctx.slots.install(createSlotRenderer());
+	let renderApp;
+	ctx.reflect.provide("appShell", { renderApp: () => {
+		renderApp ??= buildRenderApp({ ctx });
+		return renderApp();
+	} });
+}
+//#endregion
+//#region \0dsh-css-stub:./AppRoot.module.css.mjs
+var AppRoot_module_css_default = {};
+//#endregion
+//#region lib/types/AppRoot.js
+/**
+* Shell root: boot loading page → (boot settled) → real UI in one switch.
+* Pure kernel component with zero plugin dependencies — before settled it may
+* only rely on itself (the fail-loud presentation must not depend on the
+* system whose failure it reports; the status/signal stores are kernel-own,
+* shell self-sufficiency rule); the real UI is produced by the
+* app-shell entry once every entry is active. A failed boot keeps the
+* loading page, lists the per-entry fiber states and the sweep report (fail
+* loud, no partial UI).
+*/
+/** Boot gate: loading page until the boot settles; failures stay here. */
+function AppRoot(props) {
+	const settled = useSyncExternalStore(props.settled.subscribe, props.settled.getSnapshot);
+	const status = useSyncExternalStore(props.status.subscribe, props.status.getSnapshot);
+	const error = useSyncExternalStore(props.error.subscribe, props.error.getSnapshot);
+	const failed = Object.entries(status).filter(([, s]) => s === "failed");
+	if (settled) return jsx(Fragment, { children: props.renderApp() });
+	const loud = error !== void 0 || failed.length > 0;
+	return jsx("div", {
+		className: AppRoot_module_css_default.boot,
+		children: jsxs("div", {
+			className: AppRoot_module_css_default.card,
+			children: [jsx("div", {
+				className: AppRoot_module_css_default.wordmark,
+				children: "HARNESS"
+			}), !loud ? jsxs(Fragment, { children: [jsx("div", { className: AppRoot_module_css_default.spinner }), jsx("div", {
+				className: AppRoot_module_css_default.hint,
+				children: "Loading plugins…"
+			})] }) : jsxs("div", {
+				className: AppRoot_module_css_default.failed,
+				children: [
+					jsx("div", {
+						className: AppRoot_module_css_default.failedTitle,
+						children: "Failed to load plugins"
+					}),
+					failed.map(([id]) => jsx("div", {
+						className: AppRoot_module_css_default.failedItem,
+						children: id
+					}, id)),
+					error !== void 0 && jsx("div", {
+						className: AppRoot_module_css_default.failedItem,
+						children: error
+					})
+				]
+			})]
+		})
+	});
+}
+//#endregion
+//#region lib/types/seed.js
+/**
+* Platform-singleton module-table. These are the ONLY entities the shell
+* shares into the frozen module table — fetch bundles resolve their externals
+* against exactly this set through the loader's require. Keys come from the
+* platform constant module ({@link ./platform.ts}, the single source
+* of truth with the tsdown client externals); values stay shell-static
+* imports so every bundle sees the same instance.
+*/
+/**
+* Build the static table handed to the module loader at boot.
+* @returns module specifier → exported entity (one entry per platform word).
+*/
+function getStaticModules() {
+	return {
+		"react": React,
+		"react/jsx-runtime": ReactJsxRuntime,
+		"react-dom": ReactDom,
+		"react-dom/client": ReactDomClient,
+		"@monotykamary/cordis": Cordis,
+		"@monotykamary/dsh-client-ui-slots": UiSlots,
+		"@monotykamary/dsh-client-web-react": WebReact,
+		"@monotykamary/dsh-client-ui-primitives": UiPrimitives,
+		"@monotykamary/dsh-client-ui-attachment": UiAttachment,
+		"@monotykamary/dsh-client-schema-form": SchemaForm
+	};
+}
+//#endregion
+//#region lib/types/loader-status.js
+/**
+* Value mirror of cordis's `FiberState` const enum: a const enum has no
+* runtime object to import (and esbuild-based pipelines cannot inline it
+* across modules), so these values mirror the pinned vendored definition
+* while retaining its type (same rationale as dsh-tool-cordis's mirror).
+*/
+const FIBER_STATE = {
+	PENDING: 0,
+	LOADING: 1,
+	ACTIVE: 2,
+	FAILED: 3,
+	DISPOSED: 4,
+	UNLOADING: 5
+};
+/** Label for each fiber state, keyed by member (inlining-safe — no reverse mapping). */
+const STATE_LABELS = {
+	[FIBER_STATE.PENDING]: "pending",
+	[FIBER_STATE.LOADING]: "loading",
+	[FIBER_STATE.ACTIVE]: "active",
+	[FIBER_STATE.FAILED]: "failed",
+	[FIBER_STATE.DISPOSED]: "disposed",
+	[FIBER_STATE.UNLOADING]: "unloading"
+};
+/**
+* Create a writable kernel signal.
+* @param init - initial value.
+* @returns the signal.
+*/
+function createSignal(init) {
+	let value = init;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => value,
+		subscribe: (fn) => {
+			listeners.add(fn);
+			return () => {
+				listeners.delete(fn);
+			};
+		},
+		set: (next) => {
+			value = next;
+			for (const fn of [...listeners]) fn();
+		}
+	};
+}
+/**
+* Create the boot status store.
+* @returns the store (empty until the boot chain projects rows).
+*/
+function createLoaderStatusStore() {
+	let value = {};
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		getSnapshot: () => value,
+		subscribe: (fn) => {
+			listeners.add(fn);
+			return () => {
+				listeners.delete(fn);
+			};
+		},
+		set: (id, state) => {
+			value = {
+				...value,
+				[id]: state
+			};
+			for (const fn of [...listeners]) fn();
+		}
+	};
+}
+//#endregion
+//#region lib/types/boot.js
+/**
+* Web shell boot kernel — the face consumed by the apps/web entry. Everything
+* here is machinery that cannot itself be a loader entry, and none of it
+* value-imports a plugin package (shell self-sufficiency rule: the
+* loading page must work while — especially when — plugins fail). The one
+* sanctioned exception is the modules package (bootstrap
+* identity): the module system cannot arrive through itself, so its class
+* and its client-half wrapper are shell-bundled and the kernel adopts its
+* plugin entry once cordis is up.
+*
+* AppWebEntry.run(), module face first, then plugin face: parse
+* `window.__DSH_BOOT__` into the two-view BootManifest (wire boundary)
+* → build the module system over the module-view rows → render the loading
+* page → prefetch every `immediately` row in parallel with mounting the
+* vendored cordis Loader (`internal` contract injection BEFORE any entry exists —
+* the bare-import fallback in tree.import must never run in a browser) →
+* await the prefetch tier, THEN adopt the modules entry and create one
+* loader entry per plugin-view row plus the shell-own app-shell assembly
+* entry → loader.await() + a full fiber sweep (all ACTIVE, else fail
+* listing who/what/which service) → flip the settled signal so AppRoot
+* switches to the real UI in one pass.
+*
+* Entry creation waits for the whole immediately tier: materialization runs
+* synchronous cross-package require edges (e.g. locale → runtime/client) that
+* fiber inject waiting cannot protect — a bundle's factory must be
+* registered before any dependent entry materializes. Per-row prefetch
+* failures still resolve silently (the create-side import reloads and
+* owns the loud failure), so the barrier never turns one bad bundle into a
+* boot-wide fail-fast.
+*
+* Composition lives in the host graph; the shell makes zero composition
+* decisions (the app-shell assembly is itself a graph entry, the only
+* shell-own module registered with the module system).
+*/
+/**
+* The modules package's own graph row id. The kernel adopts that entry
+* itself (its wrapper is statically registered — shell-bundled code, never
+* fetched), so the plugin-row loop must skip it: the vendored Group.create
+* does not deduplicate by name, and a second fiber would provide 'modules'
+* twice.
+*/
+const MODULES_ID = "@monotykamary/dsh-client-modules";
+/**
+* The web shell kernel: mounts the loading page into a DOM element and runs
+* the two-stage boot over the host graph. Fields hold only what must exist
+* before cordis does — the parsed manifest, the module system, and the
+* loading-page UI handles; everything else lives in plugins.
+*/
+var AppWebEntry = class {
+	el;
+	seams;
+	status = createLoaderStatusStore();
+	settled = createSignal(false);
+	error = createSignal(void 0);
+	ctx;
+	modules;
+	manifest;
+	root;
+	/**
+	* Hold the mount point; all work happens in {@link run}.
+	* @param el - mount point (the app's #root).
+	* @param seams - Optional module transport overrides for test environments.
+	*/
+	constructor(el, seams) {
+		this.el = el;
+		this.seams = seams;
+	}
+	/**
+	* Run the boot chain to settlement. Boot-chain failures resolve (not
+	* reject): the loading page stays up and renders the failure report (the
+	* fail-loud surface the kernel owns). Rejects only when the boot manifest
+	* is missing or malformed — there is nothing to boot against.
+	* @returns resolves once the UI settled or the failure report rendered.
+	*/
+	async run() {
+		this.manifest = parseBootManifest(globalThis.__DSH_BOOT__);
+		this.modules = new ClientModuleSystem({
+			modules: this.manifest.modules,
+			staticModules: getStaticModules(),
+			...this.seams
+		});
+		this.modules.registerStatic(APP_SHELL_ID, app_shell_exports);
+		this.modules.registerStatic(MODULES_ID, ModulesClient);
+		globalThis.__DSH_MODULES__ = this.modules;
+		this.root = createRoot(this.el);
+		this.root.render(jsx(AppRoot, {
+			settled: this.settled,
+			status: this.status,
+			error: this.error,
+			renderApp: () => {
+				const shell = this.ctx.get("appShell");
+				if (shell === void 0) throw new Error("web boot: appShell service missing after settled");
+				return shell.renderApp();
+			}
+		}));
+		const prefetching = this.prefetchImmediateTier();
+		this.ctx = new Context();
+		try {
+			await this.runPluginBoot(prefetching);
+			this.settled.set(true);
+		} catch (reason) {
+			console.error(reason);
+			this.error.set(reason instanceof Error ? reason.message : String(reason));
+		}
+	}
+	/** Unmount the shell (loading page or settled UI). */
+	dispose() {
+		this.root?.unmount();
+	}
+	/** Prefetch the immediately tier (factory registration only; failures defer to the import path). */
+	async prefetchImmediateTier() {
+		await Promise.all(this.manifest.plugins.filter((row) => row.immediately).map((row) => this.modules.prefetch(row.id).catch(() => {})));
+	}
+	/** Plugin face: mount the Loader, inject the `internal` contract, adopt modules, create the graph entries, settle, sweep. */
+	async runPluginBoot(prefetching) {
+		const ctx = this.ctx;
+		await ctx.plugin(Loader);
+		const loader = ctx.loader;
+		loader.internal = this.modules;
+		ctx.on("internal/status", (fiber) => {
+			const entry = fiber.entry;
+			if (entry === void 0 || entry.fiber === void 0) return;
+			this.status.set(entry.options.name, STATE_LABELS[entry.fiber.state]);
+		});
+		await prefetching;
+		const rows = [
+			MODULES_ID,
+			...this.manifest.plugins.map((row) => row.id).filter((id) => id !== MODULES_ID),
+			APP_SHELL_ID
+		];
+		await Promise.all(rows.map(async (name) => {
+			this.status.set(name, "loading");
+			const id = await loader.create({ name });
+			if (loader.resolve(id).fiber === void 0) this.status.set(name, "failed");
+		}));
+		await loader.await();
+		this.assertEntriesActive();
+	}
+	/**
+	* Sweep every loader entry after the tree quiesced: an entry without a
+	* fiber failed its import; a fiber not ACTIVE is FAILED (apply threw) or
+	* PENDING (a required service never arrived — cordis inject waiting has no
+	* timeout, so this sweep is the fail-loud compensation).
+	*/
+	assertEntriesActive() {
+		const ctx = this.ctx;
+		const failures = [];
+		for (const entry of ctx.loader.entries()) {
+			const name = entry.options.name;
+			if (entry.fiber === void 0) {
+				failures.push(`${name}: import failed (see console for the import error)`);
+				continue;
+			}
+			const state = STATE_LABELS[entry.fiber.state];
+			if (state === "active") continue;
+			if (state === "pending") {
+				const missing = Object.keys(entry.fiber.inject).filter((service) => ctx.get(service) === void 0);
+				failures.push(`${name}: pending (waiting for service${missing.length === 1 ? "" : "s"}: ${missing.join(", ") || "unknown"})`);
+			} else failures.push(`${name}: ${state}`);
+		}
+		if (failures.length > 0) throw new Error(`web boot: ${String(failures.length)} entr${failures.length === 1 ? "y" : "ies"} did not activate\n${failures.join("\n")}`);
+	}
+};
+//#endregion
+//#region lib/types/platform.js
+/**
+* Shared browser platform modules. Seeding, bundling externals, and Vite
+* aliases consume this list so their module identities cannot drift.
+* @module @monotykamary/dsh-client-web/src/platform
+*/
+/** The module specifiers the shell shares into the frozen module table. */
+const PLATFORM_MODULES = [
+	"react",
+	"react/jsx-runtime",
+	"react-dom",
+	"react-dom/client",
+	"@monotykamary/cordis",
+	"@monotykamary/dsh-client-ui-slots",
+	"@monotykamary/dsh-client-web-react",
+	"@monotykamary/dsh-client-ui-primitives",
+	"@monotykamary/dsh-client-ui-attachment",
+	"@monotykamary/dsh-client-schema-form"
+];
+//#endregion
+export { APP_SHELL_ID, AppRoot, AppWebEntry, DocumentTitle, FIBER_STATE, PLATFORM_MODULES, STATE_LABELS, buildRenderApp, createLoaderStatusStore, createSignal, getStaticModules };

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@monotykamary/dsh-client-web`.
+* @module @monotykamary/dsh-client-web/invariant
+*/
+const PACKAGE_NAME = "@monotykamary/dsh-client-web";
+/** Cordis companion plugin name. */
+const name = "client-web-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the vite entry shell — boot glue and module-table
+* seeding with no cordis events and no cross-plugin mutable state; the boot
+* chain (loading page → settled → one-flip UI) is asserted by the web smoke
+* e2e against the real carrier.
+*/
+const install = () => {};
+/**
+* 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/AppRoot.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+import type { KernelSignal, LoaderStatus } from './loader-status.ts';
+/** AppRoot props: settled signal, fiber-state projection feed, boot failure report, deferred real-UI factory. */
+export interface AppRootProps {
+    /** True once the boot chain settled (loader quiesced + all entries ACTIVE); the boot closure flips it. */
+    settled: KernelSignal<boolean>;
+    /** Per-entry fiber-state projection store (drives loading/failed rendering). */
+    status: KernelSignal<LoaderStatus>;
+    /** Boot failure report (the settle rejection message); undefined while loading or after success. */
+    error: KernelSignal<string | undefined>;
+    /** Builds the real UI; called only after settled. */
+    renderApp: () => ReactNode;
+}
+/** Boot gate: loading page until the boot settles; failures stay here. */
+export declare function AppRoot(props: AppRootProps): import("react").JSX.Element;
+//# sourceMappingURL=AppRoot.d.ts.map

package/lib/types/DocumentTitle.d.ts

@@ -0,0 +1,13 @@
+/** Props for the shell-owned browser title projection. */
+export interface DocumentTitleProps {
+    /** Durable title of the selected session, or undefined for the product title. */
+    title?: string;
+}
+/**
+ * Project the selected durable session title into the browser title and
+ * restore the shell's original product title when unmounted.
+ * @param props - selected session title projection.
+ * @returns no rendered content.
+ */
+export declare function DocumentTitle({ title }: DocumentTitleProps): null;
+//# sourceMappingURL=DocumentTitle.d.ts.map

package/lib/types/app-shell.d.ts

@@ -0,0 +1,28 @@
+/**
+ * App-shell assembly plugin. Its pseudo package id exists only in the host
+ * graph and shell registry; there is no npm package behind it.
+ */
+import type { ReactNode } from 'react';
+import type { Context } from '@monotykamary/cordis';
+/** Shell-owned pseudo entry id under which the host graph mounts this plugin. */
+export declare const APP_SHELL_ID = "@monotykamary/dsh-client-app-shell";
+/** The assembled-UI face AppRoot renders once the boot settles. */
+export interface AppShellService {
+    /** Build (once) and render the real UI tree. */
+    renderApp: () => ReactNode;
+}
+declare module '@monotykamary/cordis' {
+    interface Context {
+        /** The shell assembly face, provided by the app-shell entry once its inject set is active. */
+        appShell: AppShellService;
+    }
+}
+/** Cordis plugin name. */
+export declare const name = "app-shell";
+/** Services required before shell assembly. */
+export declare const inject: string[];
+/** Installs the React renderer and exposes the assembled application.
+ * @param ctx - Plugin context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=app-shell.d.ts.map

package/lib/types/app.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Real-UI assembly closure, invoked by the app-shell plugin once its inject
+ * set is active: the whole layout tree hangs off the built-in 'root' slot
+ * (ui-layout registers AppFrame there and renders the child slots
+ * internally) — the shell's render is the one ctx-level renderSlot call in
+ * the program.
+ */
+import type { ReactNode } from 'react';
+import type { Context } from '@monotykamary/cordis';
+/** Assembly inputs: the active app-shell plugin ctx (slots/sessions/layout services provided). */
+export interface AssemblyDeps {
+    /** Client context with the assembly's inject set active. */
+    ctx: Context;
+}
+/**
+ * Build the renderApp factory the app-shell plugin provides to AppRoot.
+ * @param deps - assembly inputs.
+ * @returns factory producing the real UI tree (called once per AppRoot render after settled).
+ */
+export declare function buildRenderApp(deps: AssemblyDeps): () => ReactNode;
+//# sourceMappingURL=app.d.ts.map

package/lib/types/boot.d.ts

@@ -0,0 +1,49 @@
+import { type ClientModuleSystemOptions } from '@monotykamary/dsh-client-modules/client';
+import './base.css';
+/** Module transport hook the shell passes through (jsdom tests replace the <script> path). */
+export type BootSeams = Pick<ClientModuleSystemOptions, 'loadBundle'>;
+/**
+ * The web shell kernel: mounts the loading page into a DOM element and runs
+ * the two-stage boot over the host graph. Fields hold only what must exist
+ * before cordis does — the parsed manifest, the module system, and the
+ * loading-page UI handles; everything else lives in plugins.
+ */
+export declare class AppWebEntry {
+    private readonly el;
+    private readonly seams;
+    private readonly status;
+    private readonly settled;
+    private readonly error;
+    private ctx;
+    private modules;
+    private manifest;
+    private root;
+    /**
+     * Hold the mount point; all work happens in {@link run}.
+     * @param el - mount point (the app's #root).
+     * @param seams - Optional module transport overrides for test environments.
+     */
+    constructor(el: HTMLElement, seams?: BootSeams);
+    /**
+     * Run the boot chain to settlement. Boot-chain failures resolve (not
+     * reject): the loading page stays up and renders the failure report (the
+     * fail-loud surface the kernel owns). Rejects only when the boot manifest
+     * is missing or malformed — there is nothing to boot against.
+     * @returns resolves once the UI settled or the failure report rendered.
+     */
+    run(): Promise<void>;
+    /** Unmount the shell (loading page or settled UI). */
+    dispose(): void;
+    /** Prefetch the immediately tier (factory registration only; failures defer to the import path). */
+    private prefetchImmediateTier;
+    /** Plugin face: mount the Loader, inject the `internal` contract, adopt modules, create the graph entries, settle, sweep. */
+    private runPluginBoot;
+    /**
+     * Sweep every loader entry after the tree quiesced: an entry without a
+     * fiber failed its import; a fiber not ACTIVE is FAILED (apply threw) or
+     * PENDING (a required service never arrived — cordis inject waiting has no
+     * timeout, so this sweep is the fail-loud compensation).
+     */
+    private assertEntriesActive;
+}
+//# sourceMappingURL=boot.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Web shell library entry. The shell's product is {@link AppWebEntry} —
+ * apps/web's vite entry runs it against #root; everything else (AppRoot
+ * gate, app-shell assembly entry, module-table staticModules, platform constants) is
+ * internal to the boot chain. PLATFORM_MODULES is re-exported as the
+ * single source of truth for the tsdown client externals projection.
+ * @module @monotykamary/dsh-client-web
+ */
+export { AppWebEntry, type BootSeams } from './boot.tsx';
+export { AppRoot, type AppRootProps } from './AppRoot.tsx';
+export { buildRenderApp, type AssemblyDeps } from './app.tsx';
+export { DocumentTitle, type DocumentTitleProps } from './DocumentTitle.tsx';
+export { APP_SHELL_ID, type AppShellService } from './app-shell.ts';
+export { getStaticModules } from './seed.ts';
+export { PLATFORM_MODULES, type PlatformModule } from './platform.ts';
+export { STATE_LABELS, FIBER_STATE, createSignal, createLoaderStatusStore, type LoaderStatus, type LoaderEntryState, type KernelSignal, type KernelValueSignal, type LoaderStatusStore, } from './loader-status.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@monotykamary/dsh-client-web`.
+ * @module @monotykamary/dsh-client-web/invariant
+ */
+import type { Context } from '@monotykamary/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-web-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/lib/types/loader-status.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Fiber-state projection vocabulary and the kernel-owned status store for the
+ * boot loading page. The status AppRoot renders is a projection of the real
+ * cordis fiber states (display the truth, not a retelling) — the boot chain
+ * subscribes `internal/status` and recomputes one row per loader entry.
+ *
+ * The store is hand-rolled here because of the shell self-sufficiency rule:
+ * the snapshot-store machinery lives in the runtime PLUGIN
+ * package, and the shell kernel must not value-import any plugin package —
+ * the loading page has to work while (and especially when) plugins fail.
+ * @module @monotykamary/dsh-client-web/src/loader-status
+ */
+import type { FiberState } from '@monotykamary/cordis';
+/**
+ * Value mirror of cordis's `FiberState` const enum: a const enum has no
+ * runtime object to import (and esbuild-based pipelines cannot inline it
+ * across modules), so these values mirror the pinned vendored definition
+ * while retaining its type (same rationale as dsh-tool-cordis's mirror).
+ */
+export declare const FIBER_STATE: {
+    readonly PENDING: FiberState.PENDING;
+    readonly LOADING: FiberState.LOADING;
+    readonly ACTIVE: FiberState.ACTIVE;
+    readonly FAILED: FiberState.FAILED;
+    readonly DISPOSED: FiberState.DISPOSED;
+    readonly UNLOADING: FiberState.UNLOADING;
+};
+/** One entry's projected state label (lower-case face of {@link FiberState}). */
+export type LoaderEntryState = 'pending' | 'loading' | 'active' | 'failed' | 'disposed' | 'unloading';
+/** Label for each fiber state, keyed by member (inlining-safe — no reverse mapping). */
+export declare const STATE_LABELS: Record<FiberState, LoaderEntryState>;
+/** Per-entry state projection (AppRoot's status feed), keyed by entry name. */
+export type LoaderStatus = Record<string, LoaderEntryState>;
+/** Minimal observable snapshot the kernel components consume (useSyncExternalStore shape). */
+export interface KernelSignal<T> {
+    /** Current value (stable reference between changes). */
+    getSnapshot: () => T;
+    /**
+     * Subscribe to changes.
+     * @param fn - change listener.
+     * @returns the unsubscribe disposer.
+     */
+    subscribe: (fn: () => void) => () => void;
+}
+/** Writable one-value signal (settled flag, boot failure report). */
+export interface KernelValueSignal<T> extends KernelSignal<T> {
+    /**
+     * Publish a new value and notify subscribers.
+     * @param next - the new value.
+     */
+    set: (next: T) => void;
+}
+/**
+ * Create a writable kernel signal.
+ * @param init - initial value.
+ * @returns the signal.
+ */
+export declare function createSignal<T>(init: T): KernelValueSignal<T>;
+/** The boot status store: per-entry rows over a {@link KernelSignal} face. */
+export interface LoaderStatusStore extends KernelSignal<LoaderStatus> {
+    /**
+     * Project one entry's state (copy-on-write so getSnapshot references only
+     * change on writes — useSyncExternalStore contract).
+     * @param id - entry name.
+     * @param state - projected fiber state.
+     */
+    set: (id: string, state: LoaderEntryState) => void;
+}
+/**
+ * Create the boot status store.
+ * @returns the store (empty until the boot chain projects rows).
+ */
+export declare function createLoaderStatusStore(): LoaderStatusStore;
+//# sourceMappingURL=loader-status.d.ts.map

package/lib/types/platform.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared browser platform modules. Seeding, bundling externals, and Vite
+ * aliases consume this list so their module identities cannot drift.
+ * @module @monotykamary/dsh-client-web/src/platform
+ */
+/** The module specifiers the shell shares into the frozen module table. */
+export declare const PLATFORM_MODULES: readonly ["react", "react/jsx-runtime", "react-dom", "react-dom/client", "@monotykamary/cordis", "@monotykamary/dsh-client-ui-slots", "@monotykamary/dsh-client-web-react", "@monotykamary/dsh-client-ui-primitives", "@monotykamary/dsh-client-ui-attachment", "@monotykamary/dsh-client-schema-form"];
+/** One platform module specifier (a seed-table key). */
+export type PlatformModule = (typeof PLATFORM_MODULES)[number];
+//# sourceMappingURL=platform.d.ts.map

package/lib/types/seed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Build the static table handed to the module loader at boot.
+ * @returns module specifier → exported entity (one entry per platform word).
+ */
+export declare function getStaticModules(): Record<string, unknown>;
+//# sourceMappingURL=seed.d.ts.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@monotykamary/dsh-client-web",
+  "description": "Web shell kernel: bootWebShell (module system holding + seed table + two-stage boot + AppRoot gate + app-shell assembly entry), consumed by the apps/web vite entry",
+  "version": "0.1.0-rc.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/web"
+  },
+  "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"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "@monotykamary/dsh-client-schema-form": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-ui-attachment": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-ui-primitives": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-ui-slots": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-web-react": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-modules": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-ui-theme": "^0.1.0-rc.5"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.0",
+    "typescript": "^6.0.3",
+    "@monotykamary/cordis": "^4.0.1",
+    "@monotykamary/dsh-client-runtime": "^0.1.0-rc.5",
+    "@monotykamary/dsh-invariants": "^0.1.0-rc.5",
+    "@monotykamary/dsh-client-test-runtime": "^0.1.0-rc.5",
+    "@monotykamary/cordis-plugin-loader": "^1.0.2"
+  },
+  "peerDependencies": {
+    "@monotykamary/cordis-plugin-loader": "^1.0.2",
+    "@monotykamary/dsh-invariants": "^0.1.0-rc.5",
+    "@monotykamary/cordis": "^4.0.1"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ]
+}