@deepseek-ai/dsh-client-ui-slots 0.1.6-alpha.1 → 0.1.7-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-slots/README.md
-README.md: d38fe059693f7b15d060b0a52c97edd0b5e050c9
-README.zh.md: 968470edd20d75b7c6bf8f7c8fca898764af757e
+README.md: d82b303d5d6efaebbccaab00d06d874d79165fb1
+README.zh.md: 2a9d0364eda148ddf8db8cc61daf1747381c4875

package/README.md

@@ -1,5 +1,5 @@
 ---
-description: "Slot registry pure core for the dsh web client: SlotMap declaration merging, the single register composition API, four-share props types, store seats, and the renderer install contract."
+description: "Slot registry pure core for the dsh web client: ordinary extension slots, reusable Component Factories, derived props types, store seats, and the renderer install contract."
 kind: "package-library"
 ---
 
@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-client-ui-slots` lets web client plugins define and compose typed UI regions. Callers can add components, declare nested regions, attach scoped state, and supply business props through one compile-time-checked API. It supports single, ordered-list, keyed, and self-selecting chain composition, and reports conflicting compositions during plugin loading. Choose it for framework-neutral slot composition; pair it with `ui-renderer` when the client needs React rendering.
+`dsh-client-ui-slots` lets web client plugins define and compose typed UI regions. Ordinary Slots provide parent-owned extension positions; Component Factories provide reusable assemblies with caller-selected local Components. Both APIs derive scoped state, injection, locale, and child-render props from declaration-merged types and report conflicting definitions during plugin loading. Pair this React-free package with `ui-renderer` when the client needs rendering.
 
 ## Table of Contents
 
@@ -27,9 +27,15 @@ English | [中文](README.zh.md)
 
 Compose UI through this package whenever you write a client plugin: register a component into a slot your parent declared, or declare child slots your component renders. The four kinds cover the composition shapes — `single` (one occupant), `list` (ordered entries), `keyed` (dispatch by a key), and `chain` (entries elect themselves).
 
-### The four props shares
+### Reusable Component Factories
 
-Every registered component receives props composed from four shares: the runtime share (`owner` from the parent's renderSlot call site, plus the session standard kit and global seat), the child-render share (`renderSlot` statically narrowed to the declared children keys), the store share (the declared handle's selector hook and draft-stripped actions), and the business share (inferred from the `inject` factory's return). Components reference `ComposedProps`; they never re-type a share locally.
+Use a Component Factory when one package defines an assembly that unrelated parents render independently. Declare its complete type in `SlotFactoryMap`, install the definition with `ctx.slots.registerFactory()`, render occurrences through the injected `renderFactorySlot()`, and select each declared local Component through the call's `slots` option. The definition reads that choice through `useFactorySlot(name, fallback)`.
+
+Factory `children` remain ordinary global Slots and must match `SlotMap`, while local `slots` select one Component per occurrence. An occurrence inherits its render-position scope; `renderFactorySlot()` does not accept a Session identity. Shared Store handles use ordinary scope resolution. A Store factory stays lazy until an occurrence first materializes, then creates one handle for that render position and rejects a persistent Store spec whose key would collide across occurrences.
+
+### The five framework props shares
+
+Every registered component receives props composed from five framework shares: the runtime share (`owner` from the parent's render call site, plus the session standard kit and global seat), the child-render share (`renderSlot` statically narrowed to declared children), the Factory-render share (`renderFactorySlot`), the store share (the declared handle's selector hook and draft-stripped actions), and the business share (inferred from `inject`). Components reference the derived props aliases; they never re-type a share locally.
 
 ### Store seats
 
@@ -47,15 +53,15 @@ Declaring a slot is claiming it: the registering entry becomes the only entry al
 <details>
 <summary>Implementation internals — click to expand</summary>
 
-The design is one table: declaration = render authorization = runtime spec. `SlotMap` is declared empty here and merged by consumers via `declare module` augmentation, exactly like the standard-kit interfaces (`SessionStandardProps`, `GlobalStandardProps`), which the runtime package merges with real members.
+The ordinary Slot design is one table: declaration = render authorization = runtime spec. `SlotMap` is declared empty here and merged by consumers via `declare module` augmentation, exactly like `SlotFactoryMap` and the standard-kit interfaces (`SessionStandardProps`, `GlobalStandardProps`). Factory definitions use a separate single-definition ledger because their occurrences have no parent declaration.
 
 ### Registration and routing
 
-`SlotCore` seeds the a-priori `'root'` slot at construction and enforces load-time validation. `ChainSelect` selectors run in ascending `priority` order (ties in registration order); the first non-null return elects its entry and becomes the component's `matched` prop, and all-null falls to the owner's `renderSlotChain` fallback (`ChainRenderOpts`). Each key carries a declaration epoch that advances only on declaration and collapse; `ui-renderer` uses it for `ctx.slots.inject`, independently from ordinary entry versions.
+`SlotCore` seeds the a-priori `'root'` slot at construction and enforces load-time validation. `ChainSelect` selectors run in ascending `priority` order (ties in registration order); the first non-null return elects its entry and becomes the component's `matched` prop, and all-null falls to the owner's `renderSlotChain` fallback (`ChainRenderOpts`). Each key carries a declaration epoch that advances only on declaration and collapse; `ui-renderer` uses it for `ctx.slots.inject`, independently from ordinary entry versions. Live inspection uses strict `type: 'slot' | 'factory'` nodes and nests Factory-owned child Slots under their definition.
 
 ### The renderer contract
 
-`renderer.ts` carries the installation contract (`SlotRenderer`, `SlotRendererHost`) plus `StaleAuthorizationError`/`SlotOwnershipError`; ui-renderer owns both the implementation and its plugin-lifecycle installation. Engine products and the renderer host contract carry bare snapshot sources (`getSnapshot`/`subscribe`), never React hooks — hook binding belongs to the render machinery.
+`renderer.ts` carries the installation contract (`SlotRenderer`, `SlotRendererHost`) plus `StaleAuthorizationError`/`SlotOwnershipError`; ui-renderer owns both the implementation and its plugin-lifecycle installation. Engine products and the renderer host contract carry bare snapshot sources (`getSnapshot`/`subscribe`), never React hooks — hook binding belongs to the render machinery. Factory crashes use the ordinary supervision channel, and an idempotent effect retains per-position Store handles only after commit.
 
 </details>
 
@@ -68,6 +74,7 @@ These pages cover the engine, the renderer, and the composition model.
 
 - [ui-renderer](../ui-renderer/README.md) — the React slot renderer implementing this package's install contract.
 - [Slot system standard](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.md) — the definitive composition model.
+- [Component Factories](../../../.agents/notes/implemented/architecture/2026-09-10-component-factories-and-local-slots.md) — reusable definitions, local Component selection, and occurrence lifetimes.
 - [Web client architecture](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.md) — the loading chain and object layer this registry plugs into.
 
 -----

package/README.zh.md

@@ -1,5 +1,5 @@
 ---
-description: "dsh Web 客户端的 slot 注册表纯核心：SlotMap 声明合并、单一 register 组合 API、四 share props 类型、store 席位与渲染器安装约定。"
+description: "dsh Web 客户端的 slot 注册表纯核心：普通扩展 slots、可复用 Component Factory、推导 props 类型、store 席位与渲染器安装约定。"
 kind: "package-library"
 ---
 
@@ -9,7 +9,7 @@ kind: "package-library"
 
 ## 概述
 
-`dsh-client-ui-slots` 让 Web 客户端插件定义并组合带类型检查的 UI 区域。调用方可以通过一个在编译期检查的 API 添加组件、声明嵌套区域、附加作用域状态并提供业务 props。它支持单项、有序列表、键控和自行选择的 chain 组合，并会在插件加载期间报告冲突组合。需要与框架无关的 slot 组合时选择本包；客户端需要 React 渲染时与 `ui-renderer` 配合使用。
+`dsh-client-ui-slots` 让 Web 客户端插件定义并组合带类型检查的 UI 区域。普通 Slots 提供 parent-owned 扩展位置；Component Factory 提供带调用方所选局部 Component 的可复用装配。两套 API 都从声明合并类型推导 scoped state、injection、locale 与 child-render props，并在插件加载期间报告冲突 definition。客户端需要渲染时，将这个不依赖 React 的包与 `ui-renderer` 配合使用。
 
 ## 目录
 
@@ -27,9 +27,15 @@ kind: "package-library"
 
 编写客户端插件时都通过本包组合 UI：把组件注册进父级已声明的 slot，或声明组件将要渲染的子 slot。四种 kind 覆盖组合形态——`single`（单个占位者）、`list`（有序条目）、`keyed`（按键分派）与 `chain`（条目自行提名）。
 
-### 四个 props share
+### 可复用 Component Factory
 
-每个已注册组件都会收到由四个 share 组合而成的 props：运行时 share（父级 renderSlot 调用点的 `owner`，加上会话标准工具包与全局席位）、child render share（静态缩窄到已声明 children key 的 `renderSlot`）、store share（已声明句柄的 selector 钩子与移除 draft 的 actions），以及业务 share（从 `inject` factory 返回值推断）。组件引用 `ComposedProps`；它们绝不在本地重新定义任何 share 的类型。
+当一个包定义装配、而互不相关的 parents 需要独立渲染它时，使用 Component Factory。在 `SlotFactoryMap` 中声明完整类型，通过 `ctx.slots.registerFactory()` 安装 definition，通过注入的 `renderFactorySlot()` 渲染 occurrences，并通过调用的 `slots` 选项选择每个已声明的局部 Component。definition 通过 `useFactorySlot(name, fallback)` 读取该选择。
+
+Factory `children` 仍是普通全局 Slots 且必须与 `SlotMap` 匹配，而局部 `slots` 为每个 occurrence 选择一个 Component。occurrence 继承其渲染位置的 scope；`renderFactorySlot()` 不接受 Session identity。共享 Store handle 使用普通 scope 解析。Store factory 保持 lazy，直到 occurrence 首次物化时才为该渲染位置创建一个 handle；若持久化 Store spec 会让 persistence key 在 occurrences 之间冲突，renderer 会拒绝它。
+
+### 五个框架 props share
+
+每个已注册组件都会收到由五个框架 share 组合而成的 props：运行时 share（父级 render 调用点的 `owner`，加上会话标准工具包与全局席位）、child render share（静态缩窄到已声明 children 的 `renderSlot`）、Factory render share（`renderFactorySlot`）、store share（已声明 handle 的 selector 钩子与移除 draft 的 actions），以及业务 share（从 `inject` 推导）。组件引用推导出的 props 别名；它们绝不在本地重新定义任何 share 的类型。
 
 ### Store 席位
 
@@ -47,15 +53,15 @@ register 调用可以用 `store: defineStore(...)` 声明 store 席位：`init`
 <details>
 <summary>实现细节——点击展开</summary>
 
-设计就是一张表：声明 = 渲染授权 = 运行时规范。`SlotMap` 在这里声明为空，由消费方通过 `declare module` 增补合并，标准工具包接口（`SessionStandardProps`、`GlobalStandardProps`）也是如此，由运行时包以真实成员合并。
+普通 Slot 设计就是一张表：声明 = 渲染授权 = 运行时规范。`SlotMap` 在这里声明为空，由消费方通过 `declare module` 增补合并；`SlotFactoryMap` 和标准工具包接口（`SessionStandardProps`、`GlobalStandardProps`）也采用同一方式。Factory definition 使用独立的单 definition ledger，因为其 occurrences 没有 parent 声明。
 
 ### 注册与路由
 
-`SlotCore` 在构造时预置 `'root'` slot，并强制执行加载时验证。`ChainSelect` selector 按升序 `priority` 运行（相同值按注册顺序）；第一个非 null 返回值选中其条目，并成为组件的 `matched` prop；全部返回 null 时使用 owner 的 `renderSlotChain` fallback（`ChainRenderOpts`）。每个 key 都携带一个 declaration epoch，它只在声明与移除时递增；`ui-renderer` 将其用于 `ctx.slots.inject`，且与普通条目版本相互独立。
+`SlotCore` 在构造时预置 `'root'` slot，并强制执行加载时验证。`ChainSelect` selector 按升序 `priority` 运行（相同值按注册顺序）；第一个非 null 返回值选中其条目，并成为组件的 `matched` prop；全部返回 null 时使用 owner 的 `renderSlotChain` fallback（`ChainRenderOpts`）。每个 key 都携带一个 declaration epoch，它只在声明与移除时递增；`ui-renderer` 将其用于 `ctx.slots.inject`，且与普通条目版本相互独立。实时检查使用严格的 `type: 'slot' | 'factory'` 节点，并把 Factory-owned child Slots 嵌套在其 definition 下。
 
 ### 渲染器约定
 
-`renderer.ts` 携带安装约定（`SlotRenderer`、`SlotRendererHost`）以及 `StaleAuthorizationError`/`SlotOwnershipError`；ui-renderer 负责实现，并在其插件生命周期中完成安装。引擎产物与渲染器宿主约定携带裸快照 source（`getSnapshot`/`subscribe`），绝不携带 React 钩子——钩子绑定属于渲染机制。
+`renderer.ts` 携带安装约定（`SlotRenderer`、`SlotRendererHost`）以及 `StaleAuthorizationError`/`SlotOwnershipError`；ui-renderer 负责实现，并在其插件生命周期中完成安装。引擎产物与渲染器宿主约定携带裸快照 source（`getSnapshot`/`subscribe`），绝不携带 React 钩子——钩子绑定属于渲染机制。Factory 崩溃使用普通监督通道，幂等 effect 仅在 commit 后保留逐渲染位置 Store handle。
 
 </details>
 
@@ -68,6 +74,7 @@ register 调用可以用 `store: defineStore(...)` 声明 store 席位：`init`
 
 - [ui-renderer](../ui-renderer/README.zh.md)——实现本包安装约定的 React slot 渲染器。
 - [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 生命周期。
 - [Web 客户端架构](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.zh.md)——本注册表接入的加载链与对象层。
 
 -----

package/lib/index.js

@@ -46,6 +46,7 @@ const NO_ENTRIES = Object.freeze([]);
 */
 var SlotCore = class {
 	records = /* @__PURE__ */ new Map();
+	factories = /* @__PURE__ */ new Map();
 	mutateListeners = /* @__PURE__ */ new Set();
 	/** Shared-handle scope ledger: handle → the scope it first mounted under + live mount count. */
 	handleScopes = /* @__PURE__ */ new Map();
@@ -69,6 +70,96 @@ var SlotCore = class {
 		root.declaredBy = "(built-in)";
 		root.declarationEpoch = 1;
 	}
+	/** Register one reusable Factory definition. */
+	registerFactory = ((rawOptions, component) => {
+		const options = rawOptions;
+		const record = this.factoryRecord(options.name);
+		if (record.definition !== void 0) throw new Error(`slot factory "${options.name}" already has a definition`);
+		for (const childKey of Object.keys(options.children ?? {})) {
+			const childRecord = this.records.get(childKey);
+			if (childRecord?.spec !== void 0) throw new Error(`slot "${childKey}" is already declared (by ${childRecord.declaredBy ?? "an unknown entry"})`);
+		}
+		if (options.store !== void 0 && typeof options.store !== "function") {
+			const pinned = this.handleScopes.get(options.store);
+			if (pinned !== void 0 && pinned.scope !== options.scope) throw new Error(`store handle mounted under factory "${options.name}" (scope "${options.scope}") is already mounted under scope "${pinned.scope}" — one handle, one scope`);
+			if (pinned !== void 0) pinned.count += 1;
+			else this.handleScopes.set(options.store, {
+				scope: options.scope,
+				count: 1
+			});
+		}
+		const definition = {
+			name: options.name,
+			component,
+			scope: options.scope,
+			...options.children === void 0 ? {} : { children: options.children },
+			...options.store === void 0 ? {} : { store: options.store },
+			...options.inject === void 0 ? {} : { inject: options.inject },
+			...options.locale === void 0 ? {} : { locale: options.locale },
+			...options.slots === void 0 ? {} : { slots: options.slots },
+			...options.registrant === void 0 ? {} : { registrant: options.registrant }
+		};
+		record.definition = definition;
+		this.markFactoryDirty(record);
+		const declarations = [];
+		for (const [childKey, childSpec] of Object.entries(options.children ?? {})) {
+			const childRecord = this.record(childKey);
+			childRecord.spec = childSpec;
+			childRecord.declaredBy = `factory "${options.name}"${options.registrant ? ` (${options.registrant})` : ""}`;
+			childRecord.parent = `factory:${options.name}`;
+			childRecord.declarationEpoch += 1;
+			declarations.push([childKey, childRecord]);
+		}
+		for (const [childKey, childRecord] of declarations) this.markDirty(childKey, childRecord);
+		for (const [, childRecord] of declarations) this.notifyDeclaration(childRecord);
+		return () => {
+			if (record.definition !== definition) return;
+			record.definition = void 0;
+			this.markFactoryDirty(record);
+			if (definition.store !== void 0 && typeof definition.store !== "function") {
+				const pinned = this.handleScopes.get(definition.store);
+				if (pinned !== void 0 && --pinned.count === 0) this.handleScopes.delete(definition.store);
+			}
+			this.releaseChildren(definition.children);
+		};
+	});
+	/**
+	* Read one registered Factory definition.
+	* @param name - Factory name.
+	* @returns the live definition, or `undefined` when absent.
+	*/
+	factory(name) {
+		return this.factories.get(name)?.definition;
+	}
+	/**
+	* Read the monotonic definition version for one Factory name.
+	* @param name - Factory name.
+	* @returns the current version.
+	*/
+	factoryVersion(name) {
+		return this.factories.get(name)?.version ?? 0;
+	}
+	/**
+	* Subscribe to one Factory definition's registration lifetime.
+	* @param name - Factory name.
+	* @param listener - callback notified after a definition change.
+	* @returns the unsubscribe function.
+	*/
+	subscribeFactory(name, listener) {
+		const record = this.factoryRecord(name);
+		record.listeners.add(listener);
+		return () => {
+			record.listeners.delete(listener);
+		};
+	}
+	/**
+	* Return whether a retained Factory definition is still registered.
+	* @param definition - retained definition identity.
+	* @returns whether that exact definition remains live.
+	*/
+	isFactoryLive(definition) {
+		return this.factories.get(definition.name)?.definition === definition;
+	}
 	register(options, component) {
 		const rec = this.records.get(options.name);
 		if (!rec?.spec) throw new Error(`slot "${options.name}" is not declared (a parent entry's children table must declare it)`);
@@ -220,21 +311,24 @@ var SlotCore = class {
 	}
 	/**
 	* Export the current declaration topology without components or executable hooks.
-	* @param root - exact Slot key to select; omitted returns every live root.
+	* Factory definitions appear as `factory:<name>` parents of their ordinary
+	* child Slots, matching the parent/child topology of ordinary registrations.
+	* @param root - exact Slot or `factory:<name>` key to select; omitted returns every live root.
 	* @returns selected live Slot trees, or an empty array when `root` is unavailable.
 	*/
 	snapshot(root) {
-		const build = (name, seen) => {
+		const buildSlot = (name, seen) => {
 			const record = this.records.get(name);
 			if (record?.spec === void 0 || seen.has(name)) return void 0;
 			const branch = new Set(seen);
 			branch.add(name);
 			const active = new Set(this.entriesOfSlot(name));
 			const children = [...this.records.entries()].filter(([, candidate]) => candidate.spec !== void 0 && candidate.parent === name).flatMap(([child]) => {
-				const node = build(child, branch);
+				const node = buildSlot(child, branch);
 				return node === void 0 ? [] : [node];
 			});
 			return {
+				type: "slot",
 				name,
 				kind: record.spec.kind,
 				scope: record.spec.scope,
@@ -250,14 +344,35 @@ var SlotCore = class {
 				children
 			};
 		};
+		const buildFactory = (name) => {
+			const definition = this.factories.get(name)?.definition;
+			if (definition === void 0) return void 0;
+			const nodeName = `factory:${name}`;
+			const children = [...this.records.entries()].filter(([, candidate]) => candidate.spec !== void 0 && candidate.parent === nodeName).flatMap(([child]) => {
+				const node = buildSlot(child, new Set([nodeName]));
+				return node === void 0 ? [] : [node];
+			});
+			return {
+				type: "factory",
+				name,
+				scope: definition.scope,
+				...definition.registrant === void 0 ? {} : { registrant: definition.registrant },
+				children
+			};
+		};
 		if (root !== void 0) {
-			const node = build(root, /* @__PURE__ */ new Set());
+			const node = root.startsWith("factory:") ? buildFactory(root.slice(8)) : buildSlot(root, /* @__PURE__ */ new Set());
 			return node === void 0 ? [] : [node];
 		}
-		return [...this.records.entries()].filter(([, record]) => record.spec !== void 0 && (record.parent === void 0 || this.records.get(record.parent)?.spec === void 0)).flatMap(([name]) => {
-			const node = build(name, /* @__PURE__ */ new Set());
+		const slots = [...this.records.entries()].filter(([, record]) => record.spec !== void 0 && record.parent === void 0).flatMap(([name]) => {
+			const node = buildSlot(name, /* @__PURE__ */ new Set());
+			return node === void 0 ? [] : [node];
+		});
+		const factories = [...this.factories.keys()].flatMap((name) => {
+			const node = buildFactory(name);
 			return node === void 0 ? [] : [node];
 		});
+		return [...slots, ...factories];
 	}
 	/**
 	* Read the declaration lifetime of a key. Entry additions and removals do
@@ -347,13 +462,21 @@ var SlotCore = class {
 		for (const fn of [...this.entryErrorListeners]) fn(key, entry, error, { abdicated: info.abdicate });
 	}
 	/**
-	* Observe entry boundary crashes (every render-time entry failure the
-	* boundaries contain, abdicating or not) — the supervision seam for hosts
-	* mirroring contribution health. Fires synchronously per report, after the
-	* registry mutated for abdicating crashes (same listener discipline as
-	* {@link SlotCore.onMutate}).
-	* @param fn - called with the slot key, the crashed entry, the crash
-	* cause, and `abdicated`: whether the crash retired the entry from its cell.
+	* Report a contained Factory occurrence crash through the ordinary entry
+	* supervision channel without retiring the shared definition.
+	* @param name - Factory name whose occurrence crashed.
+	* @param registration - Factory definition or caller registration that owns the crashing Component.
+	* @param error - the crash cause, forwarded to listeners verbatim.
+	*/
+	reportFactoryError(name, registration, error) {
+		for (const fn of [...this.entryErrorListeners]) fn(`factory:${name}`, registration, error, { abdicated: false });
+	}
+	/**
+	* Observe ordinary entry and Factory occurrence crashes. Fires synchronously
+	* per report, after any ordinary-entry abdication mutation. Factory failures
+	* never retire their shared definition.
+	* @param fn - called with the Slot or `factory:<name>` key, the crashed
+	* registration, the cause, and whether an ordinary entry was retired.
 	* @returns unsubscribe.
 	*/
 	onEntryError(fn) {
@@ -373,8 +496,11 @@ var SlotCore = class {
 			const pinned = this.handleScopes.get(entry.store);
 			if (pinned && --pinned.count === 0) this.handleScopes.delete(entry.store);
 		}
-		if (!entry.children) return;
-		for (const childKey of Object.keys(entry.children)) {
+		this.releaseChildren(entry.children);
+	}
+	releaseChildren(children) {
+		if (children === void 0) return;
+		for (const childKey of Object.keys(children)) {
 			const childRec = this.records.get(childKey);
 			/* v8 ignore next -- defensive: declaring always creates the record */
 			if (!childRec) continue;
@@ -406,6 +532,24 @@ var SlotCore = class {
 		}
 		return rec;
 	}
+	factoryRecord(name) {
+		let record = this.factories.get(name);
+		if (record === void 0) {
+			record = {
+				definition: void 0,
+				version: 0,
+				listeners: /* @__PURE__ */ new Set()
+			};
+			this.factories.set(name, record);
+		}
+		return record;
+	}
+	markFactoryDirty(record) {
+		record.version += 1;
+		queueMicrotask(() => {
+			for (const listener of [...record.listeners]) listener();
+		});
+	}
 	markDirty(key, rec) {
 		rec.version += 1;
 		for (const fn of [...this.mutateListeners]) fn(key);

package/lib/types/index.d.ts

@@ -16,6 +16,9 @@ export * from './renderer.ts';
 /** Slot contract table. Owners extend via declaration merging; entries are {@link SlotEntryDef}. */
 export interface SlotMap {
 }
+/** Reusable Component Factory contract table, extended through declaration merging. */
+export interface SlotFactoryMap {
+}
 /**
  * Locale namespace table. Dictionary owners extend via declaration merging
  * (exactly like {@link SlotMap}, and declared in this entry module for the
@@ -80,12 +83,15 @@ export type PropsLocale<N> = N extends keyof LocaleNamespaceMap & string ? {
 export type SlotKind = 'single' | 'list' | 'keyed' | 'chain';
 /** Slot data context: global, current-session-optional, or strict session-bound. */
 export type SlotScope = 'root' | 'session-maybe' | 'session';
+/** Declaration-merged explicit target types for non-root scope Providers. */
+export interface SlotScopeTargetMap {
+}
 /**
  * One SlotMap entry: kind/scope axes plus the optional owner-supplied props
  * share (`owner` is what the parent passes at its renderSlot call site; the
  * framework standard kit and the registrant's injected share never enter this
- * table — full component props compose at the component as the four-share
- * intersection, see {@link ComposedProps}).
+ * table — full component props compose at the component from the framework
+ * shares, see {@link ComposedProps}).
  */
 export interface SlotEntryDef {
     kind: SlotKind;
@@ -110,6 +116,21 @@ export interface SlotEntryDef {
      */
     inject?: object;
 }
+/** One caller-selected Component position inside a reusable Factory. */
+export interface FactoryLocalSlotDef {
+    scope: SlotScope;
+    props?: object;
+}
+/** Complete static definition of one reusable Component Factory. */
+export interface SlotFactoryDef {
+    scope: SlotScope;
+    props?: object;
+    children?: ChildrenDecl;
+    store?: StoreDecl;
+    inject?: object;
+    locale?: keyof LocaleNamespaceMap & string;
+    slots?: Record<string, FactoryLocalSlotDef>;
+}
 /**
  * Runtime dispatch spec for one slot, recorded from a register call's
  * `children` value. The literal is compile-time checked against the SlotMap
@@ -170,10 +191,10 @@ export type ScopeOf<K extends keyof SlotMap & string> = SlotMap[K]['scope'];
 export interface SessionStandardProps {
 }
 /**
- * Framework standard kit delivered to current-session-optional slots. Its
- * hooks stay callable while no session is selected and return `undefined`
- * until one becomes current; `ui-session` and domain UI adapters merge the
- * concrete members.
+ * Framework standard kit delivered to session-optional slots. Its hooks stay
+ * callable while no session is selected and return `undefined` until one
+ * becomes current; `ui-session` and domain UI adapters merge the concrete
+ * members.
  */
 export interface SessionMaybeStandardProps {
 }
@@ -192,11 +213,13 @@ export interface GlobalStandardProps {
 export type SessionIdOf = SessionStandardProps extends {
     sessionId: infer S;
 } ? S : string;
+/** Standard props selected by one declared scope. */
+export type ScopeStandardProps<S extends SlotScope> = (S extends 'session' ? SessionStandardProps : S extends 'session-maybe' ? SessionMaybeStandardProps : object) & GlobalStandardProps;
 /**
  * Runtime props share for a slot key: owner share (parent's renderSlot call
  * site) + session standard kit (session scope only) + the global seat.
  */
-export type PropsRuntime<K extends keyof SlotMap & string, EntryKey extends EntryKeyOf<K> = EntryKeyOf<K>> = OwnerOf<K> & KeyPropsOf<K, EntryKey> & SlotInjectFace<SlotInjectOf<K>> & (ScopeOf<K> extends 'session' ? SessionStandardProps : ScopeOf<K> extends 'session-maybe' ? SessionMaybeStandardProps : object) & GlobalStandardProps;
+export type PropsRuntime<K extends keyof SlotMap & string, EntryKey extends EntryKeyOf<K> = EntryKeyOf<K>> = OwnerOf<K> & KeyPropsOf<K, EntryKey> & SlotInjectFace<SlotInjectOf<K>> & ScopeStandardProps<ScopeOf<K>>;
 /** renderSlot dispatch options: keyed dispatch key, list filtering, and empty fallback. */
 export interface RenderOpts<EntryKey extends string = string> {
     entryKey?: EntryKey;
@@ -262,15 +285,20 @@ export type MatchedShare<E extends SlotEntryDef, M> = E['kind'] extends 'chain'
 } : object;
 /** Props of the standard-kit SessionProvider seat. */
 export interface SessionAreaProps {
+    /**
+     * Explicit Session-scope target. Omit this property to inherit the surrounding
+     * binding; pass `undefined` to establish an explicitly absent binding.
+     */
+    readonly session?: SlotScopeTargetMap[keyof SlotScopeTargetMap & 'session'] | undefined;
     /** No-session body (also covers a current id whose session cannot be resolved). */
     empty?: (() => ReactNode) | undefined;
-    /** Session body; the framework remounts it per session identity. */
+    /** Session body; scoped entries apply their declared remount semantics. */
     children: ReactNode;
 }
 /**
  * Framework-wired session area component. `ui-session` supplies the current
  * Controller binding through the renderer scope adapter; entries that declare
- * session-scoped children receive this component without importing it.
+ * `session` or `session-maybe` children receive this component without importing it.
  */
 export type SessionProviderComponent = (props: SessionAreaProps) => ReactNode;
 /**
@@ -304,15 +332,76 @@ export type PropsRenderSlots<S extends keyof SlotMap & string> = {
      * @returns rendered node(s).
      */
     renderSlotChain: <K extends ChainKeysOf<S>>(key: K, owner: OwnerOf<K>, opts?: ChainRenderOpts) => ReactNode;
-}) & ('session' extends ScopeOf<S> ? {
+}) & ([Extract<ScopeOf<S>, 'session' | 'session-maybe'>] extends [never] ? object : {
     SessionProvider: SessionProviderComponent;
-} : object);
+});
 /**
  * Registration-position component shape: the bare call signature, so composed
  * constraints check through clean parameter contravariance (FC statics add
  * covariant noise rejecting legitimate narrowings).
  */
 export type SlotComponent<P> = (props: P) => ReactNode;
+type FactoryDefOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] & SlotFactoryDef;
+type FactoryInputPropsOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    props: infer P extends object;
+} ? P : object;
+type FactoryChildrenOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    children: infer D extends Record<string, unknown>;
+} ? D : Record<never, never>;
+type FactoryStoreOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    store: infer H extends StoreDecl;
+} ? HandleOf<H> : undefined;
+type FactoryInjectOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    inject: infer I extends object;
+} ? I : object;
+type FactoryLocaleOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    locale: infer N extends keyof LocaleNamespaceMap & string;
+} ? N : undefined;
+type FactoryLocalSlotsOf<F extends keyof SlotFactoryMap & string> = SlotFactoryMap[F] extends {
+    slots: infer S extends Record<string, FactoryLocalSlotDef>;
+} ? S : Record<never, never>;
+type FactoryLocalNameOf<F extends keyof SlotFactoryMap & string> = keyof FactoryLocalSlotsOf<F> & string;
+type FactoryLocalDefOf<F extends keyof SlotFactoryMap & string, N extends FactoryLocalNameOf<F>> = FactoryLocalSlotsOf<F>[N] & FactoryLocalSlotDef;
+type FactoryLocalInputPropsOf<F extends keyof SlotFactoryMap & string, N extends FactoryLocalNameOf<F>> = FactoryLocalDefOf<F, N> extends {
+    props: infer P extends object;
+} ? P : object;
+type FactoryRenderPropsOf<F extends keyof SlotFactoryMap & string> = [
+    keyof FactoryChildrenOf<F> & keyof SlotMap & string
+] extends [never] ? object : PropsRenderSlots<keyof FactoryChildrenOf<F> & keyof SlotMap & string>;
+/** Framework-derived props shared by a Factory definition and its local Components. */
+export type FactoryRegistrationPropsOf<F extends keyof SlotFactoryMap & string> = FactoryRenderPropsOf<F> & PropsStore<FactoryStoreOf<F>> & InjectFace<FactoryInjectOf<F>> & PropsLocale<FactoryLocaleOf<F>> & PropsRenderFactories;
+/** Complete props received by a registered Factory Component. */
+export type FactoryComponentPropsOf<F extends keyof SlotFactoryMap & string> = FactoryInputPropsOf<F> & FactoryRegistrationPropsOf<F> & ScopeStandardProps<FactoryDefOf<F>['scope']> & {
+    useFactorySlot: UseFactorySlot<F>;
+};
+/** Complete props received by one caller-selected or fallback local Component. */
+export type FactoryLocalComponentPropsOf<F extends keyof SlotFactoryMap & string, N extends FactoryLocalNameOf<F>> = FactoryLocalInputPropsOf<F, N> & FactoryRegistrationPropsOf<F> & ScopeStandardProps<FactoryLocalDefOf<F, N>['scope']>;
+/** Component accepted for one declared local Factory position. */
+export type FactoryLocalComponent<F extends keyof SlotFactoryMap & string, N extends FactoryLocalNameOf<F>> = SlotComponent<FactoryLocalComponentPropsOf<F, N>>;
+/**
+ * Hook exposed only to a Factory definition for selecting a local Component.
+ * @param name - declared local position.
+ * @param fallback - Component used when the occurrence caller makes no selection.
+ * @returns a stable Component accepting only the local occurrence props.
+ */
+export type UseFactorySlot<F extends keyof SlotFactoryMap & string> = <N extends FactoryLocalNameOf<F>>(name: N, fallback: FactoryLocalComponent<F, N>) => SlotComponent<FactoryLocalInputPropsOf<F, N>>;
+/**
+ * Render one independently keyed occurrence of a registered Factory.
+ * @param name - declaration-merged Factory name.
+ * @param props - caller-owned occurrence input.
+ * @param options - local Component selections and the missing-definition fallback.
+ * @returns the Factory occurrence or fallback.
+ */
+export type RenderFactorySlot = <F extends keyof SlotFactoryMap & string>(name: F, props: FactoryInputPropsOf<F>, options?: {
+    slots?: Partial<{
+        [N in FactoryLocalNameOf<F>]: FactoryLocalComponent<F, N>;
+    }>;
+    fallback?: ReactNode;
+}) => ReactNode;
+/** Factory rendering capability supplied to every renderer-created Component. */
+export interface PropsRenderFactories {
+    renderFactorySlot: RenderFactorySlot;
+}
 /**
  * Registrant hooks compartment: bare observable sources (getSnapshot +
  * subscribe pairs) supplied under the reserved `hooks` key of an entry's
@@ -382,7 +471,7 @@ export type InjectFace<I extends object> = I extends {
  * {@link PropsLocale}). Each share derives from its single source of truth;
  * components reference this composition, never re-type it.
  */
-export type ComposedProps<K extends keyof SlotMap & string, EntryKey extends EntryKeyOf<K>, S extends keyof SlotMap & string, H, I extends object, M = never, N = undefined> = PropsRuntime<K, EntryKey> & PropsRenderSlots<S> & PropsStore<H> & InjectFace<I> & MatchedShare<SlotMap[K], M> & PropsLocale<N>;
+export type ComposedProps<K extends keyof SlotMap & string, EntryKey extends EntryKeyOf<K>, S extends keyof SlotMap & string, H, I extends object, M = never, N = undefined> = PropsRuntime<K, EntryKey> & PropsRenderSlots<S> & PropsRenderFactories & PropsStore<H> & InjectFace<I> & MatchedShare<SlotMap[K], M> & PropsLocale<N>;
 /**
  * Inject factory parameter list, derived from the registration's declaration:
  * strict session slots receive a definite framework-resolved `sessionId`;
@@ -392,6 +481,72 @@ export type ComposedProps<K extends keyof SlotMap & string, EntryKey extends Ent
  * object parameter exists.
  */
 export type InjectParams<K extends keyof SlotMap & string, H> = ScopeOf<K> extends 'session' ? ([H] extends [StoreDecl] ? [sessionId: SessionIdOf, actions: BoundActions<HandleOf<H>>] : [sessionId: SessionIdOf]) : ScopeOf<K> extends 'session-maybe' ? ([H] extends [StoreDecl] ? [sessionId: SessionIdOf | undefined, actions: BoundActions<HandleOf<H>> | undefined] : [sessionId: SessionIdOf | undefined]) : ([H] extends [StoreDecl] ? [actions: BoundActions<HandleOf<H>>] : []);
+/** Factory inject parameters use the same scope/store matrix as ordinary registrations. */
+export type FactoryInjectParams<F extends keyof SlotFactoryMap & string> = FactoryDefOf<F>['scope'] extends 'session' ? ([FactoryStoreOf<F>] extends [StoreDecl] ? [sessionId: SessionIdOf, actions: BoundActions<FactoryStoreOf<F>>] : [sessionId: SessionIdOf]) : FactoryDefOf<F>['scope'] extends 'session-maybe' ? ([FactoryStoreOf<F>] extends [StoreDecl] ? [sessionId: SessionIdOf | undefined, actions: BoundActions<FactoryStoreOf<F>> | undefined] : [sessionId: SessionIdOf | undefined]) : ([FactoryStoreOf<F>] extends [StoreDecl] ? [actions: BoundActions<FactoryStoreOf<F>>] : []);
+type FactoryField<F extends keyof SlotFactoryMap & string, K extends keyof SlotFactoryDef, Value> = K extends keyof SlotFactoryMap[F] ? {
+    [P in K]-?: Value;
+} : {
+    [P in K]?: never;
+};
+type RuntimeFactorySlots<F extends keyof SlotFactoryMap & string> = {
+    [N in FactoryLocalNameOf<F>]: {
+        scope: FactoryLocalDefOf<F, N>['scope'];
+    };
+};
+type FactoryInjectCollisionKeys<F extends keyof SlotFactoryMap & string> = Extract<keyof InjectFace<FactoryInjectOf<F>>, keyof (FactoryRenderPropsOf<F> & PropsStore<FactoryStoreOf<F>> & PropsLocale<FactoryLocaleOf<F>> & PropsRenderFactories & ScopeStandardProps<FactoryDefOf<F>['scope']> & {
+    useFactorySlot: UseFactorySlot<F>;
+})>;
+type FactoryInputCollisionKeys<F extends keyof SlotFactoryMap & string> = Extract<keyof FactoryInputPropsOf<F>, keyof (FactoryRegistrationPropsOf<F> & ScopeStandardProps<FactoryDefOf<F>['scope']> & {
+    useFactorySlot: UseFactorySlot<F>;
+})>;
+type FactoryLocalCollisionKeys<F extends keyof SlotFactoryMap & string> = {
+    [N in FactoryLocalNameOf<F>]: Extract<keyof FactoryLocalInputPropsOf<F, N>, keyof (FactoryRegistrationPropsOf<F> & ScopeStandardProps<FactoryLocalDefOf<F, N>['scope']>)>;
+}[FactoryLocalNameOf<F>];
+type FactoryRegistrationLocalScopeCollisionKeys<F extends keyof SlotFactoryMap & string> = {
+    [N in FactoryLocalNameOf<F>]: Extract<keyof FactoryRegistrationPropsOf<F>, keyof ScopeStandardProps<FactoryLocalDefOf<F, N>['scope']>>;
+}[FactoryLocalNameOf<F>];
+type FactoryCollisionCheck<F extends keyof SlotFactoryMap & string> = [
+    FactoryInjectCollisionKeys<F> | FactoryInputCollisionKeys<F> | FactoryLocalCollisionKeys<F> | FactoryRegistrationLocalScopeCollisionKeys<F>
+] extends [never] ? unknown : {
+    'Factory declaration has overlapping prop ownership': FactoryInjectCollisionKeys<F> | FactoryInputCollisionKeys<F> | FactoryLocalCollisionKeys<F> | FactoryRegistrationLocalScopeCollisionKeys<F>;
+};
+type FactoryChildMismatchKeys<F extends keyof SlotFactoryMap & string> = {
+    [K in keyof FactoryChildrenOf<F>]: K extends keyof SlotMap ? FactoryChildrenOf<F>[K] extends SlotSpec<SlotMap[K]> ? never : K : K;
+}[keyof FactoryChildrenOf<F>];
+type FactoryChildrenCheck<F extends keyof SlotFactoryMap & string> = [
+    FactoryChildMismatchKeys<F>
+] extends [never] ? unknown : {
+    'Factory children must match SlotMap': FactoryChildMismatchKeys<F>;
+};
+/** Registration options checked against the complete declaration-merged Factory definition. */
+export type RegisterFactoryOptions<F extends keyof SlotFactoryMap & string> = {
+    name: F;
+    scope: FactoryDefOf<F>['scope'];
+} & FactoryField<F, 'children', FactoryChildrenOf<F>> & FactoryField<F, 'store', FactoryStoreOf<F> | (() => FactoryStoreOf<F>)> & FactoryField<F, 'inject', (...args: FactoryInjectParams<F>) => FactoryInjectOf<F>> & FactoryField<F, 'locale', FactoryLocaleOf<F>> & FactoryField<F, 'slots', RuntimeFactorySlots<F>> & FactoryCollisionCheck<F> & FactoryChildrenCheck<F>;
+/**
+ * Typed registration method implemented by the renderer-owned SlotRegistry service.
+ * @param options - runtime values checked against the Factory declaration.
+ * @param component - reusable definition Component.
+ * @returns an idempotent definition disposer.
+ */
+export interface RegisterFactory {
+    <F extends keyof SlotFactoryMap & string>(options: RegisterFactoryOptions<F>, component: SlotComponent<FactoryComponentPropsOf<F>>): () => void;
+}
+/** Type-erased Factory definition stored by the runtime registry. */
+export interface StoredFactory {
+    readonly name: string;
+    readonly component: unknown;
+    readonly scope: SlotScope;
+    readonly children?: Readonly<Record<string, SlotSpec<SlotEntryDef>>> | undefined;
+    readonly store?: StoreDecl | undefined;
+    readonly inject?: ((...args: never[]) => Record<string, unknown>) | undefined;
+    readonly locale?: string | undefined;
+    readonly slots?: Readonly<Record<string, {
+        scope: SlotScope;
+    }>> | undefined;
+    /** Diagnostics label of who registered the definition. */
+    readonly registrant?: string | undefined;
+}
 /**
  * A list-entry display label: a plain string, or a thunk re-evaluated per
  * read so registration-time text (nav rows, tabs) follows the active locale
@@ -506,8 +661,10 @@ export interface LiveSlotOccupant {
     /** Whether the renderer currently selects this entry. */
     active: boolean;
 }
-/** JSON-safe live slot declaration tree. */
+/** JSON-safe live Slot declaration tree. */
 export interface LiveSlotNode {
+    /** Discriminant for an ordinary Slot declaration. */
+    type: 'slot';
     /** Exact SlotMap key. */
     name: string;
     /** Slot cardinality. */
@@ -521,6 +678,21 @@ export interface LiveSlotNode {
     /** Slots declared by entries mounted in this slot. */
     children: LiveSlotNode[];
 }
+/** JSON-safe live Factory definition with its ordinary child Slot tree. */
+export interface LiveFactoryNode {
+    /** Discriminant for a reusable Factory definition. */
+    type: 'factory';
+    /** Exact SlotFactoryMap key. */
+    name: string;
+    /** Runtime data scope inherited by each occurrence. */
+    scope: SlotScope;
+    /** Plugin or package that registered the definition, when known. */
+    registrant?: string;
+    /** Ordinary Slots declared by the Factory definition. */
+    children: LiveSlotNode[];
+}
+/** One root in the live Slot/Factory composition topology. */
+export type LiveCompositionNode = LiveSlotNode | LiveFactoryNode;
 /**
  * Pure slot registry (no cordis; event emission and the renderer installation contract
  * live in the runtime Service wrapper).
@@ -539,6 +711,7 @@ export interface LiveSlotNode {
  */
 export declare class SlotCore {
     private records;
+    private factories;
     private mutateListeners;
     /** Shared-handle scope ledger: handle → the scope it first mounted under + live mount count. */
     private handleScopes;
@@ -554,6 +727,33 @@ export declare class SlotCore {
     private abdicated;
     private entryErrorListeners;
     constructor();
+    /** Register one reusable Factory definition. */
+    readonly registerFactory: RegisterFactory;
+    /**
+     * Read one registered Factory definition.
+     * @param name - Factory name.
+     * @returns the live definition, or `undefined` when absent.
+     */
+    factory(name: string): StoredFactory | undefined;
+    /**
+     * Read the monotonic definition version for one Factory name.
+     * @param name - Factory name.
+     * @returns the current version.
+     */
+    factoryVersion(name: string): number;
+    /**
+     * Subscribe to one Factory definition's registration lifetime.
+     * @param name - Factory name.
+     * @param listener - callback notified after a definition change.
+     * @returns the unsubscribe function.
+     */
+    subscribeFactory(name: string, listener: () => void): () => void;
+    /**
+     * Return whether a retained Factory definition is still registered.
+     * @param definition - retained definition identity.
+     * @returns whether that exact definition remains live.
+     */
+    isFactoryLive(definition: StoredFactory): boolean;
     /**
      * Contribute a component to a declared slot and (optionally) declare child
      * slots, a store seat, and the registrant's business face.
@@ -581,7 +781,7 @@ export declare class SlotCore {
      * @param options - registration options: target `name`, `children`
      * declaration table, `store` seat, `inject` business-face factory, kind
      * shape fields (keyed `key`; list `id`/`order`/`label`).
-     * @param component - component honoring the four-share composed props
+     * @param component - component honoring the five-share composed props
      * contract ({@link ComposedProps}); checked at this call site.
      * @returns disposer removing the registration and its declarations
      * (idempotent; stale disposers after a cascade are no-ops).
@@ -595,7 +795,7 @@ export declare class SlotCore {
      * factory's return and joins the component's composed-props constraint
      * (factory parameters derive from the declaration, {@link InjectParams}).
      * @param options - registration options plus the `inject` business-face factory.
-     * @param component - component honoring the four-share composed props
+     * @param component - component honoring the five-share composed props
      * contract including the inject share `I`.
      * @returns disposer removing the registration and its declarations.
      */
@@ -648,10 +848,12 @@ export declare class SlotCore {
     specDynamic(key: string): SlotSpec<SlotEntryDef> | undefined;
     /**
      * Export the current declaration topology without components or executable hooks.
-     * @param root - exact Slot key to select; omitted returns every live root.
+     * Factory definitions appear as `factory:<name>` parents of their ordinary
+     * child Slots, matching the parent/child topology of ordinary registrations.
+     * @param root - exact Slot or `factory:<name>` key to select; omitted returns every live root.
      * @returns selected live Slot trees, or an empty array when `root` is unavailable.
      */
-    snapshot(root?: string): LiveSlotNode[];
+    snapshot(root?: string): LiveCompositionNode[];
     /**
      * Read the declaration lifetime of a key. Entry additions and removals do
      * not change it; declaration creation and collapse each advance it.
@@ -713,16 +915,22 @@ export declare class SlotCore {
         abdicate: boolean;
     }): void;
     /**
-     * Observe entry boundary crashes (every render-time entry failure the
-     * boundaries contain, abdicating or not) — the supervision seam for hosts
-     * mirroring contribution health. Fires synchronously per report, after the
-     * registry mutated for abdicating crashes (same listener discipline as
-     * {@link SlotCore.onMutate}).
-     * @param fn - called with the slot key, the crashed entry, the crash
-     * cause, and `abdicated`: whether the crash retired the entry from its cell.
+     * Report a contained Factory occurrence crash through the ordinary entry
+     * supervision channel without retiring the shared definition.
+     * @param name - Factory name whose occurrence crashed.
+     * @param registration - Factory definition or caller registration that owns the crashing Component.
+     * @param error - the crash cause, forwarded to listeners verbatim.
+     */
+    reportFactoryError(name: string, registration: StoredEntry | StoredFactory, error: unknown): void;
+    /**
+     * Observe ordinary entry and Factory occurrence crashes. Fires synchronously
+     * per report, after any ordinary-entry abdication mutation. Factory failures
+     * never retire their shared definition.
+     * @param fn - called with the Slot or `factory:<name>` key, the crashed
+     * registration, the 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;
     /**
@@ -732,7 +940,10 @@ export declare class SlotCore {
      * axis: ledger rows, slots, contributions, and store mounts die together.
      */
     private releaseEntry;
+    private releaseChildren;
     private record;
+    private factoryRecord;
+    private markFactoryDirty;
     private markDirty;
     private notifyDeclaration;
     private flush;

package/lib/types/renderer.d.ts

@@ -2,7 +2,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { ReactNode } from 'react';
 import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
-import type { SessionAreaProps, SlotEntryDef, SlotScope, SlotSpec, StoredEntry, Translate } from './index.ts';
+import type { SessionAreaProps, SlotEntryDef, SlotScope, SlotSpec, StoredEntry, StoredFactory, Translate } from './index.ts';
 /**
  * The locale face the render machinery consumes: namespace binding plus an
  * observable revision (getSnapshot/subscribe pair — the same HostObservable
@@ -78,14 +78,14 @@ export interface ScopedStandardSourceBinding extends StandardSourceBinding {
 }
 /** One installed source of bindings for a non-root Slot scope. */
 export interface SlotScopeAdapter {
-    /** Binding that follows the current selection, including its absent projection. */
+    /** Default binding inherited by scoped entries, including its absent projection. */
     readonly current: HostObservable<StandardSourceBinding>;
     /**
-     * Resolve an already-materialized binding.
-     * @param key - scope identity.
-     * @returns the binding, or `undefined` when the identity is unavailable.
+     * Resolve a stable observable for an explicit scope target or explicit absence.
+     * @param target - domain-owned Provider target, or absence.
+     * @returns the target's current standard-source binding.
      */
-    resolve(key: string): ScopedStandardSourceBinding | undefined;
+    bindingSource(target: SessionAreaProps['session']): HostObservable<StandardSourceBinding>;
     /**
      * Render the scope owner's area seat over the current binding. The renderer
      * binds this function to the standard `SessionProvider` prop without owning
@@ -154,6 +154,13 @@ export interface SlotRendererHost {
     reportEntryError(key: string, entry: StoredEntry, error: unknown, info: {
         abdicate: boolean;
     }): void;
+    /**
+     * Report a contained Factory occurrence crash without retiring its shared definition.
+     * @param name - Factory name whose occurrence crashed.
+     * @param registration - Factory definition or caller registration that owns the crashing Component.
+     * @param error - the crash cause.
+     */
+    reportFactoryError(name: string, registration: StoredEntry | StoredFactory, error: unknown): void;
     /**
      * Declared runtime spec from the declarations ledger.
      * @param key - slot key.
@@ -174,6 +181,47 @@ export interface SlotRendererHost {
      * @returns the instance, or undefined when the entry declares no store.
      */
     storeOf(entry: StoredEntry, scopeBinding: ScopedStandardSourceBinding | undefined): StoreInstanceLike | undefined;
+    /**
+     * Resolve a Factory Store for one render occurrence and inherited scope.
+     * @param definition - live Factory definition.
+     * @param scopeBinding - exact Session binding for scoped Factories, undefined for root scope.
+     * @param occurrence - identity token owned by the render position.
+     * @returns the occurrence Store instance, or undefined without a Store declaration.
+     */
+    factoryStoreOf(definition: StoredFactory, scopeBinding: ScopedStandardSourceBinding | undefined, occurrence: object): StoreInstanceLike | undefined;
+    /**
+     * Retain an exclusive Factory Store occurrence after React commits it.
+     * Repeated setup and cleanup preserve the occurrence's Store identity.
+     * @param definition - the live Factory definition.
+     * @param occurrence - identity token owned by the mounted render position.
+     * @returns an idempotent cleanup function.
+     */
+    retainFactoryOccurrence(definition: StoredFactory, occurrence: object): () => void;
+    /**
+     * Subscribe to one Factory definition's registration lifetime.
+     * @param name - Factory name.
+     * @param fn - change callback.
+     * @returns the unsubscribe function.
+     */
+    subscribeFactory(name: string, fn: () => void): () => void;
+    /**
+     * Read the monotonic version for one Factory definition.
+     * @param name - Factory name.
+     * @returns the current definition version.
+     */
+    getFactoryVersion(name: string): number;
+    /**
+     * Read one live Factory definition.
+     * @param name - Factory name.
+     * @returns the definition, or undefined while unregistered.
+     */
+    factoryOf(name: string): StoredFactory | undefined;
+    /**
+     * Check retained Factory render authority.
+     * @param definition - a previously resolved Factory definition.
+     * @returns whether that exact definition remains live.
+     */
+    isFactoryLive(definition: StoredFactory): boolean;
     /** Root standard data assembled from domain-owned contributions. */
     readonly root: HostObservable<StandardSourceBinding>;
     /** Monotonic source updated whenever the installed scope-adapter roster changes. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-slots",
-  "description": "Slot registry pure core: SlotMap declaration merging, single register composition API, four-share props types, store-seat types, renderer install seam",
-  "version": "0.1.6-alpha.1",
+  "description": "Slot registry pure core: typed ordinary Slots and reusable Component Factories, derived props, Store seats, and renderer installation",
+  "version": "0.1.7-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -24,14 +24,14 @@
   "license": "MIT",
   "devDependencies": {
     "@types/react": "~18.3.1",
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-store": "^0.1.6-alpha.1"
+    "@deepseek-ai/cordis": "^4.0.3",
+    "@deepseek-ai/dsh-client-store": "^0.1.7-alpha.1"
   },
   "files": [
     "lib/index.js",
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2"
+    "@deepseek-ai/cordis": "^4.0.3"
   }
 }