@x1a0f3n9/dsh-client-ui-renderer 0.1.5-rc.4 → 0.1.7-rc.2

package/README.i18n.yaml

@@ -1,6 +1,52 @@
-# 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:
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-renderer/README.md
-README.md: 582de984025c54b5ed6cc12dc3c39f50e5c0df1a
-README.zh.md: f38c0089fcbb8a3fdf741d97a66f0bc2c08fd24d
+/:
+  en: 06bd9d926c743736
+  zh: 39acdcb577fd8c6d
+/x1a0f3n9-dsh-client-ui-renderer:
+  en: 3569f2670b8a1fce
+  zh: 5bbedcc4e539d186
+/x1a0f3n9-dsh-client-ui-renderer/summary:
+  en: cae0bce110641caf
+  zh: e5bde9dba75389bc
+/x1a0f3n9-dsh-client-ui-renderer/table-of-contents:
+  en: d152484eb41ac6b4
+  zh: 09388d293f9be9cb
+/x1a0f3n9-dsh-client-ui-renderer/use-this-package:
+  en: 4873b12ddeac04f2
+  zh: 027845407b207c4f
+/x1a0f3n9-dsh-client-ui-renderer/use-this-package/what-mounting-does:
+  en: 16f8f781e259f0ee
+  zh: aa2b4783807fe943
+/x1a0f3n9-dsh-client-ui-renderer/use-this-package/for-business-plugins:
+  en: 15a2bfee2c0bd051
+  zh: 0c5b336fc5afbbc6
+/x1a0f3n9-dsh-client-ui-renderer/understand-the-implementation:
+  en: 0de0a8ad857b93f6
+  zh: 98a0fae2d6606a7d
+/x1a0f3n9-dsh-client-ui-renderer/understand-the-implementation/activation-and-mount:
+  en: 822adba4ecd1b7e3
+  zh: bab3626fbe30ff55
+/x1a0f3n9-dsh-client-ui-renderer/understand-the-implementation/slot-bindings:
+  en: 6ab26cf5744a23d4
+  zh: 84a531322a724a84
+/x1a0f3n9-dsh-client-ui-renderer/understand-the-implementation/identity:
+  en: 2a349d500ead79cb
+  zh: ac49c8b1d73dcd6c
+/x1a0f3n9-dsh-client-ui-renderer/further-exploration:
+  en: 77b43b2f3d55c933
+  zh: 9847b53486372aeb
+/x1a0f3n9-dsh-client-ui-renderer/model-experience:
+  en: ca4e29db08d34e6d
+  zh: de6ec680414b1d54
+/x1a0f3n9-dsh-client-ui-renderer/model-experience/kv-cache-effect:
+  en: ca75c51c89c2c9b0
+  zh: de54f3467ef3b9be
+/x1a0f3n9-dsh-client-ui-renderer/known-limitations-and-deferred-work:
+  en: 686023788b76788f
+  zh: 2bb3ca909746c485
+/x1a0f3n9-dsh-client-ui-renderer/known-limitations-and-deferred-work/dev-note:
+  en: e67f633dc6fe7773
+  zh: 3bb0c20c93f16f98

package/README.md

@@ -1,5 +1,5 @@
 ---
-description: "Browser UI renderer: React slot bindings, ctx.uiRenderer, and the assembled application root for the dsh web client."
+description: "Browser UI renderer: React bindings for ordinary Slots and reusable Component Factories, ctx.uiRenderer, and the assembled dsh web application root."
 kind: "package-reference"
 ---
 
@@ -33,7 +33,7 @@ This package is infrastructure: the web shell and the boot kernel are its only d
 
 ### For business plugins
 
-A business plugin registers a component through the slot system; the renderer binds the runtime's session and workspace observable sources into selector hooks at the outlet. The plugin receives the standard session props (session id, conversation snapshot hooks) through its composed props — it never imports the renderer or touches React internals.
+A business plugin registers an ordinary Slot entry or a reusable Component Factory; the renderer binds the runtime's session and workspace observable sources into selector hooks at the render position. The plugin receives standard scope props through its derived Component props — it never imports the renderer or touches React internals. Every renderer-created Component can render a Factory occurrence, and a Factory can expose caller-selected local Components without sharing implementation values between packages.
 
 -----
 
@@ -51,7 +51,7 @@ The plugin installs `createSlotRenderer()` and reflects the `uiRenderer` service
 
 ### Slot bindings
 
-`createSlotRenderer` connects the slot registry to React: entry lists become reactive sources, and each outlet renders through the installed renderer. Business plugins pass bare observable sources through typed slot `hooks`; the renderer binds them at the outlet via the uSES adapter.
+`createSlotRenderer` connects the slot registry to React: ordinary entry lists and Factory definitions become reactive sources, and each outlet or occurrence renders through the installed renderer. Business plugins pass bare observable sources through typed `hooks`; the renderer binds them at the render position via the uSES adapter. A Factory Store factory stays lazy until an occurrence first materializes; its exclusive handle rejects persistence, render-time records stay weak, and an idempotent effect strongly retains only mounted occurrences while preserving identity across effect replay. Factory errors use the ordinary supervision channel without abdicating the shared definition: the definition and its fallback local Components report against the definition, caller-selected local Components report against the caller registration, and each boundary resets with its own scope incarnation.
 
 ### Identity
 
@@ -71,6 +71,7 @@ These pages cover the surrounding machinery and the composition model.
 - [ui-session](../ui-session/README.md) — the adapter that supplies the standard Session sources and hooks this renderer binds.
 - [Web client architecture](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.md) — the loading chain, object layer, and layering red lines.
 - [Slot system standard](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.md) — the definitive composition model.
+- [Component Factories](../../../.agents/notes/implemented/architecture/2026-09-10-component-factories-and-local-slots.md) — reusable definitions, local Component selection, and occurrence lifetimes.
 
 -----
 

package/README.zh.md

@@ -1,5 +1,5 @@
 ---
-description: "浏览器 UI 渲染器：React slot 绑定、ctx.uiRenderer 与 dsh Web 客户端组装后的应用根。"
+description: "浏览器 UI 渲染器：普通 Slot 与可复用 Component Factory 的 React 绑定、ctx.uiRenderer 与组装后的 dsh Web 应用根。"
 kind: "package-reference"
 ---
 
@@ -33,7 +33,7 @@ kind: "package-reference"
 
 ### 对业务插件
 
-业务插件通过 slot 系统注册组件；渲染器在 outlet 处把运行时的会话与 Workspace observable source 绑定为 selector 钩子。插件通过其组合 props 收到标准会话 props（session id、对话快照钩子）——它绝不导入渲染器，也不触碰 React 内部机制。
+业务插件注册普通 Slot entry 或可复用 Component Factory；渲染器在渲染位置把运行时的会话与 Workspace observable source 绑定为 selector 钩子。插件通过推导出的 Component props 收到标准 scope props——它绝不导入渲染器，也不触碰 React 内部机制。每个由 renderer 创建的 Component 都能渲染 Factory occurrence，Factory 也能暴露由调用方选择的局部 Component，而无需在包之间共享实现值。
 
 -----
 
@@ -51,7 +51,7 @@ kind: "package-reference"
 
 ### Slot 绑定
 
-`createSlotRenderer` 把 slot 注册表连接到 React：条目列表成为响应式 source，每个 outlet 经已安装的渲染器渲染。业务插件通过带类型的 slot `hooks` 传递裸 observable source；渲染器经 uSES 适配器在 outlet 处完成绑定。
+`createSlotRenderer` 把 slot 注册表连接到 React：普通 entry list 与 Factory definition 成为响应式 source，每个 outlet 或 occurrence 经已安装的渲染器渲染。业务插件通过带类型的 `hooks` 传递裸 observable source；渲染器经 uSES 适配器在渲染位置完成绑定。Factory Store factory 保持 lazy，直到 occurrence 首次物化时才创建 handle；其 exclusive handle 拒绝持久化，渲染期记录保持弱引用，幂等 effect 仅强引用 mounted occurrences，同时在 effect replay 期间保留 identity。Factory 错误使用普通监督通道且不会 abdicate 共享 definition：definition 及其 fallback 局部 Component 的失败归属 definition，调用方所选局部 Component 的失败归属调用方 registration，每个边界随自身 scope incarnation 重置。
 
 ### 身份
 
@@ -71,6 +71,7 @@ React、React DOM、Cordis、ui-slots 与 ui-primitives 通过 Web 外壳的静
 - [ui-session](../ui-session/README.zh.md)——提供本渲染器所绑定标准会话 source 与钩子的适配器。
 - [Web 客户端架构](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.zh.md)——加载链、对象层与分层红线。
 - [slot 系统标准](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.zh.md)——权威组合模型。
+- [Component Factory](../../../.agents/notes/implemented/architecture/2026-09-10-component-factories-and-local-slots.zh.md)——可复用 definitions、局部 Component 选择与 occurrence 生命周期。
 
 -----
 

package/lib/client.js

@@ -160,10 +160,13 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
+		//#region lib/types/client/errors.js
+		/** Shared renderer failure categories. @module */
+		/** Renderer assembly failures that must escape component error boundaries. */
+		var SlotAssemblyError = class extends Error {};
+		//#endregion
 		//#region lib/types/client/bindings.js
 		/** Internal React bindings for renderer hosts and standard-source scopes. */
-		/** Missing renderer assembly dependency. */
-		var SlotAssemblyError = class extends Error {};
 		/** In-package renderer host context. */
 		const HostContext = (0, react.createContext)(null);
 		/**
@@ -196,6 +199,19 @@ window.__ModuleLoader__.load({
 			return binding;
 		}
 		/**
+		* Publish one resolved scope binding to a renderer subtree.
+		* @param props - provider inputs.
+		* @param props.binding - binding exposed to scoped entries.
+		* @param props.children - subtree that inherits the binding.
+		* @returns the scoped React provider.
+		*/
+		function ScopeBindingProvider({ binding, children }) {
+			return (0, react_jsx_runtime.jsx)(ScopeBindingContext.Provider, {
+				value: binding,
+				children
+			});
+		}
+		/**
 		* Bind one observable source to an identity-stable selector Hook.
 		* @param source - observable source.
 		* @returns cached selector Hook.
@@ -230,20 +246,36 @@ window.__ModuleLoader__.load({
 		* @param source - keyed resolver, or absence for an optional scope.
 		* @returns cached keyed selector Hook.
 		*/
-		function keyedObservableHook(source) {
+		function keyedObservableHook(source, defaultKey) {
 			if (source === void 0) return absentKeyedHook;
-			let hook = keyedHookCache.get(source);
+			let hooks = keyedHookCache.get(source);
+			if (hooks === void 0) {
+				hooks = /* @__PURE__ */ new Map();
+				keyedHookCache.set(source, hooks);
+			}
+			const cacheKey = defaultKey ?? NO_DEFAULT_KEY;
+			let hook = hooks.get(cacheKey);
 			if (hook === void 0) {
-				hook = (key, selector, equal) => {
-					return observableHook(source(key) ?? absentSource)(selector ?? identity, equal);
+				hook = (keyOrSelector, selectorOrEqual, equal) => {
+					const keyed = typeof keyOrSelector === "string";
+					const key = keyed ? keyOrSelector : defaultKey;
+					const selector = keyed ? selectorOrEqual : keyOrSelector;
+					const comparison = keyed ? equal : selectorOrEqual;
+					return observableHook(key === void 0 ? absentSource : source(key) ?? absentSource)(selector ?? identity, comparison);
 				};
-				keyedHookCache.set(source, hook);
+				hooks.set(cacheKey, hook);
 			}
 			return hook;
 		}
+		const NO_DEFAULT_KEY = Symbol("no default key");
 		const keyedHookCache = /* @__PURE__ */ new WeakMap();
 		const identity = (value) => value;
-		const absentKeyedHook = (_key, selector, equal) => observableHook(absentSource)(selector ?? identity, equal);
+		const absentKeyedHook = (keyOrSelector, selectorOrEqual, equal) => {
+			const keyed = typeof keyOrSelector === "string";
+			const selector = keyed ? selectorOrEqual : keyOrSelector;
+			const comparison = keyed ? equal : selectorOrEqual;
+			return observableHook(absentSource)(selector ?? identity, comparison);
+		};
 		/** Subscribe the tree to the atomically assembled root standard-source roster. */
 		function RootStandardProvider({ children }) {
 			const binding = observableHook(useHost().root)((value) => value);
@@ -270,6 +302,20 @@ window.__ModuleLoader__.load({
 		* React renderer for declarative slots. Per-entry bindings enforce child
 		* authorization, and entry boundaries contain registrant failures.
 		*/
+		const factoryRenderCache = /* @__PURE__ */ new WeakMap();
+		function boundRenderFactorySlot(caller) {
+			let render = factoryRenderCache.get(caller);
+			if (render !== void 0) return render;
+			render = ((name, props, options) => (0, react_jsx_runtime.jsx)(FactoryOutlet, {
+				name,
+				inputProps: props,
+				slots: options?.slots,
+				fallback: options?.fallback,
+				caller
+			}));
+			factoryRenderCache.set(caller, render);
+			return render;
+		}
 		/**
 		* Per-entry renderSlot bindings. The binding is identity-stable per entry
 		* (memoized components must not resubscribe on unrelated re-renders) and dies
@@ -320,6 +366,42 @@ window.__ModuleLoader__.load({
 			}
 			return binding;
 		}
+		const factoryRenderSlotCache = /* @__PURE__ */ new WeakMap();
+		const factoryRenderSlotChainCache = /* @__PURE__ */ new WeakMap();
+		function boundFactoryRenderSlot(host, definition) {
+			let binding = factoryRenderSlotCache.get(definition);
+			if (binding !== void 0) return binding;
+			binding = (key, owner, opts) => {
+				if (!host.isFactoryLive(definition)) throw new _x1a0f3n9_dsh_client_ui_slots.StaleAuthorizationError(`renderSlot('${key}') from a disposed Factory`);
+				const declared = definition.children?.[key];
+				if (declared === void 0) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is not declared by this Factory`);
+				if (declared.kind === "chain") throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is declared 'chain' — use renderSlotChain`);
+				return (0, react_jsx_runtime.jsx)(SlotOutlet, {
+					slotKey: key,
+					ownerProps: owner,
+					opts
+				});
+			};
+			factoryRenderSlotCache.set(definition, binding);
+			return binding;
+		}
+		function boundFactoryRenderSlotChain(host, definition) {
+			let binding = factoryRenderSlotChainCache.get(definition);
+			if (binding !== void 0) return binding;
+			binding = (key, owner, opts) => {
+				if (!host.isFactoryLive(definition)) throw new _x1a0f3n9_dsh_client_ui_slots.StaleAuthorizationError(`renderSlotChain('${key}') from a disposed Factory`);
+				const declared = definition.children?.[key];
+				if (declared === void 0) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is not declared by this Factory`);
+				if (declared.kind !== "chain") throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is declared '${declared.kind}', not 'chain' — use renderSlot`);
+				return (0, react_jsx_runtime.jsx)(SlotOutlet, {
+					slotKey: key,
+					ownerProps: owner,
+					opts
+				});
+			};
+			factoryRenderSlotChainCache.set(definition, binding);
+			return binding;
+		}
 		/**
 		* Inject results cache: root entries per entry, session entries per
 		* (entry x scope binding). WeakMap keys are entry/binding objects (both
@@ -506,6 +588,16 @@ window.__ModuleLoader__.load({
 			}
 			return key;
 		}
+		let nextSessionGenerationKey = 0;
+		const sessionGenerationKeys = /* @__PURE__ */ new WeakMap();
+		function sessionGenerationKeyOf(binding) {
+			let key = sessionGenerationKeys.get(binding.ctx);
+			if (key === void 0) {
+				key = nextSessionGenerationKey++;
+				sessionGenerationKeys.set(binding.ctx, key);
+			}
+			return key;
+		}
 		/**
 		* Per-entry isolation: one registrant crashing (component render or inject
 		* factory) must not take down siblings. Assembly errors (missing providers)
@@ -531,11 +623,27 @@ window.__ModuleLoader__.load({
 				return this.props.children;
 			}
 		};
+		/** Contain one Factory occurrence without retiring the shared definition. */
+		var FactoryErrorBoundary = class extends react.Component {
+			state = { failed: false };
+			static getDerivedStateFromError(error) {
+				if (error instanceof SlotAssemblyError) throw error;
+				return { failed: true };
+			}
+			componentDidCatch(error) {
+				console.error(`slot factory occurrence crashed in '${this.props.name}':`, error);
+				this.props.onEntryError(error);
+			}
+			render() {
+				if (this.state.failed) return (0, react_jsx_runtime.jsx)("div", { "data-factory-error": this.props.name });
+				return this.props.children;
+			}
+		};
 		const rootStandardCache = /* @__PURE__ */ new WeakMap();
 		const sessionStandardCache = /* @__PURE__ */ new WeakMap();
 		const sessionMaybeStandardCache = /* @__PURE__ */ new WeakMap();
 		/** Materialize one binding into stable framework Hook and plain-prop seats. */
-		function materializeStandardBinding(binding, optional) {
+		function materializeStandardBinding(binding, optional, defaultKey) {
 			const standard = { ...binding.props };
 			for (const [name, source] of Object.entries(binding.hooks)) {
 				if (source === void 0 && !optional) throw new SlotAssemblyError(`strict standard hook '${name}' has no source`);
@@ -543,7 +651,7 @@ window.__ModuleLoader__.load({
 			}
 			for (const [name, source] of Object.entries(binding.keyedHooks)) {
 				if (source === void 0 && !optional) throw new SlotAssemblyError(`strict keyed standard hook '${name}' has no source resolver`);
-				standard[(0, _x1a0f3n9_dsh_client_ui_slots.standardHookPropName)(name)] = keyedObservableHook(source);
+				standard[(0, _x1a0f3n9_dsh_client_ui_slots.standardHookPropName)(name)] = keyedObservableHook(source, defaultKey);
 			}
 			return standard;
 		}
@@ -565,7 +673,7 @@ window.__ModuleLoader__.load({
 			let standard = perScope.get(scopeBinding);
 			if (standard !== void 0) return standard;
 			standard = {
-				...root,
+				...materializeStandardBinding(rootBinding, false, scopeBinding.key),
 				...materializeStandardBinding(scopeBinding, scope === "session-maybe")
 			};
 			perScope.set(scopeBinding, standard);
@@ -579,7 +687,15 @@ window.__ModuleLoader__.load({
 			if (adapter.renderArea === void 0) throw new SlotAssemblyError("scope 'session' adapter does not provide its area renderer");
 			const renderArea = adapter.renderArea.bind(adapter);
 			Provider = function ScopeAreaProvider(props) {
-				return renderArea(useScopeBinding(), props);
+				const inherited = useScopeBinding();
+				const explicit = Object.hasOwn(props, "session");
+				const source = adapter.bindingSource(props.session);
+				const resolved = (0, react.useSyncExternalStore)((listener) => source.subscribe(listener), () => source.getSnapshot(), () => source.getSnapshot());
+				const binding = explicit ? resolved : inherited;
+				return (0, react_jsx_runtime.jsx)(ScopeBindingProvider, {
+					binding,
+					children: renderArea(binding, props)
+				});
 			};
 			scopeAreaCache.set(adapter, Provider);
 			return Provider;
@@ -598,7 +714,10 @@ window.__ModuleLoader__.load({
 		*/
 		function standardKit(host, entry, scope, rootBinding, scopeBinding) {
 			const standard = standardProps(scope, rootBinding, scopeBinding);
-			const kit = { ...standard };
+			const kit = {
+				...standard,
+				renderFactorySlot: boundRenderFactorySlot(entry)
+			};
 			if (entry.locale !== void 0) {
 				const face = host.locale;
 				if (face === void 0) throw new SlotAssemblyError(`entry declares locale namespace '${entry.locale}' but no locale face is installed (locale plugin missing from the composition?)`);
@@ -613,7 +732,7 @@ window.__ModuleLoader__.load({
 			if (entry.children !== void 0) {
 				kit["renderSlot"] = boundRenderSlot(host, entry);
 				if (Object.values(entry.children).some((spec) => spec.kind === "chain")) kit["renderSlotChain"] = boundRenderSlotChain(host, entry);
-				if (Object.values(entry.children).some((spec) => spec.scope === "session")) {
+				if (Object.values(entry.children).some((spec) => spec.scope !== "root")) {
 					const adapter = host.scope("session");
 					if (adapter === void 0) throw new SlotAssemblyError("entry declares a session child without an installed 'session' scope adapter");
 					kit["SessionProvider"] = scopeAreaProvider(adapter);
@@ -697,22 +816,39 @@ window.__ModuleLoader__.load({
 		*/
 		function SessionMaybeEntry({ entry, ownerProps, slotKey, slotInjected, hookContext, hasHookContext }) {
 			const binding = useScopeBinding();
+			const epoch = useMaybeIncarnation(binding);
+			return (0, react_jsx_runtime.jsx)(SessionMaybeEntryBody, {
+				entry,
+				ownerProps,
+				binding,
+				slotKey,
+				slotInjected,
+				hookContext,
+				hasHookContext
+			}, epoch);
+		}
+		const FIRST_INCARNATION = {
+			adopted: void 0,
+			epoch: 0
+		};
+		function useMaybeIncarnation(binding) {
+			const identity = binding.key === void 0 ? void 0 : binding.ctx;
 			const [state, setState] = (0, react.useState)(FIRST_INCARNATION);
 			let { adopted, epoch } = state;
-			if (binding.key !== void 0 && adopted === void 0) {
-				adopted = binding.key;
+			if (identity !== void 0 && adopted === void 0) {
+				adopted = identity;
 				setState({
 					adopted,
 					epoch
 				});
-			} else if (adopted !== void 0 && binding.key !== void 0 && binding.key !== adopted) {
-				adopted = binding.key;
+			} else if (adopted !== void 0 && identity !== void 0 && identity !== adopted) {
+				adopted = identity;
 				epoch += 1;
 				setState({
 					adopted,
 					epoch
 				});
-			} else if (adopted !== void 0 && binding.key === void 0) {
+			} else if (adopted !== void 0 && identity === void 0) {
 				adopted = void 0;
 				epoch += 1;
 				setState({
@@ -720,20 +856,8 @@ window.__ModuleLoader__.load({
 					epoch
 				});
 			}
-			return (0, react_jsx_runtime.jsx)(SessionMaybeEntryBody, {
-				entry,
-				ownerProps,
-				binding,
-				slotKey,
-				slotInjected,
-				hookContext,
-				hasHookContext
-			}, epoch);
+			return epoch;
 		}
-		const FIRST_INCARNATION = {
-			adopted: void 0,
-			epoch: 0
-		};
 		function RootEntry({ entry, ownerProps, slotKey, slotInjected, hookContext, hasHookContext }) {
 			const host = useHost();
 			const rootBinding = useRootBinding();
@@ -741,22 +865,225 @@ window.__ModuleLoader__.load({
 			const { kit, standard, actions } = standardKit(host, entry, "root", rootBinding, void 0);
 			return renderEntry(slotKey, Comp, kit, standard, cachedRootInject(entry, actions), slotInjected, ownerProps, hookContext, hasHookContext);
 		}
+		const FactoryOccurrenceContext = (0, react.createContext)(null);
+		const FactoryAncestryContext = (0, react.createContext)(/* @__PURE__ */ new Set());
+		const EMPTY_FACTORY_SELECTION = {};
+		function useFactorySlotRuntime(name, fallback) {
+			const occurrence = (0, react.useContext)(FactoryOccurrenceContext);
+			if (occurrence === null) throw new SlotAssemblyError("useFactorySlot() called outside a Factory occurrence");
+			if (!occurrence.host.isFactoryLive(occurrence.definition)) throw new _x1a0f3n9_dsh_client_ui_slots.StaleAuthorizationError(`useFactorySlot('${name}') from a disposed Factory`);
+			const declared = occurrence.definition.slots?.[name];
+			if (declared === void 0) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`local slot '${name}' is not declared by factory '${occurrence.definition.name}'`);
+			const selected = occurrence.selected[name];
+			const Selected = selected ?? fallback;
+			const usesFallback = selected === void 0;
+			const { definition, host } = occurrence;
+			return (0, react.useMemo)(function bindFactoryLocalComponent() {
+				return function BoundFactoryLocalComponent(localProps) {
+					const current = (0, react.useContext)(FactoryOccurrenceContext);
+					const localScopeBinding = useScopeBinding();
+					const localMaybeEpoch = useMaybeIncarnation(localScopeBinding);
+					if (!host.isFactoryLive(definition)) throw new _x1a0f3n9_dsh_client_ui_slots.StaleAuthorizationError(`local slot '${name}' from a disposed Factory`);
+					if (current === null || current.definition !== definition) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`local slot '${name}' rendered outside factory '${definition.name}'`);
+					if (declared.scope === "session" && localScopeBinding.key === void 0) throw new SlotAssemblyError(`strict session local slot '${name}' from factory '${definition.name}' rendered without a scope binding`);
+					const localOwner = usesFallback ? definition : current.caller;
+					const localScopeIdentity = declared.scope === "root" ? "root" : declared.scope === "session" ? `session:${sessionGenerationKeyOf(localScopeBinding)}` : `session-maybe:${localMaybeEpoch}`;
+					const localStandard = standardProps(declared.scope, current.rootBinding, localScopeBinding);
+					const localRegistrationKit = {
+						...current.registrationKit,
+						renderFactorySlot: boundRenderFactorySlot(localOwner)
+					};
+					assertNoPropOverlap(`factory '${definition.name}' local slot '${name}'`, localRegistrationKit, localStandard);
+					const provided = {
+						...localRegistrationKit,
+						...localStandard
+					};
+					assertNoPropOverlap(`factory '${definition.name}' local slot '${name}'`, provided, localProps);
+					return (0, react_jsx_runtime.jsx)(FactoryErrorBoundary, {
+						name: `${definition.name}:${name}`,
+						onEntryError: (error) => {
+							host.reportFactoryError(definition.name, localOwner, error);
+						},
+						children: (0, react_jsx_runtime.jsx)(Selected, {
+							...provided,
+							...localProps
+						})
+					}, `${definition.name}:${name}:${localScopeIdentity}`);
+				};
+			}, [
+				Selected,
+				declared.scope,
+				definition,
+				host,
+				name,
+				usesFallback
+			]);
+		}
+		function assertNoPropOverlap(owner, provided, received) {
+			for (const name of Object.keys(received)) if (Object.hasOwn(provided, name)) throw new SlotAssemblyError(`${owner} received duplicate prop '${name}'`);
+		}
+		function factoryKit(host, definition, rootBinding, scopeBinding, occurrence) {
+			const standard = standardProps(definition.scope, rootBinding, scopeBinding);
+			const registrationKit = { renderFactorySlot: boundRenderFactorySlot(definition) };
+			if (definition.locale !== void 0) {
+				const face = host.locale;
+				if (face === void 0) throw new SlotAssemblyError(`factory declares locale namespace '${definition.locale}' but no locale face is installed`);
+				registrationKit["t"] = localeSeat(face, definition.locale);
+			}
+			const scoped = scopeBinding?.key === void 0 ? void 0 : scopeBinding;
+			const store = host.factoryStoreOf(definition, scoped, occurrence);
+			if (store !== void 0) {
+				registrationKit["useStore"] = observableHook(store);
+				registrationKit["actions"] = store.actions;
+			}
+			if (definition.children !== void 0) {
+				registrationKit["renderSlot"] = boundFactoryRenderSlot(host, definition);
+				if (Object.values(definition.children).some((spec) => spec.kind === "chain")) registrationKit["renderSlotChain"] = boundFactoryRenderSlotChain(host, definition);
+				if (Object.values(definition.children).some((spec) => spec.scope !== "root")) {
+					const sessionAdapter = host.scope("session");
+					if (sessionAdapter === void 0) throw new SlotAssemblyError("factory declares a session child without an installed 'session' scope adapter");
+					registrationKit["SessionProvider"] = scopeAreaProvider(sessionAdapter);
+				}
+			}
+			return {
+				kit: {
+					...standard,
+					...registrationKit
+				},
+				registrationKit,
+				actions: store?.actions
+			};
+		}
+		function FactoryOccurrence({ definition, inputProps, selected, caller, binding, maybeEpoch }) {
+			if (definition.scope === "root") return (0, react_jsx_runtime.jsx)(FactoryOccurrenceBody, {
+				definition,
+				inputProps,
+				selected,
+				caller
+			});
+			if (definition.scope === "session") {
+				if (binding.key === void 0) throw new SlotAssemblyError(`strict session factory '${definition.name}' rendered without a scope binding`);
+				return (0, react_jsx_runtime.jsx)(FactoryOccurrenceBody, {
+					definition,
+					inputProps,
+					selected,
+					caller,
+					scopeBinding: binding
+				}, sessionGenerationKeyOf(binding));
+			}
+			return (0, react_jsx_runtime.jsx)(FactoryOccurrenceBody, {
+				definition,
+				inputProps,
+				selected,
+				caller,
+				scopeBinding: binding
+			}, maybeEpoch);
+		}
+		function FactoryOccurrenceBody({ definition, inputProps, selected, caller, scopeBinding }) {
+			const host = useHost();
+			const rootBinding = useRootBinding();
+			const occurrence = (0, react.useRef)({}).current;
+			const localeRevision = useLocaleRevision(host.locale);
+			(0, react.useEffect)(() => host.retainFactoryOccurrence(definition, occurrence), [
+				definition,
+				host,
+				occurrence
+			]);
+			const { kit, registrationKit, actions } = (0, react.useMemo)(() => factoryKit(host, definition, rootBinding, scopeBinding, occurrence), [
+				definition,
+				host,
+				localeRevision,
+				occurrence,
+				rootBinding,
+				scopeBinding
+			]);
+			const injected = (0, react.useMemo)(() => runInject(definition, scopeBinding, actions), [
+				actions,
+				definition,
+				scopeBinding
+			]);
+			assertNoPropOverlap(`factory '${definition.name}' inject`, kit, injected);
+			const provided = {
+				...kit,
+				...injected,
+				useFactorySlot: useFactorySlotRuntime
+			};
+			assertNoPropOverlap(`factory '${definition.name}' occurrence`, provided, inputProps);
+			const context = (0, react.useMemo)(() => ({
+				host,
+				definition,
+				selected,
+				registrationKit: {
+					...registrationKit,
+					...injected
+				},
+				rootBinding,
+				caller
+			}), [
+				caller,
+				definition,
+				host,
+				injected,
+				registrationKit,
+				rootBinding,
+				selected
+			]);
+			const Comp = definition.component;
+			return (0, react_jsx_runtime.jsx)(FactoryOccurrenceContext.Provider, {
+				value: context,
+				children: (0, react_jsx_runtime.jsx)(Comp, {
+					...provided,
+					...inputProps
+				})
+			});
+		}
+		function FactoryOutlet({ name, inputProps, slots: selected = EMPTY_FACTORY_SELECTION, fallback, caller }) {
+			const host = useHost();
+			const ancestors = (0, react.useContext)(FactoryAncestryContext);
+			const binding = useScopeBinding();
+			const maybeEpoch = useMaybeIncarnation(binding);
+			const version = (0, react.useSyncExternalStore)((listener) => host.subscribeFactory(name, listener), () => host.getFactoryVersion(name));
+			const definition = host.factoryOf(name);
+			if (definition === void 0) return (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: fallback ?? null });
+			if (ancestors.has(name)) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`recursive render of factory '${name}'`);
+			for (const localName of Object.keys(selected)) if (definition.slots?.[localName] === void 0) throw new _x1a0f3n9_dsh_client_ui_slots.SlotOwnershipError(`local slot '${localName}' is not declared by factory '${name}'`);
+			const nextAncestors = new Set(ancestors).add(name);
+			const scopeIdentity = definition.scope === "root" ? "root" : definition.scope === "session" ? binding.key === void 0 ? "session:absent" : `session:${sessionGenerationKeyOf(binding)}` : `session-maybe:${maybeEpoch}`;
+			return (0, react_jsx_runtime.jsx)(FactoryErrorBoundary, {
+				name,
+				onEntryError: (error) => {
+					host.reportFactoryError(name, definition, error);
+				},
+				children: (0, react_jsx_runtime.jsx)(FactoryAncestryContext.Provider, {
+					value: nextAncestors,
+					children: (0, react_jsx_runtime.jsx)(FactoryOccurrence, {
+						definition,
+						inputProps,
+						selected,
+						caller,
+						binding,
+						maybeEpoch
+					})
+				})
+			}, `${name}:${version}:${scopeIdentity}`);
+		}
 		function StrictSessionEntry({ slotKey, entry, ownerProps, slotInjected, hookContext, hasHookContext, onEntryError }) {
 			const binding = useScopeBinding();
 			if (binding.key === void 0) throw new SlotAssemblyError(`strict session slot '${slotKey}' rendered without a scope binding`);
+			const scopedBinding = binding;
 			return (0, react_jsx_runtime.jsx)(SlotErrorBoundary, {
 				slotKey,
 				onEntryError,
 				children: (0, react_jsx_runtime.jsx)(SessionEntry, {
 					entry,
 					ownerProps,
-					binding,
+					binding: scopedBinding,
 					slotKey,
 					slotInjected,
 					hookContext,
 					hasHookContext
 				})
-			}, binding.key);
+			}, sessionGenerationKeyOf(scopedBinding));
 		}
 		/**
 		* Anchor style shared by every outlet wrapper: `display:contents` keeps the
@@ -944,8 +1271,8 @@ window.__ModuleLoader__.load({
 		* declaration injection through the caller's ctx.effect (fiber unload
 		* collects both), the renderer installation contract (install()/renderSlot('root') +
 		* the SlotRendererHost face), and the store INSTANCE axis — handle x scope
-		* key -> create/cache, dropped with the last holding entry, session instances
-		* cleared (with persisted state) on scope death.
+		* key -> create/cache, dropped with the last holding entry, and in-memory
+		* session instances released without clearing persisted state on scope death.
 		*/
 		/** Instance key for root-scoped store records (session records key by session id, so the literal cannot collide). */
 		const ROOT_INSTANCE_KEY = "root";
@@ -954,6 +1281,7 @@ window.__ModuleLoader__.load({
 			_core = new _x1a0f3n9_dsh_client_ui_slots.SlotCore();
 			/** Store-instance axis: handle -> mounted scope, refcount, resolved instances. */
 			_stores = /* @__PURE__ */ new Map();
+			_factoryStores = /* @__PURE__ */ new Map();
 			/** Latest live Context generation for each scoped store key. */
 			_storeScopeOwners = /* @__PURE__ */ new Map();
 			_renderer;
@@ -1149,21 +1477,22 @@ window.__ModuleLoader__.load({
 				}, `slots.installScope(${JSON.stringify(scope)})`);
 			}
 			/**
-			* Bind all scoped Store handles to one owner Context lifetime. The cleanup
-			* materializes an otherwise-unused handle before clearing it, because a
-			* previous application run may have persisted state for a Slot that this
-			* scope never rendered. Rebinding the same key transfers cleanup ownership
-			* to the newest Context generation.
+			* Bind scoped Store instances to one Context generation. Rebinding the key
+			* drops the previous generation's memory instances before the new owner can
+			* resolve them. Cleanup never clears persisted state, which belongs to the
+			* durable scope key, or drops a replacement generation's instances.
 			*
 			* @param binding - materialized scope identity and its owning Context.
 			*/
 			bindStoreScope(binding) {
-				if (this._storeScopeOwners.get(binding.key) === binding.ctx) return;
+				const current = this._storeScopeOwners.get(binding.key);
+				if (current === binding.ctx) return;
+				if (current !== void 0) this.releaseStoreScope(binding.key);
 				this._storeScopeOwners.set(binding.key, binding.ctx);
 				binding.ctx.effect(() => () => {
 					if (this._storeScopeOwners.get(binding.key) !== binding.ctx) return;
 					this._storeScopeOwners.delete(binding.key);
-					this.clearStoreScope(binding.key);
+					this.releaseStoreScope(binding.key);
 				}, `slots: store scope ${binding.key}`);
 			}
 			/**
@@ -1192,7 +1521,7 @@ window.__ModuleLoader__.load({
 			* Shadowing winners per cell for a key: the first live (non-abdicated)
 			* entry of each cell in priority order — what outlets render; chain keys
 			* pass through unchanged (election consumes every entry). The raw
-			* {@link SlotsService.entries} view stays the inspection surface. Fresh
+			* {@link SlotRegistry.entries} view stays the inspection surface. Fresh
 			* array per call, not a uSES getSnapshot source.
 			* @param key - SlotMap key.
 			* @returns the winning entry per occupied cell.
@@ -1201,22 +1530,20 @@ window.__ModuleLoader__.load({
 				return this._core.entriesOfSlot(key);
 			}
 			/**
-			* Export the current JSON-safe Slot declaration tree for read-only inspection.
-			* @param root - exact live Slot root; omitted returns all roots.
-			* @returns selected Slot trees.
+			* Export the current JSON-safe Slot and Factory declaration trees for read-only inspection.
+			* @param root - exact live Slot key or `factory:<name>`; omitted returns all roots.
+			* @returns selected composition trees.
 			*/
 			snapshot(root) {
 				return this._core.snapshot(root);
 			}
 			/**
-			* Observe entry boundary crashes (every render-time entry failure the
-			* boundaries contain, abdicating or not) — the supervision seam for
-			* plugins mirroring contribution health. Fires synchronously per report,
-			* after the registry mutated for abdicating crashes. Callers own the
-			* disposer (wire it through ctx.effect for fiber-lifetime cleanup, as with
-			* {@link SlotsService.subscribe}).
-			* @param fn - called with the slot key, the crashed entry, the crash
-			* cause, and `abdicated`: whether the crash retired the entry from its cell.
+			* Observe ordinary entry and Factory occurrence crashes through one
+			* supervision channel. Fires synchronously after any ordinary-entry
+			* abdication mutation. Callers own the disposer (wire it through ctx.effect
+			* for fiber-lifetime cleanup, as with {@link SlotRegistry.subscribe}).
+			* @param fn - called with the Slot or `factory:<name>` key, crashed
+			* registration, cause, and whether an ordinary entry was retired.
 			* @returns unsubscribe.
 			*/
 			onEntryError(fn) {
@@ -1269,6 +1596,29 @@ window.__ModuleLoader__.load({
 					if (store !== void 0) this._release(store);
 				};
 			}
+			_registerFactory(options, component) {
+				const registrant = this.ctx.fiber?.name;
+				const erased = {
+					...options,
+					...registrant === void 0 ? {} : { registrant }
+				};
+				const dispose = this._core.registerFactory(erased, component);
+				const definition = this._core.factory(options.name);
+				if (definition === void 0) throw new Error(`slot factory "${options.name}" disappeared during registration`);
+				if (definition.store !== void 0 && typeof definition.store !== "function") this._acquire(definition.store, definition.scope);
+				else if (typeof definition.store === "function") this._factoryStores.set(definition, {
+					occurrences: /* @__PURE__ */ new WeakMap(),
+					mounted: /* @__PURE__ */ new Map()
+				});
+				let disposed = false;
+				return () => {
+					if (disposed) return;
+					disposed = true;
+					dispose();
+					this._factoryStores.delete(definition);
+					if (definition.store !== void 0 && typeof definition.store !== "function") this._release(definition.store);
+				};
+			}
 			/** Build the domain-neutral host face once; installed adapters remain live through getters. */
 			hostFace() {
 				if (this._host !== void 0) return this._host;
@@ -1281,9 +1631,18 @@ window.__ModuleLoader__.load({
 					reportEntryError: (key, entry, error, info) => {
 						this._core.reportEntryError(key, entry, error, info);
 					},
+					reportFactoryError: (name, registration, error) => {
+						this._core.reportFactoryError(name, registration, error);
+					},
 					specOf: (key) => this._core.specDynamic(key),
 					isLive: (entry) => this._core.isLive(entry),
 					storeOf: (entry, scopeBinding) => entry.store === void 0 ? void 0 : this.resolveStore(entry.store, scopeBinding),
+					factoryStoreOf: (definition, scopeBinding, occurrence) => this.resolveFactoryStore(definition, scopeBinding, occurrence),
+					retainFactoryOccurrence: (definition, occurrence) => this.retainFactoryOccurrence(definition, occurrence),
+					subscribeFactory: (name, fn) => this._core.subscribeFactory(name, fn),
+					getFactoryVersion: (name) => this._core.factoryVersion(name),
+					factoryOf: (name) => this._core.factory(name),
+					isFactoryLive: (definition) => this._core.isFactoryLive(definition),
 					root: this._rootSource,
 					scopeRevision: this._scopeRevisionSource,
 					scope: (scope) => service._scopes.get(scope === "session-maybe" ? "session" : scope),
@@ -1343,13 +1702,54 @@ window.__ModuleLoader__.load({
 				}
 				return instance;
 			}
-			/** Clear every live non-root Store handle for one dead scope key. */
-			clearStoreScope(key) {
-				for (const [handle, record] of this._stores) {
+			resolveFactoryStore(definition, scopeBinding, occurrence) {
+				if (!this._core.isFactoryLive(definition)) throw new _x1a0f3n9_dsh_client_ui_slots.StaleAuthorizationError(`slot factory "${definition.name}" is not registered`);
+				const declaration = definition.store;
+				if (declaration === void 0) return void 0;
+				if (typeof declaration !== "function") return this.resolveStore(declaration, scopeBinding);
+				const axis = this._factoryStores.get(definition);
+				const scopeKey = definition.scope === "root" ? ROOT_INSTANCE_KEY : requireScopeKey(definition, scopeBinding);
+				if (scopeBinding !== void 0 && definition.scope !== "root") this.bindStoreScope(scopeBinding);
+				let record = axis.occurrences.get(occurrence);
+				if (record === void 0) {
+					const handle = declaration();
+					if (handle.spec.persist !== void 0) throw new SlotAssemblyError(`exclusive store for factory "${definition.name}" cannot declare persistence`);
+					record = {
+						handle,
+						instances: /* @__PURE__ */ new Map(),
+						retainers: 0
+					};
+					axis.occurrences.set(occurrence, record);
+				}
+				const existing = record.instances.get(scopeKey);
+				if (existing !== void 0) return existing;
+				const instance = definition.scope === "root" || scopeBinding === void 0 ? record.handle.create() : record.handle.create(scopeBinding.key);
+				record.instances.set(scopeKey, instance);
+				return instance;
+			}
+			retainFactoryOccurrence(definition, occurrence) {
+				if (!this._core.isFactoryLive(definition)) return () => {};
+				if (typeof definition.store !== "function") return () => {};
+				const axis = this._factoryStores.get(definition);
+				const record = axis.occurrences.get(occurrence);
+				record.retainers += 1;
+				axis.mounted.set(occurrence, record);
+				let released = false;
+				return () => {
+					if (released) return;
+					released = true;
+					record.retainers -= 1;
+					if (record.retainers !== 0) return;
+					axis.mounted.delete(occurrence);
+				};
+			}
+			/** Drop every materialized non-root Store instance for one ended Context generation. */
+			releaseStoreScope(key) {
+				for (const record of this._stores.values()) {
 					if (record.scope === "root") continue;
-					(record.instances.get(key) ?? handle.create(key)).clearPersisted();
 					record.instances.delete(key);
 				}
+				for (const axis of this._factoryStores.values()) for (const record of axis.mounted.values()) record.instances.delete(key);
 			}
 			/** Bind (or re-reference) a handle on the axis; cross-scope conflicts already threw in the core. */
 			_acquire(handle, scope) {
@@ -1389,6 +1789,14 @@ window.__ModuleLoader__.load({
 			const options = rawOptions;
 			return this.ctx.effect(() => this["_register"](options, component), "slots.register()");
 		};
+		SlotRegistry.prototype.registerFactory = function registerFactory(rawOptions, component) {
+			const options = rawOptions;
+			return this.ctx.effect(() => this["_registerFactory"](options, component), "slots.registerFactory()");
+		};
+		function requireScopeKey(definition, binding) {
+			if (binding === void 0) throw new Error(`${definition.scope} factory store resolution requires a session id`);
+			return binding.key;
+		}
 		//#endregion
 		//#region lib/types/client/index.js
 		/**

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

@@ -1,9 +1,6 @@
 /** Internal React bindings for renderer hosts and standard-source scopes. */
 import { type ReactNode } from 'react';
 import type { HostObservable, KeyedStandardSource, MaybeSnapshotSelectorHook, SlotRendererHost, SnapshotSelectorHook, StandardSourceBinding } from '@x1a0f3n9/dsh-client-ui-slots';
-/** Missing renderer assembly dependency. */
-export declare class SlotAssemblyError extends Error {
-}
 /** In-package renderer host context. */
 export declare const HostContext: import("react").Context<SlotRendererHost | null>;
 /**
@@ -21,6 +18,17 @@ export declare function useRootBinding(): StandardSourceBinding;
  * @returns a binding whose key is absent when no Session is selected.
  */
 export declare function useScopeBinding(): StandardSourceBinding;
+/**
+ * Publish one resolved scope binding to a renderer subtree.
+ * @param props - provider inputs.
+ * @param props.binding - binding exposed to scoped entries.
+ * @param props.children - subtree that inherits the binding.
+ * @returns the scoped React provider.
+ */
+export declare function ScopeBindingProvider({ binding, children }: {
+    binding: StandardSourceBinding;
+    children: ReactNode;
+}): ReactNode;
 /**
  * Bind one observable source to an identity-stable selector Hook.
  * @param source - observable source.
@@ -34,13 +42,13 @@ export declare function observableHook<T>(source: HostObservable<T>): SnapshotSe
  */
 export declare function maybeObservableHook<T>(source: HostObservable<T> | undefined): MaybeSnapshotSelectorHook<T>;
 /** Erased open-key selector Hook synthesized from one keyed source family. */
-export type KeyedSnapshotHook = (key: string, selector?: (value: unknown) => unknown, equal?: (left: unknown, right: unknown) => boolean) => unknown;
+export type KeyedSnapshotHook = (keyOrSelector: string | ((value: unknown) => unknown), selectorOrEqual?: ((value: unknown) => unknown) | ((left: unknown, right: unknown) => boolean), equal?: (left: unknown, right: unknown) => boolean) => unknown;
 /**
  * Bind an open-key source family.
  * @param source - keyed resolver, or absence for an optional scope.
  * @returns cached keyed selector Hook.
  */
-export declare function keyedObservableHook(source: KeyedStandardSource | undefined): KeyedSnapshotHook;
+export declare function keyedObservableHook(source: KeyedStandardSource | undefined, defaultKey?: string): KeyedSnapshotHook;
 /** Subscribe the tree to the atomically assembled root standard-source roster. */
 export declare function RootStandardProvider({ children }: {
     children: ReactNode;

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

@@ -0,0 +1,5 @@
+/** Shared renderer failure categories. @module */
+/** Renderer assembly failures that must escape component error boundaries. */
+export declare class SlotAssemblyError extends Error {
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -15,7 +15,8 @@ export interface UiRendererService {
 declare module '@deepseek-ai/cordis' {
     interface Events {
         /**
-         * A slot declaration or registration set changed.
+         * An ordinary Slot declaration or entry registration set changed. Factory
+         * definitions publish through `subscribeFactory()` instead.
          * @mode emit
          * @param key - mutated SlotMap key.
          */

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

@@ -6,13 +6,13 @@
  * declaration injection through the caller's ctx.effect (fiber unload
  * collects both), the renderer installation contract (install()/renderSlot('root') +
  * the SlotRendererHost face), and the store INSTANCE axis — handle x scope
- * key -> create/cache, dropped with the last holding entry, session instances
- * cleared (with persisted state) on scope death.
+ * key -> create/cache, dropped with the last holding entry, and in-memory
+ * session instances released without clearing persisted state on scope death.
  */
 import { Service } from '@deepseek-ai/cordis';
 import type { Context } from '@deepseek-ai/cordis';
 import { SlotCore } from '@x1a0f3n9/dsh-client-ui-slots';
-import type { LiveSlotNode, LocaleFace, OwnerOf, SlotMap, SlotRenderer, RootStandardSourceContribution, ScopedStandardSourceBinding, SlotScope, SlotScopeAdapter, SlotSpec, StoredEntry } from '@x1a0f3n9/dsh-client-ui-slots';
+import type { LiveCompositionNode, LocaleFace, OwnerOf, RegisterFactory, SlotMap, SlotRenderer, RootStandardSourceContribution, ScopedStandardSourceBinding, SlotScope, SlotScopeAdapter, SlotSpec, StoredFactory, StoredEntry } from '@x1a0f3n9/dsh-client-ui-slots';
 declare module '@x1a0f3n9/dsh-client-ui-slots' {
     interface SlotMap {
         /**
@@ -47,6 +47,7 @@ export declare class SlotRegistry extends Service {
     private readonly _core;
     /** Store-instance axis: handle -> mounted scope, refcount, resolved instances. */
     private readonly _stores;
+    private readonly _factoryStores;
     /** Latest live Context generation for each scoped store key. */
     private readonly _storeScopeOwners;
     private _renderer;
@@ -65,7 +66,7 @@ export declare class SlotRegistry extends Service {
      */
     constructor(ctx: Context);
     /**
-     * The single registration API. The typed face IS the core's register
+     * The ordinary Slot registration API. The typed face IS the core's register
      * (both overloads reused verbatim — one authority, no structural copy;
      * see SlotCore.register for children declaration, store seat, inject
      * face, load-time validation, and the unload cascade). This layer adds:
@@ -82,6 +83,16 @@ export declare class SlotRegistry extends Service {
      * own root ctx and silently break per-plugin disposal.
      */
     readonly register: SlotCore['register'];
+    /**
+     * Register one reusable Component Factory under the caller's effect lifetime.
+     * A Store factory mints one handle per rendered occurrence rather than per
+     * definition. Like {@link SlotRegistry.register}, this remains a prototype
+     * method so the Cordis proxy binds `this.ctx` to the caller's Context.
+     * @param options - runtime definition checked against `SlotFactoryMap`.
+     * @param component - reusable Factory Component.
+     * @returns the idempotent definition disposer.
+     */
+    readonly registerFactory: RegisterFactory;
     /**
      * Install an effect for each declaration lifetime of a slot. The callback
      * runs synchronously when the declaration already exists; otherwise it runs
@@ -128,11 +139,10 @@ export declare class SlotRegistry extends Service {
      */
     installScope(scope: Exclude<SlotScope, 'root' | 'session-maybe'>, adapter: SlotScopeAdapter): void;
     /**
-     * Bind all scoped Store handles to one owner Context lifetime. The cleanup
-     * materializes an otherwise-unused handle before clearing it, because a
-     * previous application run may have persisted state for a Slot that this
-     * scope never rendered. Rebinding the same key transfers cleanup ownership
-     * to the newest Context generation.
+     * Bind scoped Store instances to one Context generation. Rebinding the key
+     * drops the previous generation's memory instances before the new owner can
+     * resolve them. Cleanup never clears persisted state, which belongs to the
+     * durable scope key, or drops a replacement generation's instances.
      *
      * @param binding - materialized scope identity and its owning Context.
      */
@@ -156,30 +166,28 @@ export declare class SlotRegistry extends Service {
      * Shadowing winners per cell for a key: the first live (non-abdicated)
      * entry of each cell in priority order — what outlets render; chain keys
      * pass through unchanged (election consumes every entry). The raw
-     * {@link SlotsService.entries} view stays the inspection surface. Fresh
+     * {@link SlotRegistry.entries} view stays the inspection surface. Fresh
      * array per call, not a uSES getSnapshot source.
      * @param key - SlotMap key.
      * @returns the winning entry per occupied cell.
      */
     entriesOfSlot(key: keyof SlotMap & string): readonly StoredEntry[];
     /**
-     * Export the current JSON-safe Slot declaration tree for read-only inspection.
-     * @param root - exact live Slot root; omitted returns all roots.
-     * @returns selected Slot trees.
+     * Export the current JSON-safe Slot and Factory declaration trees for read-only inspection.
+     * @param root - exact live Slot key or `factory:<name>`; omitted returns all roots.
+     * @returns selected composition trees.
      */
-    snapshot(root?: string): LiveSlotNode[];
+    snapshot(root?: string): LiveCompositionNode[];
     /**
-     * Observe entry boundary crashes (every render-time entry failure the
-     * boundaries contain, abdicating or not) — the supervision seam for
-     * plugins mirroring contribution health. Fires synchronously per report,
-     * after the registry mutated for abdicating crashes. Callers own the
-     * disposer (wire it through ctx.effect for fiber-lifetime cleanup, as with
-     * {@link SlotsService.subscribe}).
-     * @param fn - called with the slot key, the crashed entry, the crash
-     * cause, and `abdicated`: whether the crash retired the entry from its cell.
+     * Observe ordinary entry and Factory occurrence crashes through one
+     * supervision channel. Fires synchronously after any ordinary-entry
+     * abdication mutation. Callers own the disposer (wire it through ctx.effect
+     * for fiber-lifetime cleanup, as with {@link SlotRegistry.subscribe}).
+     * @param fn - called with the Slot or `factory:<name>` key, crashed
+     * registration, cause, and whether an ordinary entry was retired.
      * @returns unsubscribe.
      */
-    onEntryError(fn: (key: string, entry: StoredEntry, error: unknown, info: {
+    onEntryError(fn: (key: string, registration: StoredEntry | StoredFactory, error: unknown, info: {
         abdicated: boolean;
     }) => void): () => void;
     /**
@@ -203,6 +211,7 @@ export declare class SlotRegistry extends Service {
     getVersion(key: keyof SlotMap & string): number;
     /** Delegating registration path: factory minting + registrant stamp + core write + instance-axis bookkeeping. */
     private _register;
+    private _registerFactory;
     /** Build the domain-neutral host face once; installed adapters remain live through getters. */
     private hostFace;
     /** Validate and atomically publish the current root contribution roster. */
@@ -211,8 +220,10 @@ export declare class SlotRegistry extends Service {
     private publishScopeRevision;
     /** Resolve (create or reuse) the store instance for a registered handle under a scope key. */
     private resolveStore;
-    /** Clear every live non-root Store handle for one dead scope key. */
-    private clearStoreScope;
+    private resolveFactoryStore;
+    private retainFactoryOccurrence;
+    /** Drop every materialized non-root Store instance for one ended Context generation. */
+    private releaseStoreScope;
     /** Bind (or re-reference) a handle on the axis; cross-scope conflicts already threw in the core. */
     private _acquire;
     /** Drop one reference; the last holder's unload drops the record (instances go with it — engine stores need no explicit dispose). */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@x1a0f3n9/dsh-client-ui-renderer",
   "description": "Browser UI renderer: React slot bindings, ctx.uiRenderer, and the assembled application root",
-  "version": "0.1.5-rc.4",
+  "version": "0.1.7-rc.2",
   "publishConfig": {
     "access": "public"
   },
@@ -37,7 +37,7 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2"
+    "@deepseek-ai/cordis": "~4.0.4"
   },
   "devDependencies": {
     "@types/react": "~18.3.1",
@@ -46,10 +46,10 @@
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "use-sync-external-store": "1.2.0",
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@x1a0f3n9/dsh-client-test-runtime": "^0.1.5-rc.4",
-    "@x1a0f3n9/dsh-client-ui-slots": "^0.1.5-rc.4",
-    "@x1a0f3n9/dsh-invariants": "^0.1.5-rc.4"
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@x1a0f3n9/dsh-client-test-runtime": "0.1.7-rc.2",
+    "@x1a0f3n9/dsh-client-ui-slots": "0.1.7-rc.2",
+    "@x1a0f3n9/dsh-invariants": "0.1.7-rc.2"
   },
   "files": [
     "lib/index.js",