@deepseek-ai/dsh-client-ui-slots 0.1.1-rc.2 → 0.1.2-alpha.2

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # 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/ui-slots/README.md
-README.md: 332bd092e8a4dec5a424acccce57c3dd0d8c27d8
-README.zh.md: 369776ea72c6f21184c0accd183aa9b409ee867a
+README.md: 7b5b55c7f640d290b569354a1d2ce1771fcbf871
+README.zh.md: 3212304227048c5334695395160378c7dfb19fb3

package/README.md

@@ -1,29 +1,82 @@
+---
+description: "Slot registry pure core for the dsh web client: SlotMap declaration merging, the single register composition API, four-share props types, store seats, and the renderer install contract."
+kind: "package-library"
+---
+
 # @deepseek-ai/dsh-client-ui-slots
 
 English | [中文](README.zh.md)
 
-Slot registry pure core, slot terminal design: SlotMap declaration merging, the single `register` composition API on SlotCore, the four-share component-props type family, the store-seat type family, and the renderer installation contract. React types only at runtime — the package is React-free and cordis-free.
+## Summary
+
+`dsh-client-ui-slots` is the pure core of the web client's slot system: the type-level contract every UI feature composes through. One `register({ name, children?, store?, inject?, ...kind }, Component)` call contributes a component into a declared slot and, in the same breath, declares child slots, a store seat, and the registrant's business face. The component is checked at the call site against `ComposedProps` — the intersection of four shares, each derived from its single source of truth — so a wrong composition fails to compile. Chain-kind slots invert keyed routing: entries self-nominate through a pure selector instead of the dispatch site picking an `entryKey`. The package is React-free and Cordis-free at runtime (React types only); `ui-renderer` owns the engine implementation and React bindings.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Compose UI through this package whenever you write a client plugin: register a component into a slot your parent declared, or declare child slots your component renders. The four kinds cover the composition shapes — `single` (one occupant), `list` (ordered entries), `keyed` (dispatch by a key), and `chain` (entries elect themselves).
+
+### The four props shares
+
+Every registered component receives props composed from four shares: the runtime share (`owner` from the parent's renderSlot call site, plus the session standard kit and global seat), the child-render share (`renderSlot` statically narrowed to the declared children keys), the store share (the declared handle's selector hook and draft-stripped actions), and the business share (inferred from the `inject` factory's return). Components reference `ComposedProps`; they never re-type a share locally.
+
+### Store seats
+
+A register call may declare a store seat with `store: defineStore(...)`: `init` infers the state schema and `actions` is the complete draft-transform write set. Components read through the selector hook and write through the baked callbacks; the engine implementation of `defineStore` lives in the runtime package and satisfies the `DefineStore` contract exported here.
+
+### Declaration discipline
+
+Declaring a slot is claiming it: the registering entry becomes the only entry allowed to render that key, and registering into an undeclared slot, declaring an already-declared child, mounting one shared handle under two scopes, or registering a chain without `select` throws at load. An entry's disposer collapses its declared child slots recursively — ledger rows, contributions, and store mounts die on one lifecycle axis.
+
+-----
 
-One `register({ name, children?, store?, inject?, ...kind }, Component)` call contributes a component into a declared slot and, in the same breath, declares child slots (declaration = render authorization = runtime spec, one table), a store seat, and the registrant's business face. The component is checked at the call site against `ComposedProps` — the intersection of four shares, each derived from its single source of truth:
+<a id="understand-the-implementation"></a>
+## Understand the implementation
 
-| share | type | source |
-|---|---|---|
-| runtime | `PropsRuntime<K>` | SlotMap entry: `owner` (parent's renderSlot call site) + session standard kit + global seat |
-| child render | `PropsRenderSlots<S>` | the register call's `children` key set (statically narrowed `renderSlot`) |
-| store | `PropsStore<H>` | the declared handle: `useStore` selector hook + draft-stripped `actions` |
-| business | `I` | inferred from the `inject` factory's return |
+<details>
+<summary>Implementation internals — click to expand</summary>
 
-Chain-kind slots invert keyed routing — entries self-nominate instead of the dispatch site picking an `entryKey`: each registration carries a pure `ChainSelect` selector (plus optional ascending `priority`, ties in registration order), the first non-null return elects its entry and becomes the component's `matched` prop, and all-null falls to the owner's `renderSlotChain` fallback (`ChainRenderOpts`).
+The design is one table: declaration = render authorization = runtime spec. `SlotMap` is declared empty here and merged by consumers via `declare module` augmentation, exactly like the standard-kit interfaces (`SessionStandardProps`, `GlobalStandardProps`), which the runtime package merges with real members.
 
-The standard-kit interfaces (`SessionStandardProps`, `GlobalStandardProps`) are declared empty here and merged by the runtime package (same declare-merge pattern as SlotMap keys). The renderer binds the runtime's session and workspace observable sources into selector hooks. Inject factory parameters derive from the declaration (`InjectParams`): session slots get `sessionId`, a declared store appends baked `actions`, nothing else — data access lives in the apply closure's ctx.
+### Registration and routing
 
-The store family (`defineStore` spec in / `StoreHandle<T, A>` out) types the store seat: `init` infers the state schema, `actions` is the complete draft-transform write set, `BakedActions` strips the draft parameter into the callbacks components and inject factories receive. The `defineStore` value implementation lives in the runtime package (the engine's home) and satisfies the `DefineStore` contract exported here. Engine products and the renderer host contract carry bare snapshot sources (`getSnapshot`/`subscribe`), never React hooks — hook binding belongs to the render machinery; only the props-contract hook type (`SnapshotSelectorHook`) lives here.
+`SlotCore` seeds the a-priori `'root'` slot at construction and enforces load-time validation. `ChainSelect` selectors run in ascending `priority` order (ties in registration order); the first non-null return elects its entry and becomes the component's `matched` prop, and all-null falls to the owner's `renderSlotChain` fallback (`ChainRenderOpts`). Each key carries a declaration epoch that advances only on declaration and collapse; `ui-renderer` uses it for `ctx.slots.inject`, independently from ordinary entry versions.
 
-`SlotCore` seeds the a-priori `'root'` slot at construction and enforces load-time validation (undeclared-slot registration, duplicate child declaration, one shared handle under two scopes, a chain registration without `select` — all throw at register). An entry's disposer collapses its declared child slots recursively: ledger rows, contributions, and store mounts die on one lifecycle axis. Each key also carries a declaration epoch that advances only on declaration and collapse; the runtime uses it for [`ctx.slots.inject`](../runtime/README.md#slot-declaration-injection), independently from ordinary entry versions. `renderer.ts` carries the installation contract (`SlotRenderer`, `SlotRendererHost`) plus `StaleAuthorizationError`/`SlotOwnershipError`; ui-renderer owns both the implementation and its plugin-lifecycle installation.
+### The renderer contract
 
+`renderer.ts` carries the installation contract (`SlotRenderer`, `SlotRendererHost`) plus `StaleAuthorizationError`/`SlotOwnershipError`; ui-renderer owns both the implementation and its plugin-lifecycle installation. Engine products and the renderer host contract carry bare snapshot sources (`getSnapshot`/`subscribe`), never React hooks — hook binding belongs to the render machinery.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+These pages cover the engine, the renderer, and the composition model.
+
+- [Slot declaration injection decision](../../../.agents/notes/implemented/architecture/2026-08-05-slot-declaration-injection.md) — the lifecycle rules behind `ctx.slots.inject`.
+- [ui-renderer](../ui-renderer/README.md) — the React slot renderer implementing this package's install contract.
+- [Slot system standard](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.md) — the definitive composition model.
+- [Web client architecture](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.md) — the loading chain and object layer this registry plugs into.
+
+-----
+
+<a id="model-experience"></a>
 ## Model Experience
 
-None, as the slot registry is browser-side UI plumbing; nothing here reaches a model request.
+None, as the package is a browser-side UI plugin layer that registers nothing model-facing.
 
 #### KV Cache effect
 
@@ -31,5 +84,20 @@ None; this package neither assembles nor sends a provider request.
 
 ## Known Limitations and Deferred Work
 
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define the registry's scaling behavior and accepted type noise; they are current package constraints.
+
 - **`isLive` scans all records linearly** — fine at UI-plugin registration counts (tens); revisit with an entry→record backref if ledgers ever grow hot.
 - **The `__renders` phantom anchor is visible on `PropsRenderSlots`** — the same accepted noise as the type-chain design's `__accepts`: generic method signatures compare loosely across key unions, so the contravariant marker is what enforces "component key set ⊆ children declaration".
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -1,35 +1,103 @@
+---
+description: "dsh Web 客户端的 slot 注册表纯核心：SlotMap 声明合并、单一 register 组合 API、四 share props 类型、store 席位与渲染器安装约定。"
+kind: "package-library"
+---
+
 # @deepseek-ai/dsh-client-ui-slots
 
 [English](README.md) | 中文
 
-Slot 注册表纯核心、slot 终端设计：SlotMap 声明合并、SlotCore 上唯一的 `register` 组合 API、四 share 组件 props 类型家族、store seat 类型家族，以及 renderer 安装约定。只使用 React 类型；该包不依赖 React，也不依赖 Cordis。
+## 概述
+
+`dsh-client-ui-slots` 是 Web 客户端 slot 系统的纯核心：每个 UI 功能都经由它组合的类型级约定。一次 `register({ name, children?, store?, inject?, ...kind }, Component)` 调用会向已声明 slot 贡献一个组件，同时声明子 slot、store 席位与注册方的业务表层。组件会在调用点依据 `ComposedProps` 接受类型检查——该类型是四个 share 的交集，每个 share 都从各自的唯一真源派生——因此错误的组合在编译期就会失败。chain-kind slot 会反转键控路由：条目通过纯 selector 自行提名，而不是由分发点选择 `entryKey`。本包在运行时与 Cordis 无关（仅使用 React 类型）；`ui-renderer` 拥有引擎实现与 React 绑定。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+编写客户端插件时都通过本包组合 UI：把组件注册进父级已声明的 slot，或声明组件将要渲染的子 slot。四种 kind 覆盖组合形态——`single`（单个占位者）、`list`（有序条目）、`keyed`（按键分派）与 `chain`（条目自行提名）。
+
+### 四个 props share
+
+每个已注册组件都会收到由四个 share 组合而成的 props：运行时 share（父级 renderSlot 调用点的 `owner`，加上会话标准工具包与全局席位）、child render share（静态缩窄到已声明 children key 的 `renderSlot`）、store share（已声明 handle 的 selector 钩子与移除 draft 的 actions），以及业务 share（从 `inject` factory 返回值推断）。组件引用 `ComposedProps`；它们绝不在本地重新输入任何 share。
+
+### Store 席位
+
+register 调用可以用 `store: defineStore(...)` 声明 store 席位：`init` 推断状态 schema，`actions` 是完整的 draft-transform 写入集合。组件经 selector 钩子读取、经烘焙回调写入；`defineStore` 的引擎实现位于 runtime 包，并满足这里导出的 `DefineStore` 约定。
+
+### 声明纪律
+
+声明即认领：注册条目成为唯一被允许渲染该键的条目；注册未声明 slot、声明已声明过的子项、在两个 scope 下挂载同一个共享 handle、或注册缺少 `select` 的 chain，都会在加载时抛出。条目的 disposer 会递归移除其声明的子 slot——账本行、贡献与 store 挂载都随同一生命周期结束而移除。
+
+-----
 
-一次 `register({ name, children?, store?, inject?, ...kind }, Component)` 调用会向已声明 slot 贡献一个组件，同时声明子 slot（声明 = 渲染授权 = 运行时规范，三者共用一张表）、store seat 以及注册方的业务表层。组件会在调用点依据 `ComposedProps` 接受类型检查；该类型是四个 share 的交集，每个 share 都从各自的唯一真源派生：
+<a id="understand-the-implementation"></a>
+## 理解实现
 
-| share | 类型 | 来源 |
-|---|---|---|
-| 运行时 | `PropsRuntime<K>` | SlotMap 条目：`owner`（父级 renderSlot 调用点）+ 会话标准工具包 + 全局 seat |
-| child render | `PropsRenderSlots<S>` | register 调用的 `children` key 集合（静态缩窄的 `renderSlot`） |
-| store | `PropsStore<H>` | 已声明 handle：`useStore` selector 钩子 + 移除 draft 的 `actions` |
-| business | `I` | 从 `inject` factory 返回值推断 |
+<details>
+<summary>实现细节——点击展开</summary>
 
-chain-kind slot 会反转键控路由：条目自行提名，而不是由分发点选择 `entryKey`。每次注册都携带一个纯 `ChainSelect` selector（另有可选的升序 `priority`，相同值按注册顺序处理）；第一个非 null 返回值选中其条目，并成为组件的 `matched` prop；全部返回 null 时则使用 owner 的 `renderSlotChain` fallback（`ChainRenderOpts`）。
+设计就是一张表：声明 = 渲染授权 = 运行时规范。`SlotMap` 在这里声明为空，由消费方通过 `declare module` 增补合并，标准工具包接口（`SessionStandardProps`、`GlobalStandardProps`）也是如此，由 runtime 包以真实成员合并。
 
-标准工具包接口（`SessionStandardProps`、`GlobalStandardProps`）在这里声明为空，由运行时包合并（与 SlotMap key 相同的 declare-merge 模式）。renderer 会把运行时会话和 Workspace observable source 绑定为 selector 钩子。Inject factory 参数从声明派生（`InjectParams`）：会话 slot 获得 `sessionId`；声明 store 时追加 baked `actions`；没有其他参数，数据访问位于 apply 闭包的 ctx 中。
+### 注册与路由
 
-store 家族（输入 `defineStore` 规范／输出 `StoreHandle<T, A>`）为 store seat 建模：`init` 推断状态 schema；`actions` 是完整的 draft-transform 写入集合；`BakedActions` 移除 draft 参数，成为组件和 inject factory 收到的回调。`defineStore` 值实现位于运行时包（引擎所属位置），并满足这里导出的 `DefineStore` 约定。引擎产物与 renderer host 约定携带裸快照 source（`getSnapshot`／`subscribe`），绝不携带 React 钩子；钩子绑定属于渲染机制，只有 props 约定钩子类型（`SnapshotSelectorHook`）位于这里。
+`SlotCore` 在构造时预置 `'root'` slot，并强制执行加载时验证。`ChainSelect` selector 按升序 `priority` 运行（相同值按注册顺序）；第一个非 null 返回值选中其条目，并成为组件的 `matched` prop；全部返回 null 时使用 owner 的 `renderSlotChain` fallback（`ChainRenderOpts`）。每个 key 都携带一个 declaration epoch，它只在声明与移除时递增；`ui-renderer` 将其用于 `ctx.slots.inject`，且与普通条目版本相互独立。
 
-`SlotCore` 在构造时预置 `'root'` slot，并强制执行加载时验证（注册未声明 slot、重复声明子项、在两个 scope 下使用同一个共享 handle、chain 注册缺少 `select`，这些情况都在 register 时抛出）。条目的 disposer 会递归移除其声明的子 slot：账本行、贡献和 store 挂载都会随同一生命周期结束而移除。每个 key 还携带一个 declaration epoch（声明代次），它只在声明与移除时递增；运行时将其用于 [`ctx.slots.inject`](../runtime/README.zh.md#slot-declaration-injection)，且与普通条目版本相互独立。`renderer.ts` 携带安装约定（`SlotRenderer`、`SlotRendererHost`）以及 `StaleAuthorizationError`／`SlotOwnershipError`；ui-renderer 同时持有实现及其插件生命周期安装。
+### 渲染器约定
 
+`renderer.ts` 携带安装约定（`SlotRenderer`、`SlotRendererHost`）以及 `StaleAuthorizationError`/`SlotOwnershipError`；ui-renderer 同时持有实现及其插件生命周期安装。引擎产物与渲染器宿主约定携带裸快照 source（`getSnapshot`/`subscribe`），绝不携带 React 钩子——钩子绑定属于渲染机制。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+以下页面覆盖引擎、渲染器与组合模型。
+
+- [Slot 声明注入决策](../../../.agents/notes/implemented/architecture/2026-08-05-slot-declaration-injection.zh.md)——`ctx.slots.inject` 背后的生命周期规则。
+- [ui-renderer](../ui-renderer/README.zh.md)——实现本包安装约定的 React slot 渲染器。
+- [slot 系统标准](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.zh.md)——权威组合模型。
+- [Web 客户端架构](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.zh.md)——本注册表接入的加载链与对象层。
+
+-----
+
+<a id="model-experience"></a>
 ## 模型体验
 
-无。slot 注册表属于浏览器侧 UI 接线；这里没有任何内容进入模型请求。
+无。该包是浏览器端 UI 接线层，不注册任何面向模型的内容。
 
 #### KV Cache 影响
 
 无；该包既不组装也不发送提供方请求。
 
-## 已知限制与暂缓事项
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制定义注册表的扩展行为与已接受的类型噪声；它们是当前包约束。
 
 - **`isLive` 会线性扫描所有记录**：在 UI 插件的注册规模（数十项）下没有问题；如果账本变得频繁访问，再使用条目→记录反向引用改进。
 - **`__renders` 幻象锚点在 `PropsRenderSlots` 上可见**：这是与类型链设计的 `__accepts` 相同且已接受的噪声；泛型方法签名在 key 联合之间比较宽松，因此必须依靠逆变标记强制执行「组件 key 集合 ⊆ children 声明」。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -1,4 +1,12 @@
 //#region lib/types/renderer.js
+/**
+* Convert one standard source name to its rendered Hook prop name.
+* @param name - registered fixed or keyed source name.
+* @returns the `use<Name>` prop exposed to Slot components.
+*/
+function standardHookPropName(name) {
+	return `use${name[0]?.toUpperCase() ?? ""}${name.slice(1)}`;
+}
 /** Thrown when a retained renderSlot binding is invoked after its declaring entry was disposed. */
 var StaleAuthorizationError = class extends Error {};
 /**
@@ -420,6 +428,6 @@ var SlotCore = class {
 	}
 };
 //#endregion
-export { SlotCore, SlotOwnershipError, StaleAuthorizationError, resolveSlotLabel };
+export { SlotCore, SlotOwnershipError, StaleAuthorizationError, resolveSlotLabel, standardHookPropName };
 
 //# sourceMappingURL=index.js.map

package/lib/invariant.js

@@ -10,7 +10,7 @@ const name = "client-ui-slots-invariant";
 const inject = ["invariants"];
 /**
 * No runtime invariant: a zero-dependency pure registry core — it emits no
-* cordis events itself (the runtime SlotRegistry wrapper owns the event
+* cordis events itself (the `ui-renderer` SlotRegistry owns the event
 * bridge and its invariants); define/register/dispose sequencing is asserted
 * directly by this package's behavior specs.
 */

package/lib/types/index.d.ts

@@ -9,8 +9,8 @@
  * the augmented module, not with re-exports.
  */
 import type { ReactNode } from 'react';
+import type { BoundActions, HandleOf, PropsStore, SnapshotSelectorHook, StoreDecl } from '@deepseek-ai/dsh-client-store';
 import type { HostObservable } from './renderer.ts';
-import type { BoundActions, HandleOf, PropsStore, SnapshotSelectorHook, StoreDecl } from './store.ts';
 export * from './store.ts';
 export * from './renderer.ts';
 /** Slot contract table. Owners extend via declaration merging; entries are {@link SlotEntryDef}. */
@@ -155,28 +155,29 @@ export type SlotInjectOf<K extends keyof SlotMap & string> = SlotMap[K] extends
 export type ScopeOf<K extends keyof SlotMap & string> = SlotMap[K]['scope'];
 /**
  * Framework standard kit delivered to every session-scope slot component.
- * Declared EMPTY here (zero-dependency layer): the runtime package merges the
- * real members (`useSession` bound to the conversation snapshot and the
- * framework-supplied `sessionId`) exactly as consumers merge SlotMap keys.
+ * Declared empty here (zero-dependency layer): `ui-session` merges the
+ * Session lifecycle hook, projection hook, and Session identity; domain UI
+ * adapters merge their own standard hooks exactly as consumers merge SlotMap keys.
  */
 export interface SessionStandardProps {
 }
 /**
  * Framework standard kit delivered to current-session-optional slots. Its
  * hooks stay callable while no session is selected and return `undefined`
- * until one becomes current; concrete members merge in at runtime packages.
+ * until one becomes current; `ui-session` and domain UI adapters merge the
+ * concrete members.
  */
 export interface SessionMaybeStandardProps {
 }
 /**
  * Framework standard kit delivered to EVERY slot component (the global seat).
- * Declared empty here; the runtime package merges the global object-layer
- * selector hooks that shared page composition consumes.
+ * Declared empty here; each owning UI adapter merges the global selector hooks
+ * that shared page composition consumes.
  */
 export interface GlobalStandardProps {
 }
 /**
- * The session id type as the runtime's SessionStandardProps merge declares it
+ * The session id type as `ui-session`'s SessionStandardProps merge declares it
  * (branded); falls back to `string` in programs without the merge (this
  * package's own tests).
  */
@@ -200,12 +201,14 @@ export interface RenderOpts<EntryKey extends string = string> {
 export interface ChainRenderOpts {
     /** The owner's fallback body, rendered when every entry's selector declines. */
     fallback?: ReactNode;
+    /** Render only the owner fallback without resolving or dispatching the chain's scope. */
+    fallbackOnly?: boolean;
     /**
      * Keep the fallback permanently mounted: an election hides it (wrapped,
      * display:none) instead of unmounting it, and the all-decline case shows it
      * as-is — fallback-held state (composer drafts, DOM state) survives a
-     * takeover. Chain kind only. Sole consumer today: the
-     * 'conversation.composer' chain.
+     * takeover. Chain kind only; the sole consumer is the
+     * `conversation.composer` chain.
      */
     overlay?: boolean;
 }
@@ -249,23 +252,17 @@ type RenderSlotFn<S extends keyof SlotMap & string> = ([ContextualKeysOf<S>] ext
 export type MatchedShare<E extends SlotEntryDef, M> = E['kind'] extends 'chain' ? {
     matched: M;
 } : object;
-/**
- * Conversation-session selector hook alias for props contracts. Wide by
- * default at this dependency-inverted layer; the runtime narrows at its
- * export outlet (`UseSession<ConversationSnapshot>`).
- */
-export type UseSession<Snap extends object = object> = SnapshotSelectorHook<Snap>;
-/** Props of the standard-kit SessionProvider seat (render-prop form). */
+/** Props of the standard-kit SessionProvider seat. */
 export interface SessionAreaProps {
     /** No-session body (also covers a current id whose session cannot be resolved). */
     empty?: (() => ReactNode) | undefined;
-    /** Session body; the framework remounts it per session (key=sessionId). */
-    children: (sessionId: SessionIdOf) => ReactNode;
+    /** Session body; the framework remounts it per session identity. */
+    children: ReactNode;
 }
 /**
- * Framework-wired session area component. It subscribes to runtime-owned
- * session selection and is injected into entries that declare session-scoped
- * children; business code does not import it directly.
+ * Framework-wired session area component. `ui-session` supplies the current
+ * Controller binding through the renderer scope adapter; entries that declare
+ * session-scoped children receive this component without importing it.
  */
 export type SessionProviderComponent = (props: SessionAreaProps) => ReactNode;
 /**

package/lib/types/renderer.d.ts

@@ -1,6 +1,8 @@
 /** React-free contracts between the slot host and an installed renderer. */
+import type { Context } from '@deepseek-ai/cordis';
 import type { ReactNode } from 'react';
-import type { SlotEntryDef, SlotSpec, StoredEntry, Translate } from './index.ts';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { SessionAreaProps, SlotEntryDef, SlotScope, SlotSpec, StoredEntry, Translate } from './index.ts';
 /**
  * The locale face the render machinery consumes: namespace binding plus an
  * observable revision (getSnapshot/subscribe pair — the same HostObservable
@@ -8,7 +10,7 @@ import type { SlotEntryDef, SlotSpec, StoredEntry, Translate } from './index.ts'
  * active-locale or registry change; the renderer re-derives each entry's `t`
  * from (namespace, revision), so a locale switch hands out NEW function
  * references and memoized components re-render naturally. Implemented by the
- * locale plugin, installed through the runtime SlotRegistry (installLocale).
+ * locale plugin, installed through the `ui-renderer` SlotRegistry.
  * Install before the first render that needs the seat: outlets bind their
  * revision subscription at mount, and a face appearing later has no channel
  * to notify already-mounted outlets (the locale plugin is immediately-tier
@@ -27,11 +29,14 @@ export interface LocaleFace extends HostObservable<{
      */
     bind(ns: string): Translate;
 }
-/** Minimal observable API for host-provided standard-kit data sources. */
-export interface HostObservable<T> {
-    getSnapshot(): T;
-    subscribe(fn: () => void): () => void;
-}
+/** Observable currency shared by domain sources, stores, and the renderer. */
+export type HostObservable<T> = ObservableSnapshot<T>;
+/**
+ * Convert one standard source name to its rendered Hook prop name.
+ * @param name - registered fixed or keyed source name.
+ * @returns the `use<Name>` prop exposed to Slot components.
+ */
+export declare function standardHookPropName(name: string): string;
 /**
  * Type-erased store instance face at the render boundary (the typed twin is
  * {@link StoreInstance}): a bare snapshot source plus the draft-stripped
@@ -49,42 +54,53 @@ export interface StoreInstanceLike {
     subscribe(fn: () => void): () => void;
     readonly actions: Record<string, (...params: never[]) => void>;
 }
+/** Resolve one member of an open-key standard hook family. */
+export type KeyedStandardSource = (key: string) => HostObservable<unknown> | undefined;
 /**
- * Per-session standard props resolved per session id (identity-stable per
- * session scope; a recreated scope yields a new info). Plugins contribute
- * members through the runtime `sessions.provide` contract; the render side binds
- * every `hooks` source into a `use<Name>` selector hook (hooks never appear
- * on the host contract) and spreads `props` verbatim. The runtime itself
- * contributes the first entry (`'session'` → `useSession`).
+ * Framework-neutral inputs from which the renderer materializes standard
+ * props. A scope adapter keeps member names present while its binding is
+ * absent so optional slots retain a stable Hook call order.
  */
-export interface SessionMaybeProvideInfo {
-    /** Current session id, absent while the application is in no-session mode. */
-    sessionId: string | undefined;
+export interface StandardSourceBinding {
+    /** Scope identity; absent for root data and an optional scope with no selection. */
+    readonly key: string | undefined;
+    /** Fixed-name sources; each `name` becomes a `useName` selector Hook. */
+    readonly hooks: Readonly<Record<string, HostObservable<unknown> | undefined>>;
+    /** Open-key source families; each `name` becomes a `useName(key, selector)` Hook. */
+    readonly keyedHooks: Readonly<Record<string, KeyedStandardSource | undefined>>;
+    /** Stable plain values copied into standard props. */
+    readonly props: Readonly<Record<string, unknown>>;
+}
+/** Materialized binding for one live non-root scope. */
+export interface ScopedStandardSourceBinding extends StandardSourceBinding {
+    readonly key: string;
+    readonly ctx: Context;
+}
+/** One installed source of bindings for a non-root Slot scope. */
+export interface SlotScopeAdapter {
+    /** Binding that follows the current selection, including its absent projection. */
+    readonly current: HostObservable<StandardSourceBinding>;
     /**
-     * Static hook roster. Each value is absent with the session; keys remain so
-     * session-maybe entries always receive the same hook-shaped standard kit.
+     * Resolve an already-materialized binding.
+     * @param key - scope identity.
+     * @returns the binding, or `undefined` when the identity is unavailable.
      */
-    hooks: Record<string, HostObservable<unknown> | undefined>;
-    /** Static plain-member roster; values are undefined with the session. */
-    props: Record<string, unknown>;
+    resolve(key: string): ScopedStandardSourceBinding | undefined;
     /**
-     * Key-addressed projection value sources (the useProjection framework seat;
-     * session-projection subsystem page: docs/subsystems/session-projection.md).
-     * Unlike `hooks`, the key space is open — values
-     * arrive from host-computed push frames — so the render side binds per
-     * resolved key instead of per static roster member. Faces are always
-     * defined per key (absence is an `undefined` snapshot); the whole member is
-     * absent with the session.
+     * Render the scope owner's area seat over the current binding. The renderer
+     * binds this function to the standard `SessionProvider` prop without owning
+     * Session selection semantics.
+     * @param binding - current scope binding, including its absent projection.
+     * @param props - render-prop body and empty branch.
+     * @returns rendered scope area.
      */
-    projections?: {
-        faceOf(key: string): HostObservable<unknown>;
-    } | undefined;
+    renderArea?(binding: StandardSourceBinding, props: SessionAreaProps): ReactNode;
 }
-/** Definite per-session standard props resolved for strict session slots. */
-export interface SessionProvideInfo extends SessionMaybeProvideInfo {
-    sessionId: string;
-    /** Bare observable sources, keyed by hook base name ('session' → useSession). */
-    hooks: Record<string, HostObservable<unknown>>;
+/** Root standard-source contribution installed by one domain UI package. */
+export interface RootStandardSourceContribution {
+    readonly hooks?: Readonly<Record<string, HostObservable<unknown>>>;
+    readonly keyedHooks?: Readonly<Record<string, KeyedStandardSource>>;
+    readonly props?: Readonly<Record<string, unknown>>;
 }
 /** renderSlot dispatch options at the machinery level. */
 export interface RenderOpts {
@@ -94,7 +110,7 @@ export interface RenderOpts {
     /** Opaque occurrence context consumed only by function-valued injected Hooks. */
     hookContext?: unknown;
 }
-/** Host API the runtime SlotRegistry presents to the installed renderer. */
+/** Host API the `ui-renderer` SlotRegistry presents to its React renderer. */
 export interface SlotRendererHost {
     /**
      * Subscribe to a key's registration changes (microtask-batched).
@@ -154,28 +170,21 @@ export interface SlotRendererHost {
      * Resolve (create or return cached) the store instance for an entry's
      * declared handle under a scope key; lifecycle rides the ledger axis.
      * @param entry - entry whose declaration carries the handle.
-     * @param scopeKey - session id for session-scope slots, undefined for root scope.
+     * @param scopeBinding - exact Session binding for scoped slots, undefined for root scope.
      * @returns the instance, or undefined when the entry declares no store.
      */
-    storeOf(entry: StoredEntry, scopeKey: string | undefined): StoreInstanceLike | undefined;
-    /** Session-side standard-kit sources. */
-    sessions: {
-        /** Session list source backing the useSessions standard hook. */
-        list: HostObservable<unknown>;
-        /**
-         * Atomic current-session provide projection used by SessionProvider:
-         * selection changes and provider-roster changes publish through this one
-         * source, so a stable current id cannot strand mounted entries on an
-         * obsolete hook/prop schema. Carries the static roster with sessionId
-         * undefined while no current session resolves.
-         */
-        provideInfo: HostObservable<SessionMaybeProvideInfo>;
-    };
-    /** Workspace-side standard-kit sources. */
-    workspaces: {
-        /** Workspace list source backing the useWorkspaces standard hook. */
-        list: HostObservable<unknown>;
-    };
+    storeOf(entry: StoredEntry, scopeBinding: ScopedStandardSourceBinding | undefined): StoreInstanceLike | undefined;
+    /** Root standard data assembled from domain-owned contributions. */
+    readonly root: HostObservable<StandardSourceBinding>;
+    /** Monotonic source updated whenever the installed scope-adapter roster changes. */
+    readonly scopeRevision: HostObservable<number>;
+    /**
+     * Resolve the adapter installed for one non-root scope.
+     * `session` and `session-maybe` intentionally resolve the same adapter.
+     * @param scope - Slot scope.
+     * @returns adapter, or `undefined` when the composition omitted its owner.
+     */
+    scope(scope: Exclude<SlotScope, 'root'>): SlotScopeAdapter | undefined;
     /**
      * Installed locale face backing the `t` standard seat (absent until the
      * locale plugin installs one; rendering an entry that declared `locale:`
@@ -183,7 +192,7 @@ export interface SlotRendererHost {
      */
     locale?: LocaleFace | undefined;
 }
-/** The installation contract: runtime owns install()/renderSlot(); ui-renderer implements rendering. */
+/** The installation contract between the `ui-renderer` SlotRegistry and its React renderer. */
 export interface SlotRenderer {
     /**
      * Render the root slot tree over the host API (the only ctx-level entry).

package/lib/types/store.d.ts

@@ -1,111 +1,3 @@
-/** Framework-neutral store contracts for slot registrations and the runtime engine. */
-/**
- * Typed selector hook over a snapshot source. Canonical shape for the whole
- * slot system (ui-renderer's engine hook is structurally identical; the
- * framework is the only party that ever constructs one).
- */
-export type SnapshotSelectorHook<T> = <S>(sel: (s: T) => S, eq?: (a: S, b: S) => boolean) => S;
-/**
- * Selector hook over a source that follows the current session. The hook is
- * always present, while its selected value is absent whenever no session is
- * current. This keeps hook call sites stable across no-session/session
- * transitions without pretending that a session snapshot exists.
- */
-export type MaybeSnapshotSelectorHook<T> = <S>(sel: (s: T) => S, eq?: (a: S, b: S) => boolean) => S | undefined;
-/**
- * Action declaration table: pure immer-draft transforms over the store state,
- * declared as the store's complete write set (the audit face — components can
- * only write through these).
- */
-export type ActionsDecl<T> = Record<string, (draft: T, ...params: any[]) => void>;
-/**
- * Draft-stripped callback form of an actions table: what components
- * (`props.actions`) and inject factories receive — the framework bakes the
- * draft parameter away by binding each action to the resolved instance.
- */
-export type BakedActions<T, A extends ActionsDecl<T>> = {
-    [K in keyof A]: A[K] extends (draft: T, ...params: infer P) => void ? (...params: P) => void : never;
-};
-/**
- * Store declaration spec: initial-state factory (a lambda so every instance
- * gets a fresh state), optional persistence key (mechanical, framework-run),
- * and the actions write set.
- */
-export interface StoreSpec<T, A extends ActionsDecl<T>> {
-    init: () => T;
-    persist?: string;
-    actions: A;
-}
-/**
- * Live engine instance: the create() product consumed by the render machinery
- * and by tests. A bare snapshot source plus the baked write set — no React
- * hook rides the engine product (the engine lives in the React-free runtime);
- * the render machinery binds the `useStore` hook from this source on its own
- * side, cached per instance. Production components and render paths never
- * call create() themselves — instance lifecycle is the framework's.
- */
-export interface StoreInstance<T, A extends ActionsDecl<T>> {
-    readonly actions: BakedActions<T, A>;
-    getSnapshot(): T;
-    /**
-     * Subscribe to state changes (uSES subscribe side).
-     * @param fn - change callback.
-     * @returns unsubscribe.
-     */
-    subscribe(fn: () => void): () => void;
-    /**
-     * Drop this instance's persisted value (no-op for non-persist specs). The
-     * framework calls it when the owning scope dies for good — a pruned session
-     * must not leave orphaned storage keys behind.
-     */
-    clearPersisted(): void;
-}
-/**
- * Store handle: spec + state/actions types + shared identity + instance
- * factory in one value. Handles are constructed in apply world (shared across
- * registrations of one plugin) or by the framework from a registrant's
- * factory (exclusive). Never export a handle at module level — module-cache
- * identity is a disguised singleton across plugin reloads.
- */
-export interface StoreHandle<T, A extends ActionsDecl<T>> {
-    readonly spec: StoreSpec<T, A>;
-    /**
-     * Create a live engine instance (framework machinery and tests only).
-     * @param scopeKey - session id for session-scope instances; suffixes the
-     * persist key so per-session instances persist independently (root-scope
-     * instances omit it).
-     * @returns a fresh instance seeded from `spec.init()`.
-     */
-    create(scopeKey?: string): StoreInstance<T, A>;
-}
-/**
- * Exclusive-store registration form: the registrant passes the factory itself
- * and the framework calls it per entry x scope (no shared identity exists).
- */
-export type StoreFactory = () => StoreHandle<any, any>;
-/** The register `store` option position: a shared handle or an exclusive factory. */
-export type StoreDecl = StoreHandle<any, any> | StoreFactory;
-/** Normalize a store declaration to its handle type (factories yield their return). */
-export type HandleOf<H> = H extends () => infer R ? R : H;
-/**
- * Handle-keyed baked actions: the `actions` parameter of an inject factory
- * whose registration declared a store — the same baked callback set the
- * component receives via {@link PropsStore}.
- */
-export type BoundActions<H> = H extends StoreHandle<infer T, infer A> ? BakedActions<T, A> : never;
-/**
- * The store props share, derived from the declared handle: a typed selector
- * hook plus the baked write set. Components never see the instance itself
- * (no update/set — reads via useStore, writes via the declared actions only).
- */
-export type PropsStore<H> = H extends StoreHandle<infer T, infer A> ? {
-    useStore: SnapshotSelectorHook<T>;
-    actions: BakedActions<T, A>;
-} : object;
-/**
- * The defineStore contract (implementation lives in the runtime package,
- * bound to the snapshot-store engine): spec in, handle out, with T inferred
- * from `init` and the actions table constrained by T.
- */
-export type DefineStore = <T, A extends ActionsDecl<T>>(spec: StoreSpec<T, A>) => StoreHandle<T, A>;
+/** Slot-facing re-exports of the React-free store contracts. */
+export type { ActionsDecl, BakedActions, BoundActions, DefineStore, HandleOf, MaybeSnapshotSelectorHook, PropsStore, SnapshotSelectorHook, StoreDecl, StoreFactory, StoreHandle, StoreInstance, StoreSpec, } from '@deepseek-ai/dsh-client-store';
 //# sourceMappingURL=store.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-slots",
   "description": "Slot registry pure core: SlotMap declaration merging, single register composition API, four-share props types, store-seat types, renderer install seam",
-  "version": "0.1.1-rc.2",
+  "version": "0.1.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -28,8 +28,9 @@
   "license": "MIT",
   "devDependencies": {
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2"
+    "@deepseek-ai/dsh-client-store": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/cordis": "^4.0.2"
   },
   "files": [
     "lib/index.js",
@@ -37,7 +38,6 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.2"
   }
 }