@songtonyli/dsh-cli 0.1.12 → 0.1.13

package/node_modules/@deepseek-ai/dsh-client-ui-renderer/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 _deepseek_ai_dsh_client_ui_slots.StaleAuthorizationError(`renderSlot('${key}') from a disposed Factory`);
+				const declared = definition.children?.[key];
+				if (declared === void 0) throw new _deepseek_ai_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is not declared by this Factory`);
+				if (declared.kind === "chain") throw new _deepseek_ai_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 _deepseek_ai_dsh_client_ui_slots.StaleAuthorizationError(`renderSlotChain('${key}') from a disposed Factory`);
+				const declared = definition.children?.[key];
+				if (declared === void 0) throw new _deepseek_ai_dsh_client_ui_slots.SlotOwnershipError(`slot '${key}' is not declared by this Factory`);
+				if (declared.kind !== "chain") throw new _deepseek_ai_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, _deepseek_ai_dsh_client_ui_slots.standardHookPropName)(name)] = keyedObservableHook(source);
+				standard[(0, _deepseek_ai_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 _deepseek_ai_dsh_client_ui_slots.StaleAuthorizationError(`useFactorySlot('${name}') from a disposed Factory`);
+			const declared = occurrence.definition.slots?.[name];
+			if (declared === void 0) throw new _deepseek_ai_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 _deepseek_ai_dsh_client_ui_slots.StaleAuthorizationError(`local slot '${name}' from a disposed Factory`);
+					if (current === null || current.definition !== definition) throw new _deepseek_ai_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 _deepseek_ai_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 _deepseek_ai_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 _deepseek_ai_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,11 +1477,10 @@ 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 owner Context lifetime. Cleanup drops
+			* only materialized in-memory instances; persisted state belongs to the
+			* durable scope key. Rebinding the same key transfers cleanup ownership to
+			* the newest Context generation.
 			*
 			* @param binding - materialized scope identity and its owning Context.
 			*/
@@ -1163,7 +1490,7 @@ window.__ModuleLoader__.load({
 				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}`);
 			}
 			/**
@@ -1201,22 +1528,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 SlotRegistry.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 +1594,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 +1629,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 +1700,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 _deepseek_ai_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 +1787,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
 		/**