@x1a0f3n9/dsh-client-ui-slots 0.1.5-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/client/ui-slots/README.md
+README.md: d38fe059693f7b15d060b0a52c97edd0b5e050c9
+README.zh.md: 968470edd20d75b7c6bf8f7c8fca898764af757e

package/README.md

@@ -0,0 +1,104 @@
+---
+description: "Slot registry pure core for the dsh web client: SlotMap declaration merging, the single register composition API, four-share props types, store seats, and the renderer install contract."
+kind: "package-library"
+---
+
+# @x1a0f3n9/dsh-client-ui-slots
+
+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.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+Compose UI through this package whenever you write a client plugin: register a component into a slot your parent declared, or declare child slots your component renders. The four kinds cover the composition shapes — `single` (one occupant), `list` (ordered entries), `keyed` (dispatch by a key), and `chain` (entries elect themselves).
+
+### The four props shares
+
+Every registered component receives props composed from four shares: the runtime share (`owner` from the parent's renderSlot call site, plus the session standard kit and global seat), the child-render share (`renderSlot` statically narrowed to the declared children keys), the store share (the declared handle's selector hook and draft-stripped actions), and the business share (inferred from the `inject` factory's return). Components reference `ComposedProps`; they never re-type a share locally.
+
+### Store seats
+
+A register call may declare a store seat with `store: defineStore(...)`: `init` infers the state schema and `actions` is the complete draft-transform write set. Components read through the selector hook and write through the baked callbacks; the engine implementation of `defineStore` lives in the runtime package and satisfies the `DefineStore` contract exported here.
+
+### Declaration discipline
+
+Declaring a slot is claiming it: the registering entry becomes the only entry allowed to render that key, and registering into an undeclared slot, declaring an already-declared child, mounting one shared handle under two scopes, or registering a chain without `select` throws at load. An entry's disposer collapses its declared child slots recursively — ledger rows, contributions, and store mounts die on one lifecycle axis.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<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.
+
+### 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.
+
+### The renderer contract
+
+`renderer.ts` carries the installation contract (`SlotRenderer`, `SlotRendererHost`) plus `StaleAuthorizationError`/`SlotOwnershipError`; ui-renderer owns both the implementation and its plugin-lifecycle installation. Engine products and the renderer host contract carry bare snapshot sources (`getSnapshot`/`subscribe`), never React hooks — hook binding belongs to the render machinery.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+These pages cover the engine, the renderer, and the composition model.
+
+- [ui-renderer](../ui-renderer/README.md) — the React slot renderer implementing this package's install contract.
+- [Slot system standard](../../../.agents/notes/implemented/architecture/2026-07-22-slot-type-chain-implementation.md) — the definitive composition model.
+- [Web client architecture](../../../.agents/notes/implemented/architecture/2026-07-19-gui-web-client-architecture.md) — the loading chain and object layer this registry plugs into.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as the package is a browser-side UI plugin layer that registers nothing model-facing.
+
+#### KV Cache effect
+
+None; this package neither assembles nor sends a provider request.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define the registry's scaling behavior and accepted type noise; they are current package constraints.
+
+- **`isLive` scans all records linearly** — fine at UI-plugin registration counts (tens); revisit with an entry→record backref if ledgers ever grow hot.
+- **The `__renders` phantom anchor is visible on `PropsRenderSlots`** — the same accepted noise as the type-chain design's `__accepts`: generic method signatures compare loosely across key unions, so the contravariant marker is what enforces "component key set ⊆ children declaration".
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>
+
+**Runtime invariant:** No companion is published. This is a zero-dependency pure registry core; it emits no Cordis events itself (the `ui-renderer` SlotRegistry owns the event bridge and its invariants); define/register/dispose sequencing is asserted directly by this package's behavior specs.

package/README.zh.md

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

package/lib/index.js

@@ -0,0 +1,433 @@
+//#region lib/types/renderer.js
+/**
+* Convert one standard source name to its rendered Hook prop name.
+* @param name - registered fixed or keyed source name.
+* @returns the `use<Name>` prop exposed to Slot components.
+*/
+function standardHookPropName(name) {
+	return `use${name[0]?.toUpperCase() ?? ""}${name.slice(1)}`;
+}
+/** Thrown when a retained renderSlot binding is invoked after its declaring entry was disposed. */
+var StaleAuthorizationError = class extends Error {};
+/**
+* Thrown when a renderSlot binding is invoked for a key outside its entry's
+* children declaration (plain-JS backstop; typed callers are narrowed
+* statically).
+*/
+var SlotOwnershipError = class extends Error {};
+//#endregion
+//#region lib/types/index.js
+/**
+* Resolve a possibly-thunked list label at read time (thunks follow the
+* active locale; owners projecting ledger rows call this instead of reading
+* `options.label` raw).
+* @param label - the stored label.
+* @returns the display string, or undefined when the entry declared none.
+*/
+function resolveSlotLabel(label) {
+	return typeof label === "function" ? label() : label;
+}
+const NO_ENTRIES = Object.freeze([]);
+/**
+* Pure slot registry (no cordis; event emission and the renderer installation contract
+* live in the runtime Service wrapper).
+*
+* The 'root' slot is the one a-priori declaration, seeded at construction
+* (single/root, declared by the framework) — the render tree's root hole.
+*
+* Change propagation contract: versions bump and {@link SlotCore.onMutate}
+* fires synchronously per mutation (registry state is consistent when they
+* fire); {@link SlotCore.subscribeDeclaration} fires synchronously for each
+* declaration lifetime boundary; {@link SlotCore.subscribe} notifications
+* batch per microtask, so N same-tick mutations produce one notification per
+* touched key. Entry crash reports ({@link SlotCore.reportEntryError}) ride
+* the same mutation channel when they abdicate, then notify
+* {@link SlotCore.onEntryError} synchronously.
+*/
+var SlotCore = class {
+	records = /* @__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();
+	dirty = /* @__PURE__ */ new Set();
+	flushScheduled = false;
+	/**
+	* Entries retired by an abdicating crash report
+	* ({@link SlotCore.reportEntryError}): excluded from
+	* {@link SlotCore.entriesOfSlot} projections for the rest of their
+	* registration's life, while the registration itself stays on the ledger
+	* (disposal authority remains with the registrant).
+	*/
+	abdicated = /* @__PURE__ */ new WeakSet();
+	entryErrorListeners = /* @__PURE__ */ new Set();
+	constructor() {
+		const root = this.record("root");
+		root.spec = {
+			kind: "single",
+			scope: "root"
+		};
+		root.declaredBy = "(built-in)";
+		root.declarationEpoch = 1;
+	}
+	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)`);
+		const spec = rec.spec;
+		const priority = options.priority ?? 0;
+		const occupantHint = (occupant) => `at priority ${priority}${occupant.registrant !== void 0 ? ` (registered by ${occupant.registrant})` : ""} — register at a different priority to shadow it (lowest renders)`;
+		switch (spec.kind) {
+			case "single": {
+				const occupant = rec.entries.find((e) => (e.options.priority ?? 0) === priority);
+				if (occupant) throw new Error(`single slot "${options.name}" already has a registration ${occupantHint(occupant)}`);
+				break;
+			}
+			case "keyed": {
+				if (options.key === void 0) throw new Error(`keyed slot "${options.name}" requires options.key`);
+				const occupant = rec.entries.find((e) => e.options.key === options.key && (e.options.priority ?? 0) === priority);
+				if (occupant) throw new Error(`keyed slot "${options.name}" already has an entry for key "${options.key}" ${occupantHint(occupant)}`);
+				break;
+			}
+			case "list": {
+				if (options.id === void 0) throw new Error(`list slot "${options.name}" requires options.id`);
+				const occupant = rec.entries.find((e) => e.options.id === options.id && (e.options.priority ?? 0) === priority);
+				if (occupant) throw new Error(`list slot "${options.name}" already has an entry with id "${options.id}" ${occupantHint(occupant)}`);
+				break;
+			}
+			case "chain":
+				if (options.select === void 0) throw new Error(`chain slot "${options.name}" requires options.select`);
+				break;
+		}
+		if (options.children) for (const childKey of Object.keys(options.children)) {
+			const childRec = this.records.get(childKey);
+			if (childRec?.spec) throw new Error(`slot "${childKey}" is already declared (by ${childRec.declaredBy ?? "an unknown entry"})`);
+		}
+		if (options.store !== void 0 && typeof options.store !== "function") {
+			const pinned = this.handleScopes.get(options.store);
+			if (pinned && pinned.scope !== spec.scope) throw new Error(`store handle mounted under "${options.name}" (scope "${spec.scope}") is already mounted under scope "${pinned.scope}" — one handle, one scope`);
+			if (pinned) pinned.count += 1;
+			else this.handleScopes.set(options.store, {
+				scope: spec.scope,
+				count: 1
+			});
+		}
+		const entry = {
+			component,
+			options: {
+				...options.key !== void 0 ? { key: options.key } : {},
+				...options.id !== void 0 ? { id: options.id } : {},
+				...options.order !== void 0 ? { order: options.order } : {},
+				...options.label !== void 0 ? { label: options.label } : {},
+				...options.priority !== void 0 ? { priority: options.priority } : {}
+			},
+			...options.select !== void 0 ? { select: options.select } : {},
+			...options.inject !== void 0 ? { inject: options.inject } : {},
+			...options.children !== void 0 ? { children: options.children } : {},
+			...options.store !== void 0 ? { store: options.store } : {},
+			...options.locale !== void 0 ? { locale: options.locale } : {},
+			...options.registrant !== void 0 ? { registrant: options.registrant } : {}
+		};
+		const next = [...rec.entries, entry];
+		next.sort(spec.kind === "list" ? (a, b) => (a.options.priority ?? 0) - (b.options.priority ?? 0) || (a.options.order ?? 0) - (b.options.order ?? 0) : (a, b) => (a.options.priority ?? 0) - (b.options.priority ?? 0));
+		rec.entries = next;
+		this.markDirty(options.name, rec);
+		if (options.children) {
+			const declarations = [];
+			for (const [childKey, childSpec] of Object.entries(options.children)) {
+				const childRec = this.record(childKey);
+				childRec.spec = childSpec;
+				childRec.declaredBy = `an entry in "${options.name}"${options.registrant ? ` (${options.registrant})` : ""}`;
+				childRec.parent = options.name;
+				childRec.declarationEpoch += 1;
+				declarations.push([childKey, childRec]);
+			}
+			for (const [childKey, childRec] of declarations) this.markDirty(childKey, childRec);
+			for (const [, childRec] of declarations) this.notifyDeclaration(childRec);
+		}
+		return () => {
+			if (!rec.entries.includes(entry)) return;
+			rec.entries = rec.entries.filter((e) => e !== entry);
+			this.markDirty(options.name, rec);
+			this.releaseEntry(entry);
+		};
+	}
+	/**
+	* Whether a previously obtained entry is still registered (the render
+	* machinery's stale-authorization probe: a retained renderSlot binding
+	* whose entry left the ledger must not render).
+	* @param entry - a previously read entry.
+	* @returns false once the entry's registration was disposed.
+	*/
+	isLive(entry) {
+		for (const rec of this.records.values()) if (rec.entries.includes(entry)) return true;
+		return false;
+	}
+	/**
+	* Snapshot the registered entries for a key. Returns the cached array
+	* reference (stable between mutations — safe as a uSES getSnapshot source);
+	* empty for keys not (or no longer) declared, so renderers may probe ahead
+	* of plugin load order.
+	* @param key - slot key (dynamic: the render machinery holds keys as strings).
+	* @returns entries in registration (list: order) sequence.
+	*/
+	entries(key) {
+		return this.records.get(key)?.entries ?? NO_ENTRIES;
+	}
+	/**
+	* Project a key's entries to its shadowing winners: the first live
+	* (non-abdicated) entry of each cell in priority order — single: the slot
+	* is one cell; keyed: one cell per `key`; list: one cell per `id` (winners
+	* keep ledger sequence; list renderers still refine display by `order`).
+	* Chain keys return the raw entries unchanged: election consumes every
+	* entry, shadowing does not apply. The raw {@link SlotCore.entries} view
+	* stays the inspection surface. Builds a fresh array per call — a render
+	* body read, not a uSES getSnapshot source.
+	* @param key - slot key (dynamic: the render machinery holds keys as strings).
+	* @returns the winning entry per occupied cell (empty while undeclared).
+	*/
+	entriesOfSlot(key) {
+		const rec = this.records.get(key);
+		if (!rec?.spec) return NO_ENTRIES;
+		const kind = rec.spec.kind;
+		if (kind === "chain") return rec.entries;
+		const heads = [];
+		const seenCells = /* @__PURE__ */ new Set();
+		for (const entry of rec.entries) {
+			if (this.abdicated.has(entry)) continue;
+			const cell = kind === "keyed" ? entry.options.key : kind === "list" ? entry.options.id : void 0;
+			if (seenCells.has(cell)) continue;
+			seenCells.add(cell);
+			heads.push(entry);
+		}
+		return heads;
+	}
+	/**
+	* Look up a slot's declared spec, narrowed by the SlotMap key.
+	* @param key - SlotMap key.
+	* @returns the spec, or undefined while undeclared.
+	*/
+	spec(key) {
+		return this.records.get(key)?.spec;
+	}
+	/**
+	* Dynamic-key escape hatch for spec lookup — renderers resolving keys they
+	* only hold as strings (generic dispatch) use this wide form; statically
+	* keyed callers use {@link SlotCore.spec}.
+	* @param key - candidate slot key.
+	* @returns the wide-typed spec, or undefined while undeclared.
+	*/
+	specDynamic(key) {
+		return this.records.get(key)?.spec;
+	}
+	/**
+	* Export the current declaration topology without components or executable hooks.
+	* @param root - exact Slot 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 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);
+				return node === void 0 ? [] : [node];
+			});
+			return {
+				name,
+				kind: record.spec.kind,
+				scope: record.spec.scope,
+				...record.declaredBy === void 0 ? {} : { declaredBy: record.declaredBy },
+				occupants: record.entries.map((entry) => ({
+					...entry.registrant === void 0 ? {} : { registrant: entry.registrant },
+					...entry.options.key === void 0 ? {} : { key: entry.options.key },
+					...entry.options.id === void 0 ? {} : { id: entry.options.id },
+					...entry.options.order === void 0 ? {} : { order: entry.options.order },
+					priority: entry.options.priority ?? 0,
+					active: active.has(entry)
+				})),
+				children
+			};
+		};
+		if (root !== void 0) {
+			const node = build(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());
+			return node === void 0 ? [] : [node];
+		});
+	}
+	/**
+	* Read the declaration lifetime of a key. Entry additions and removals do
+	* not change it; declaration creation and collapse each advance it.
+	* @param key - slot key.
+	* @returns monotonic epoch (0 before the first declaration).
+	*/
+	declarationEpoch(key) {
+		return this.records.get(key)?.declarationEpoch ?? 0;
+	}
+	/**
+	* Subscribe to registration changes for a key (microtask-batched).
+	* Subscribing ahead of declaration is allowed; the declaration notifies.
+	* @param key - slot key.
+	* @param fn - change callback.
+	* @returns unsubscribe.
+	*/
+	subscribe(key, fn) {
+		const rec = this.record(key);
+		rec.listeners.add(fn);
+		return () => {
+			rec.listeners.delete(fn);
+		};
+	}
+	/**
+	* Subscribe to declaration lifetime boundaries for a key. Notifications
+	* are synchronous so declaration teardown finishes before a subsequent
+	* same-tick registration can observe stale resources. Ordinary entry
+	* mutations do not notify this surface. A children table commits every
+	* sibling declaration before its first notification.
+	* @param key - slot key.
+	* @param fn - declaration or collapse callback.
+	* @returns unsubscribe.
+	*/
+	subscribeDeclaration(key, fn) {
+		const rec = this.record(key);
+		rec.declarationListeners.add(fn);
+		return () => {
+			rec.declarationListeners.delete(fn);
+		};
+	}
+	/**
+	* Monotonic version for a key, bumped synchronously per mutation so a
+	* uSES getSnapshot read is never stale when its batched notification lands.
+	* @param key - slot key.
+	* @returns current version (0 for untouched keys).
+	*/
+	getVersion(key) {
+		return this.records.get(key)?.version ?? 0;
+	}
+	/**
+	* Hook every mutation (the runtime Service wrapper bridges this to ctx.emit).
+	* Fires synchronously per mutation, unbatched — event semantics need one
+	* emission per change.
+	* @param fn - called with the mutated key.
+	* @returns unsubscribe.
+	*/
+	onMutate(fn) {
+		this.mutateListeners.add(fn);
+		return () => {
+			this.mutateListeners.delete(fn);
+		};
+	}
+	/**
+	* Renderer crash report from an entry boundary. Always notifies
+	* {@link SlotCore.onEntryError} listeners; with `info.abdicate` set (the
+	* shadowing kinds — single/keyed/list) it first retires the entry from its
+	* cell, one-shot: the record's version bumps through the ordinary mutation
+	* channel so outlets re-project onto the cell's next survivor, and a
+	* repeat abdicating report no-ops entirely. Chain crashes report with
+	* `abdicate: false` — election alternatives resolve at select time, so the
+	* entry keeps its cell and only the notification fires. The registration
+	* itself stays on the ledger either way — raw {@link SlotCore.entries}
+	* still lists the entry and its disposer keeps working.
+	* @param key - slot key the entry rendered under.
+	* @param entry - the crashed entry.
+	* @param error - the crash cause, forwarded to listeners verbatim.
+	* @param info - `abdicate`: whether the crash retires the entry from its cell.
+	*/
+	reportEntryError(key, entry, error, info) {
+		if (info.abdicate) {
+			if (this.abdicated.has(entry)) return;
+			this.abdicated.add(entry);
+			const rec = this.records.get(key);
+			if (rec !== void 0) this.markDirty(key, rec);
+		}
+		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.
+	* @returns unsubscribe.
+	*/
+	onEntryError(fn) {
+		this.entryErrorListeners.add(fn);
+		return () => {
+			this.entryErrorListeners.delete(fn);
+		};
+	}
+	/**
+	* Cascade for a removed entry: release its store mount and collapse every
+	* child slot it declared — specs clear, contributions empty (their stale
+	* disposers no-op), recursively down the declaration tree. One lifecycle
+	* axis: ledger rows, slots, contributions, and store mounts die together.
+	*/
+	releaseEntry(entry) {
+		if (entry.store !== void 0 && typeof entry.store !== "function") {
+			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)) {
+			const childRec = this.records.get(childKey);
+			/* v8 ignore next -- defensive: declaring always creates the record */
+			if (!childRec) continue;
+			const doomed = childRec.entries;
+			childRec.spec = void 0;
+			childRec.declaredBy = void 0;
+			childRec.parent = void 0;
+			childRec.declarationEpoch += 1;
+			childRec.entries = NO_ENTRIES;
+			this.markDirty(childKey, childRec);
+			this.notifyDeclaration(childRec);
+			for (const dead of doomed) this.releaseEntry(dead);
+		}
+	}
+	record(key) {
+		let rec = this.records.get(key);
+		if (!rec) {
+			rec = {
+				spec: void 0,
+				declaredBy: void 0,
+				parent: void 0,
+				declarationEpoch: 0,
+				entries: NO_ENTRIES,
+				version: 0,
+				listeners: /* @__PURE__ */ new Set(),
+				declarationListeners: /* @__PURE__ */ new Set()
+			};
+			this.records.set(key, rec);
+		}
+		return rec;
+	}
+	markDirty(key, rec) {
+		rec.version += 1;
+		for (const fn of [...this.mutateListeners]) fn(key);
+		this.dirty.add(rec);
+		if (!this.flushScheduled) {
+			this.flushScheduled = true;
+			queueMicrotask(() => {
+				this.flush();
+			});
+		}
+	}
+	notifyDeclaration(rec) {
+		for (const fn of [...rec.declarationListeners]) fn();
+	}
+	flush() {
+		this.flushScheduled = false;
+		const dirty = [...this.dirty];
+		this.dirty.clear();
+		for (const rec of dirty) for (const fn of [...rec.listeners]) fn();
+	}
+};
+//#endregion
+export { SlotCore, SlotOwnershipError, StaleAuthorizationError, resolveSlotLabel, standardHookPropName };
+
+//# sourceMappingURL=index.js.map