@prettier-ai/dsh-client-ui-session 0.1.2-alpha.1

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/ui-session/README.md
+README.md: a98692cab4c40a53d7e4b78eec91a45af85fe76f
+README.zh.md: 4b8e26da6b7255bd90af853315ad551c2ad85801

package/README.md

@@ -0,0 +1,45 @@
+---
+description: "React and Slot adapters for Session Controller lists, interaction state, and per-session context."
+kind: "package-reference"
+---
+# @deepseek-ai/dsh-client-ui-session
+
+English | [中文](README.zh.md)
+
+## Summary
+
+React and Slot adapter for Session Controller state. It contributes Session list and pending-interaction hooks at root scope, materializes per-Session hooks and props, and owns the standard `SessionProvider` rendering behavior without taking ownership of Session transport or lifecycle state. Use it when a browser feature needs Session state through standard React props and hooks.
+
+## Table of Contents
+
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as this package adapts browser-side Session state and registers nothing model-facing.
+
+#### KV Cache effect
+
+None; Session selectors and Slot scopes do not assemble model requests.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Pending interactions are process-local projections** — the owning Remote waterfall must replay an outstanding request after a browser reconnect.
+
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,45 @@
+---
+description: "面向 Session Controller 列表、交互状态与逐会话上下文的 React 与 Slot 适配器。"
+kind: "package-reference"
+---
+# @deepseek-ai/dsh-client-ui-session
+
+[English](README.md) | 中文
+
+## 概述
+
+面向 Session Controller 状态的 React 与 Slot adapter。本包在 root scope 提供 Session list 和 pending-interaction hook，物化逐 Session hook 与 prop，并拥有标准 `SessionProvider` 渲染行为，但不接管 Session transport 或 lifecycle 状态。当浏览器功能需要通过标准 React prop 和 hook 读取 Session 状态时，请使用它。
+
+## 目录
+
+- [模型体验](#model-experience)
+- [已知限制与暂缓事项](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+无，因为本包适配浏览器侧 Session 状态，不注册任何面向模型的内容。
+
+#### KV Cache 影响
+
+无；Session selector 与 Slot scope 不会组装模型请求。
+
+## 已知限制与暂缓事项
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Pending interaction 是进程本地投影**——浏览器重连后，所属 Remote waterfall 必须重放仍未完成的请求。
+
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/client.js

@@ -0,0 +1,340 @@
+window.__ModuleLoader__.load({
+	id: "@prettier-ai/dsh-client-ui-session",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _prettier_ai_cordis = require("@prettier-ai/cordis");
+		let _prettier_ai_dsh_client_store = require("@prettier-ai/dsh-client-store");
+		let _prettier_ai_dsh_client_ui_slots = require("@prettier-ai/dsh-client-ui-slots");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let react = require("react");
+		//#region lib/types/client/session-provider.js
+		/** Session-owned rendering semantics for the standard SessionProvider seat. */
+		/**
+		* Render the selected Session body or its empty branch.
+		* @param binding - current Session scope binding.
+		* @param props - standard Session area render props.
+		* @returns the selected Session subtree, keyed by Session identity.
+		*/
+		function renderSessionArea(binding, { empty, children }) {
+			const sessionId = binding.key;
+			if (sessionId === void 0) return (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: empty?.() ?? null });
+			return (0, react_jsx_runtime.jsx)(react.Fragment, { children }, sessionId);
+		}
+		//#endregion
+		//#region lib/types/client/index.js
+		/** Session Controller adapter for React selector hooks and Slot scope data. */
+		var PendingInteractionDomain = class {
+			precedence;
+			changed;
+			values = /* @__PURE__ */ new Map();
+			constructor(precedence, changed) {
+				this.precedence = precedence;
+				this.changed = changed;
+			}
+			valuesSnapshot() {
+				return [...this.values.values()].map((entry) => entry.interaction);
+			}
+			publish(interaction, delegate) {
+				if (this.values.has(interaction.key)) throw new Error(`ui-session: duplicate pending interaction key '${interaction.key}'`);
+				this.values.set(interaction.key, {
+					interaction,
+					delegate
+				});
+				this.changed();
+				let active = true;
+				return () => {
+					if (!active) return;
+					active = false;
+					if (!this.values.delete(interaction.key)) return;
+					this.changed();
+				};
+			}
+			/** Remove every pending value and return the operations that settle their owners. */
+			release() {
+				const delegates = [...this.values.values()].map((entry) => entry.delegate);
+				this.values.clear();
+				return delegates;
+			}
+		};
+		const BUILTIN_SOURCE = {
+			hooks: ["session"],
+			keyedHooks: ["projection"],
+			props: ["sessionId"],
+			resolve: (binding) => ({
+				hooks: { session: binding.session },
+				keyedHooks: { projection: (key) => binding.session.projections.faceOf(key) },
+				props: { sessionId: binding.sessionId }
+			})
+		};
+		/** Session-scoped source roster and renderer adapter. */
+		var UiSession = class extends _prettier_ai_cordis.Service {
+			sessions;
+			descriptors = [BUILTIN_SOURCE];
+			bindings = /* @__PURE__ */ new Map();
+			absent;
+			currentBinding;
+			currentListeners = /* @__PURE__ */ new Set();
+			pendingDomains = [];
+			pendingSnapshot = /* @__PURE__ */ new Map();
+			pendingListeners = /* @__PURE__ */ new Set();
+			/** Root source of pending UI interactions, independent from Controller snapshots. */
+			pendingInteractions = {
+				getSnapshot: () => this.pendingSnapshot,
+				subscribe: (listener) => {
+					this.pendingListeners.add(listener);
+					return () => {
+						this.pendingListeners.delete(listener);
+					};
+				}
+			};
+			/** Renderer-facing adapter for `session` and `session-maybe` scopes. */
+			adapter;
+			/**
+			* @param ctx - Client root context.
+			* @param sessions - Controller-owned Session object layer.
+			*/
+			constructor(ctx, sessions) {
+				super(ctx, "uiSession");
+				this.sessions = sessions;
+				this.absent = this.materializeAbsent();
+				this.currentBinding = this.resolveCurrent();
+				this.adapter = {
+					current: {
+						getSnapshot: () => this.currentBinding,
+						subscribe: (listener) => {
+							this.currentListeners.add(listener);
+							return () => {
+								this.currentListeners.delete(listener);
+							};
+						}
+					},
+					resolve: (key) => this.resolve(key),
+					renderArea: renderSessionArea
+				};
+				ctx.effect(() => {
+					const disposeList = sessions.list.subscribe(() => {
+						this.publishCurrent();
+					});
+					return () => {
+						disposeList();
+						const records = [...this.bindings.values()];
+						this.bindings.clear();
+						for (const record of records) record.release();
+					};
+				}, "ui-session: Session binding projection");
+			}
+			/**
+			* Register one Session-scoped standard-source contribution.
+			* @param descriptor - static member roster and per-binding resolver.
+			* @returns disposer owned by the caller's Cordis fiber.
+			*/
+			provide(descriptor) {
+				const runtimeDescriptor = descriptor;
+				const dispose = this.ctx.effect(() => {
+					this.descriptors.push(runtimeDescriptor);
+					try {
+						this.rebuildBindings();
+					} catch (error) {
+						this.descriptors.pop();
+						throw error;
+					}
+					return () => {
+						const index = this.descriptors.indexOf(runtimeDescriptor);
+						this.descriptors.splice(index, 1);
+						this.rebuildBindings();
+					};
+				}, "uiSession.provide()");
+				return () => {
+					dispose();
+				};
+			}
+			/**
+			* Register one pending-interaction domain and return its publication function.
+			* Domain teardown first removes its visible values, then delegates and awaits
+			* every still-active owner request.
+			* @param precedence - deterministic cross-domain precedence; larger values win.
+			* @returns a function that publishes one interaction and its teardown delegation.
+			*/
+			registerPendingInteraction(precedence) {
+				const domain = new PendingInteractionDomain(precedence, () => {
+					this.publishPendingInteractions();
+				});
+				const runtimeDomain = domain;
+				this.ctx.effect(() => {
+					this.pendingDomains.push(runtimeDomain);
+					this.publishPendingInteractions();
+					return async () => {
+						const delegates = domain.release();
+						const index = this.pendingDomains.indexOf(runtimeDomain);
+						this.pendingDomains.splice(index, 1);
+						this.publishPendingInteractions();
+						await Promise.allSettled(delegates.map((delegate) => Promise.resolve().then(delegate)));
+					};
+				}, "uiSession.registerPendingInteraction()");
+				return (interaction, delegate) => domain.publish(interaction, delegate);
+			}
+			rebuildBindings() {
+				const absent = this.materializeAbsent();
+				const bindings = /* @__PURE__ */ new Map();
+				try {
+					for (const [sessionId, cached] of this.bindings) bindings.set(sessionId, this.createMaterializedBinding(cached.owner));
+				} catch (error) {
+					for (const record of bindings.values()) record.release();
+					throw error;
+				}
+				const previous = this.bindings;
+				this.absent = absent;
+				this.bindings = bindings;
+				for (const record of previous.values()) record.release();
+				this.publishCurrent();
+			}
+			resolve(key) {
+				const owner = this.sessions.binding(key);
+				if (owner === void 0) return void 0;
+				const cached = this.bindings.get(key);
+				if (cached?.owner === owner) return cached.value;
+				const record = this.createMaterializedBinding(owner);
+				this.bindings.set(key, record);
+				cached?.release();
+				return record.value;
+			}
+			resolveCurrent() {
+				const current = this.sessions.list.getSnapshot().current;
+				return current === void 0 ? this.absent : this.resolve(current) ?? this.absent;
+			}
+			publishCurrent() {
+				const next = this.resolveCurrent();
+				if (next === this.currentBinding) return;
+				this.currentBinding = next;
+				(0, _prettier_ai_dsh_client_store.notifySubscribers)(this.currentListeners, "[ui-session] current binding");
+			}
+			publishPendingInteractions() {
+				const next = /* @__PURE__ */ new Map();
+				for (const domain of this.pendingDomains) for (const interaction of domain.valuesSnapshot()) {
+					const precedence = domain.precedence(interaction);
+					const previous = next.get(interaction.sessionId);
+					if (previous === void 0 || precedence >= previous.precedence) next.set(interaction.sessionId, {
+						interaction,
+						precedence
+					});
+				}
+				const projected = new Map([...next].map(([sessionId, value]) => [sessionId, value.interaction]));
+				if (samePendingInteractions(this.pendingSnapshot, projected)) return;
+				this.pendingSnapshot = projected;
+				(0, _prettier_ai_dsh_client_store.notifySubscribers)(this.pendingListeners, "[ui-session] pending interactions");
+			}
+			createMaterializedBinding(owner) {
+				const value = this.materialize(owner);
+				const releaseEffect = owner.ctx.effect(() => () => {
+					if (this.bindings.get(owner.sessionId) !== record) return;
+					this.bindings.delete(owner.sessionId);
+					if (this.currentBinding !== value) return;
+					this.currentBinding = this.absent;
+					(0, _prettier_ai_dsh_client_store.notifySubscribers)(this.currentListeners, "[ui-session] current binding");
+				}, `ui-session: binding ${owner.sessionId}`);
+				const record = {
+					owner,
+					value,
+					release: () => {
+						releaseEffect();
+					}
+				};
+				return record;
+			}
+			materialize(binding) {
+				const hooks = {};
+				const keyedHooks = {};
+				const props = {};
+				const finalProps = /* @__PURE__ */ new Set();
+				for (const descriptor of this.descriptors) {
+					const contribution = descriptor.resolve(binding);
+					validateContribution(descriptor, contribution);
+					copyDeclared("hook", hooks, descriptor.hooks, contribution.hooks, finalProps);
+					copyDeclared("keyed hook", keyedHooks, descriptor.keyedHooks, contribution.keyedHooks, finalProps);
+					copyDeclared("prop", props, descriptor.props, contribution.props, finalProps);
+				}
+				const value = {
+					key: binding.sessionId,
+					ctx: binding.ctx,
+					hooks,
+					keyedHooks,
+					props
+				};
+				this.ctx.slots.bindStoreScope(value);
+				return value;
+			}
+			materializeAbsent() {
+				const hooks = {};
+				const keyedHooks = {};
+				const props = {};
+				const finalProps = /* @__PURE__ */ new Set();
+				for (const descriptor of this.descriptors) {
+					declareAbsent("hook", hooks, descriptor.hooks, finalProps);
+					declareAbsent("keyed hook", keyedHooks, descriptor.keyedHooks, finalProps);
+					declareAbsent("prop", props, descriptor.props, finalProps);
+				}
+				return {
+					key: void 0,
+					hooks,
+					keyedHooks,
+					props
+				};
+			}
+		};
+		function validateContribution(descriptor, contribution) {
+			rejectUndeclared("hook", descriptor.hooks, contribution.hooks);
+			rejectUndeclared("keyed hook", descriptor.keyedHooks, contribution.keyedHooks);
+			rejectUndeclared("prop", descriptor.props, contribution.props);
+		}
+		function rejectUndeclared(kind, declared, values) {
+			for (const name of Object.keys(values ?? {})) if (!(declared ?? []).includes(name)) throw new Error(`uiSession.provide: undeclared ${kind} '${name}'`);
+		}
+		function copyDeclared(kind, target, declared, values, finalProps) {
+			for (const name of declared ?? []) {
+				claimStandardProp(kind, name, finalProps);
+				const value = values?.[name];
+				if (value === void 0) throw new Error(`uiSession.provide: missing ${kind} '${name}'`);
+				target[name] = value;
+			}
+		}
+		function declareAbsent(kind, target, declared, finalProps) {
+			for (const name of declared ?? []) {
+				claimStandardProp(kind, name, finalProps);
+				target[name] = void 0;
+			}
+		}
+		function claimStandardProp(kind, name, finalProps) {
+			const propName = kind === "prop" ? name : (0, _prettier_ai_dsh_client_ui_slots.standardHookPropName)(name);
+			if (finalProps.has(propName)) throw new Error(`uiSession.provide: duplicate ${kind} '${name}' at prop '${propName}'`);
+			finalProps.add(propName);
+		}
+		/** Required Controller and renderer services. */
+		const inject = ["sessions", "slots"];
+		/**
+		* Install the Session root source and scoped adapter.
+		* @param ctx - Client Cordis context.
+		*/
+		function apply(ctx) {
+			const service = new UiSession(ctx, ctx.sessions);
+			ctx.slots.provideRoot({ hooks: {
+				sessions: ctx.sessions.list,
+				sessionPendingInteraction: service.pendingInteractions
+			} });
+			ctx.slots.installScope("session", service.adapter);
+		}
+		function samePendingInteractions(left, right) {
+			if (left.size !== right.size) return false;
+			for (const [sessionId, interaction] of left) if (right.get(sessionId) !== interaction) return false;
+			return true;
+		}
+		//#endregion
+		exports.UiSession = UiSession;
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Host loader entry for the browser-only Session UI adapter. */
+/** Provides no Host-side behavior. */
+function apply() {}
+//#endregion
+export { apply };

package/lib/invariant.js

@@ -0,0 +1,16 @@
+//#region lib/types/invariant.js
+const PACKAGE_NAME = "@prettier-ai/dsh-client-ui-session";
+/** Cordis companion plugin name. */
+const name = "client-ui-session-invariant";
+/** Service required before the companion reserves package ownership. */
+const inject = ["invariants"];
+/** No runtime invariant: the adapter materialization path enforces Session binding consistency. */
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer.
+*/
+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,135 @@
+/** Session Controller adapter for React selector hooks and Slot scope data. */
+import { Service, type Context } from '@prettier-ai/cordis';
+import type { ISessions, SessionBinding, SessionListState, SessionSnapshot, UseProjection } from '@prettier-ai/dsh-api-session-controller/client';
+import type { SessionId } from '@prettier-ai/dsh-session/types';
+import type { HostObservable, KeyedStandardSource, MaybeSnapshotSelectorHook, SlotScopeAdapter, SnapshotSelectorHook } from '@prettier-ai/dsh-client-ui-slots';
+/** Selector hook over the Session Controller list and current selection. */
+export type UseSessions = SnapshotSelectorHook<SessionListState>;
+/** Selector hook over one Session's lifecycle and control state. */
+export type SessionSnapshotSelector = SnapshotSelectorHook<SessionSnapshot>;
+/** Public name for the Session lifecycle selector hook. */
+export type UseSession = SessionSnapshotSelector;
+/** Common identity carried by every Session-scoped pending interaction. */
+export interface SessionPendingInteractionBase {
+    /** Opaque request identity; a replacement request must use a new key. */
+    readonly key: string;
+    /** Domain-owned presentation discriminator. */
+    readonly kind: string;
+    /** Session whose UI can answer this interaction. */
+    readonly sessionId: SessionId;
+}
+/** Declaration-merged roster of domain-owned pending interaction values. */
+export interface SessionPendingInteractionMap {
+}
+/** Every pending interaction contributed by the assembled Client. */
+export type SessionPendingInteraction = [
+    keyof SessionPendingInteractionMap
+] extends [never] ? SessionPendingInteractionBase : SessionPendingInteractionMap[keyof SessionPendingInteractionMap];
+/** Current effective pending interaction by Session. */
+export type SessionPendingInteractionSnapshot = ReadonlyMap<SessionId, SessionPendingInteraction>;
+/** Selector hook over Session-scoped pending interactions. */
+export type UseSessionPendingInteraction = SnapshotSelectorHook<SessionPendingInteractionSnapshot>;
+/** Publish one pending interaction and define how plugin teardown delegates it. */
+export type PendingInteractionPublisher<T extends SessionPendingInteractionBase> = (interaction: T, delegate: () => Promise<void>) => () => void;
+declare module '@prettier-ai/dsh-client-ui-slots' {
+    interface GlobalStandardProps {
+        /** Session list and current selection. */
+        useSessions: UseSessions;
+        /** Pending user interaction presented by a Session-scoped UI consumer. */
+        useSessionPendingInteraction: UseSessionPendingInteraction;
+    }
+    interface SessionStandardProps {
+        /** Current Session lifecycle and control state. */
+        useSession: SessionSnapshotSelector;
+        /** Current Session identity. */
+        sessionId: SessionId;
+        /** Host-computed projection values addressed by projection key. */
+        useProjection: UseProjection;
+    }
+    interface SessionMaybeStandardProps {
+        /** Current Session state, absent while no Session is selected. */
+        useSession: MaybeSnapshotSelectorHook<SessionSnapshot>;
+        /** Current Session identity, absent while no Session is selected. */
+        sessionId: SessionId | undefined;
+        /** Host-computed projection values; every key is absent without a Session. */
+        useProjection: UseProjection;
+    }
+}
+declare module '@prettier-ai/cordis' {
+    interface Context {
+        /** Session Controller adapter and session-scoped source registry. */
+        uiSession: UiSession;
+    }
+}
+type SessionSourceRoster = readonly string[] | undefined;
+type SessionSourceRecord<Roster extends SessionSourceRoster, Value> = Roster extends readonly string[] ? Readonly<Record<Roster[number], Value>> : never;
+/** Bare values produced by one Session-scoped source contribution. */
+export interface SessionSourceContribution<Hooks extends SessionSourceRoster = SessionSourceRoster, KeyedHooks extends SessionSourceRoster = SessionSourceRoster, Props extends SessionSourceRoster = SessionSourceRoster> {
+    readonly hooks?: SessionSourceRecord<Hooks, HostObservable<unknown>>;
+    readonly keyedHooks?: SessionSourceRecord<KeyedHooks, KeyedStandardSource>;
+    readonly props?: SessionSourceRecord<Props, unknown>;
+}
+/** Static roster and per-Session resolver for one standard-props contribution. */
+export interface SessionSourceDescriptor<Hooks extends SessionSourceRoster = SessionSourceRoster, KeyedHooks extends SessionSourceRoster = SessionSourceRoster, Props extends SessionSourceRoster = SessionSourceRoster> {
+    readonly hooks?: Hooks;
+    readonly keyedHooks?: KeyedHooks;
+    readonly props?: Props;
+    /**
+     * Resolve every declared member for one Session binding.
+     * @param binding - Controller-owned Session binding.
+     * @returns all declared bare sources and stable props.
+     */
+    resolve(binding: SessionBinding): SessionSourceContribution<NoInfer<Hooks>, NoInfer<KeyedHooks>, NoInfer<Props>>;
+}
+/** Session-scoped source roster and renderer adapter. */
+export declare class UiSession extends Service {
+    private readonly sessions;
+    private readonly descriptors;
+    private bindings;
+    private absent;
+    private currentBinding;
+    private readonly currentListeners;
+    private readonly pendingDomains;
+    private pendingSnapshot;
+    private readonly pendingListeners;
+    /** Root source of pending UI interactions, independent from Controller snapshots. */
+    readonly pendingInteractions: HostObservable<SessionPendingInteractionSnapshot>;
+    /** Renderer-facing adapter for `session` and `session-maybe` scopes. */
+    readonly adapter: SlotScopeAdapter;
+    /**
+     * @param ctx - Client root context.
+     * @param sessions - Controller-owned Session object layer.
+     */
+    constructor(ctx: Context, sessions: ISessions);
+    /**
+     * Register one Session-scoped standard-source contribution.
+     * @param descriptor - static member roster and per-binding resolver.
+     * @returns disposer owned by the caller's Cordis fiber.
+     */
+    provide<const Hooks extends SessionSourceRoster = undefined, const KeyedHooks extends SessionSourceRoster = undefined, const Props extends SessionSourceRoster = undefined>(descriptor: SessionSourceDescriptor<Hooks, KeyedHooks, Props>): () => void;
+    /**
+     * Register one pending-interaction domain and return its publication function.
+     * Domain teardown first removes its visible values, then delegates and awaits
+     * every still-active owner request.
+     * @param precedence - deterministic cross-domain precedence; larger values win.
+     * @returns a function that publishes one interaction and its teardown delegation.
+     */
+    registerPendingInteraction<T extends SessionPendingInteractionBase>(precedence: (interaction: T) => number): PendingInteractionPublisher<T>;
+    private rebuildBindings;
+    private resolve;
+    private resolveCurrent;
+    private publishCurrent;
+    private publishPendingInteractions;
+    private createMaterializedBinding;
+    private materialize;
+    private materializeAbsent;
+}
+/** Required Controller and renderer services. */
+export declare const inject: string[];
+/**
+ * Install the Session root source and scoped adapter.
+ * @param ctx - Client Cordis context.
+ */
+export declare function apply(ctx: Context): void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/session-provider.d.ts

@@ -0,0 +1,11 @@
+/** Session-owned rendering semantics for the standard SessionProvider seat. */
+import { type ReactNode } from 'react';
+import type { SessionAreaProps, StandardSourceBinding } from '@prettier-ai/dsh-client-ui-slots';
+/**
+ * Render the selected Session body or its empty branch.
+ * @param binding - current Session scope binding.
+ * @param props - standard Session area render props.
+ * @returns the selected Session subtree, keyed by Session identity.
+ */
+export declare function renderSessionArea(binding: StandardSourceBinding, { empty, children }: SessionAreaProps): ReactNode;
+//# sourceMappingURL=session-provider.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Host loader entry for the browser-only Session UI adapter. */
+/** Provides no Host-side behavior. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,13 @@
+/** Package-owned invariant companion for the Session UI adapter. */
+import type { Context } from '@prettier-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-ui-session-invariant";
+/** Service required before the companion reserves 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.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@prettier-ai/dsh-client-ui-session",
+  "description": "Session Controller adapter for React and session-scoped slots",
+  "version": "0.1.2-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/client/ui-session"
+  },
+  "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": [
+        "@prettier-ai/dsh-api-session-controller",
+        "@prettier-ai/dsh-client-ui-renderer"
+      ],
+      "platform": "web"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@prettier-ai/cordis": "^4.0.1",
+    "@prettier-ai/dsh-client-ui-renderer": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-api-session-controller": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "@prettier-ai/cordis": "^4.0.1",
+    "@prettier-ai/dsh-client-store": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-client-ui-renderer": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-client-ui-slots": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-invariants": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-api-session-controller": "^0.1.2-alpha.1",
+    "@prettier-ai/dsh-session": "^0.1.2-alpha.1"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
+}