refactor(gui): slot system standard — single register, four props shares, framework store seat

The definitive slot model for the web client, replacing the first-generation define/register two-step, ScopedSlots whitelist faces, and binding handles: - 'root' is the only a-priori slot (SlotsService built-in); the shell renders exactly ctx.slots.renderSlot('root', {}). - register is the single API: children = slot declaration + render authorization + runtime spec in one options object; misconfiguration fails loud at load (duplicate declaration, undeclared contribution, one store handle under two scopes). - Component props arrive in four auto-derived shares: PropsRuntime<K> (owner params + session/global standard kits via declare-merge), PropsRenderSlots<S>, PropsStore<H>, and the inject business face. sessionId is framework-supplied; hooks are framework-made only. - Framework store seat: defineStore factories declare schema/actions/persist; read = useStore, write = baked actions only; store scope derives from the mounting entry; per-session persist keys and clearPersisted lifecycle. - inject factories read the apply closure's own ctx (binding handles retired; root-ctx back door closed); SessionProvider is self-wired render-prop. - Rendering sits behind the SlotRenderer install seam; runtime stays React-free; ownership ledger keyed to the single entry axis closes the stale-authority window (StaleAuthorizationError probes). Docs: the slot type-chain note is refreshed in place as the slot system standard RFC (bilingual pair re-recorded); the web client architecture RFC defers its slot sections there; packages/client/AGENTS.md gains the slot and props discipline; gui-testing/web-styling notes drop missions/ references. Tests: suites rewritten to the standard (props fed directly, real store engines via createXXXStore().create(), no render machinery); load-time negative samples for declaration/authorization/store conflicts; verified by real-host playwright run (three columns, empty state, collapse, keyed session remount, cross-slot selection sharing). docs(ui-sidebar): point contract reference at the committed slot standard RFC missions/ is workspace-local and never committed; the README must not cite it.
2026-07-23 01:40:30 +08:00
parent efa4326ff4
commit 1b0ea07bce
95 changed files with 5024 additions and 3322 deletions
--- a/packages/client/runtime/src/client/index.ts
+++ b/packages/client/runtime/src/client/index.ts
@@ -1,21 +1,27 @@
 /**
 * Browser half: the whole runtime contract surface (api-contracts v3 §4) —
- * SlotsService, SessionsService (list store + scope tree + object layer),
- * the ClientLoader interface, and the cordis Context/Events merges. apply
+ * SlotsService (declaration ledger + renderer seam + store axis, built-in
+ * 'root'), SessionsService (list store + current selection + scope tree +
+ * object layer), the ClientLoader interface, and the cordis Context/Events
+ * merges. apply
 * mounts ctx.slots + ctx.sessions and wires the connection stream loop into
 * the object layer. The loader machinery implementation is NOT in the plugin
 * bundle — it ships via the package's `./loader` subpath, statically held by
 * the web shell (a loader cannot load itself).
 */
 import type { Context } from 'cordis'
-import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client'
-import type { SessionBinding as GenericSessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
+import type { ConnectionHandle, SessionId } from '@deepseek-ai/dsh-client-connection/client'
+import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots'
 import type { SnapshotStore, UseSession } from '@deepseek-ai/dsh-client-web-react'
 import { SlotsService } from './slots.ts'
 import { SessionsService } from './sessions/service.ts'
+import type { SessionListState } from './sessions/service.ts'
 import type { ConversationSnapshot, RunningToolCall, ToolResultNode } from './sessions/conversation.ts'

 export { SlotsService } from './slots.ts'
+// RootOwnerProps rides the 'root' SlotMap row (both migrated here from
+// ui-layout: the framework slot is declared by the framework package).
+export type { RootOwnerProps } from './slots.ts'
 export { SessionsService, scopeOf } from './sessions/service.ts'
 export type { Session } from './sessions/session.ts'
 export type { SessionBinding, SessionListState, SessionSummary } from './sessions/service.ts'
@@ -38,9 +44,6 @@ export type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 */
 export type ClientContext = Context

-/** SessionBinding narrowed to the client context (inject factories dot services directly). */
-export type ClientSessionBinding = GenericSessionBinding<ClientContext>
-
 /** The conversation-snapshot selector hook (ConvViewProps/ToolViewProps take this). */
 export type UseConversationSession = UseSession<ConversationSnapshot>

@@ -51,6 +54,25 @@ export type UseConversationSession = UseSession<ConversationSnapshot>
 */
 export type ToolCallBlock = RunningToolCall | ToolResultNode

+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  /**
+   * Session standard kit, real members (ui-slots declares the empty seat;
+   * the runtime — where the subjects live — merges the concrete types):
+   * every session-scope slot component receives these from the framework.
+   */
+  interface SessionStandardProps {
+    /** Selector hook over this session's conversation snapshot. */
+    useSession: SnapshotSelectorHook<ConversationSnapshot>
+    /** The framework-resolved session id (owners never pass it). */
+    sessionId: SessionId
+  }
+  /** Global standard kit, real members: the session-list hook every slot component receives. */
+  interface GlobalStandardProps {
+    /** Selector hook over the session list snapshot (`current` included — the arbitrated selection seat). */
+    useSessions: SnapshotSelectorHook<SessionListState>
+  }
+}
+
 declare module 'cordis' {
  interface Events {
    /**
--- a/packages/client/runtime/src/client/loader/index.ts
+++ b/packages/client/runtime/src/client/loader/index.ts
@@ -17,7 +17,7 @@
 * load one by one in inject topology.
 */
 import type { Context } from 'cordis'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/store'
 import type { BootPluginEntry, ClientLoader, LoaderStatus } from '../index.ts'

 export type { BootPluginEntry, ClientLoader, LoaderStatus } from '../index.ts'
--- a/packages/client/runtime/src/client/sessions/service.ts
+++ b/packages/client/runtime/src/client/sessions/service.ts
@@ -1,7 +1,9 @@
 /**
 * SessionsService: root sessions service — list snapshot store (manager
- * projection), session scope tree (mintScope pattern: no-op plugin Fiber +
- * ctx.extend scope tag), stable SessionBinding cache, ancestry walk.
+ * projection; carries `current`, the persisted selection every
+ * session-scoped surface keys off — migrated here from ui-layout per the
+ * slot-parity design), session scope tree (mintScope pattern: no-op plugin
+ * Fiber + ctx.extend scope tag), stable SessionBinding cache, ancestry walk.
 *
 * Scope lifecycle is watch-driven: a scope is minted lazily on first
 * resolution; a session leaving the list tears its scope down only when
@@ -13,8 +15,11 @@
 */
 import type { Context, Fiber } from 'cordis'
 import type { IApiClient, SessionId } from '@deepseek-ai/dsh-client-connection/client'
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-web-react'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
+// Engine reach-through: the store subpath is the framework-internal channel
+// (the public web-react face carries defineStore only).
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-web-react/store'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/store'
+import type { SessionCell } from '@deepseek-ai/dsh-client-web-react'
 import { SessionManager } from './manager.ts'
 import type { Session } from './session.ts'

@@ -28,8 +33,12 @@ export interface SessionSummary {
  updatedAt: number
 }

-/** Session list store shape. */
-export interface SessionListState { ids: SessionId[]; byId: Record<SessionId, SessionSummary> }
+/**
+ * Session list store shape. `current` rides the same snapshot (arbitrated:
+ * the single useSessions standard hook reads list and selection together —
+ * sidebar highlighting and SessionProvider share one fact source).
+ */
+export interface SessionListState { ids: SessionId[]; byId: Record<SessionId, SessionSummary>; current: SessionId | undefined }

 /** Session assembly handle for SessionProvider/inject factories (identity-stable per session). */
 export interface SessionBinding {
@@ -69,15 +78,26 @@ interface ScopeRecord {
  fiber: Fiber
  ctx: Context
  binding: SessionBinding
+  /** Render-layer standard kit (identity-stable per scope; the renderer's per-cell caches key off it). */
+  cell: SessionCell
 }

-/** Root sessions service: list store, object-layer manager, scope tree, bindings, ancestry. */
+/** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, ancestry. */
 export class SessionsService {
-  /** List snapshot store (list RPC + host stream increments; re-pulled on reconnect). */
+  /** List snapshot store (list RPC + host stream increments; re-pulled on reconnect) — the useSessions standard feed, current included. */
  readonly list: SnapshotStore<SessionListState>
  /** The object-layer instance cluster and frame dispatch entry (wired to the connection by the runtime apply). */
  readonly manager: SessionManager

+  /**
+   * Persisted selection cell (the durable half of `list.current`). Private on
+   * purpose: reads go through the list snapshot; writes through {@link
+   * SessionsService.open}. Projection validates it against the live list
+   * instead of destructively pruning, so a selection survives transient list
+   * states (reconnect re-pull) and resurfaces when its session returns.
+   */
+  private readonly selection: SnapshotStore<{ sessionId?: SessionId }>
+
  private readonly scopes = new Map<SessionId, ScopeRecord>()
  /** Most recently resolved binding id — the watch approximation for deferred teardown. */
  private watched: SessionId | undefined
@@ -90,13 +110,29 @@ export class SessionsService {
   */
  constructor(private readonly rootCtx: Context, api: IApiClient) {
    this.manager = new SessionManager(api)
-    this.list = createSnapshotStore<SessionListState>({ ids: [], byId: {} })
+    this.selection = createSnapshotStore<{ sessionId?: SessionId }>(
+      {},
+      { persist: { name: 'dsh.sessions.current' } })
+    this.list = createSnapshotStore<SessionListState>({ ids: [], byId: {}, current: undefined })
    // The manager owns wire truth; the store is its projection. Manager
    // notifications are already microtask-batched.
    this.manager.subscribe(() => { this.projectList() })
    rootCtx.reflect.provide('sessions', this, undefined)
  }

+  /**
+   * Select a session as current. Unknown ids fail loud instead of navigating
+   * nowhere (the sole selection write path).
+   * @param id - session id (must exist in the list store).
+   */
+  open(id: SessionId): void {
+    if (this.list.getSnapshot().byId[id] === undefined) {
+      throw new Error(`sessions.open: unknown session ${id}`)
+    }
+    this.selection.update((draft) => { draft.sessionId = id })
+    this.list.update((draft) => { draft.current = id })
+  }
+
  /**
   * Create a session on the host.
   * @param opts - creation options (project directory).
@@ -132,6 +168,23 @@ export class SessionsService {
    return record.binding
  }

+  /**
+   * Resolve the render-layer session cell (SessionProvider's feed through
+   * the renderer host; ctx never enters the render layer). Marks the session
+   * watched, same as {@link SessionsService.binding}.
+   * @param id - session id.
+   * @returns cell, or undefined for a session neither listed nor already scoped.
+   */
+  cell(id: string): SessionCell | undefined {
+    const record = this.resolve(id as SessionId)
+    if (record === undefined) return undefined
+    if (this.watched !== id) {
+      this.watched = id as SessionId
+      this.sweepDeferred()
+    }
+    return record.cell
+  }
+
  /**
   * Breadcrumb feed: walk parentId links inside the list store.
   * @param id - session id.
@@ -158,10 +211,12 @@ export class SessionsService {
    if (this.list.getSnapshot().byId[id] === undefined) return undefined
    const fiber = this.rootCtx.plugin(sessionScope)
    const ctx = fiber.ctx.extend({ [kScope]: id })
+    const session = this.manager.get(id)
    const record: ScopeRecord = {
      fiber,
      ctx,
-      binding: { sessionId: id, session: this.manager.get(id), ctx },
+      binding: { sessionId: id, session, ctx },
+      cell: { sessionId: id, useSession: session.useSelector },
    }
    this.scopes.set(id, record)
    return record
@@ -183,7 +238,11 @@ export class SessionsService {
        ...(entry.parentSessionId !== undefined ? { parentId: entry.parentSessionId } : {}),
      }
    }
-    this.list.set({ ids, byId })
+    // current = the persisted selection, masked while its session is absent
+    // (falls to the empty state; resurfaces if the session returns).
+    const selected = this.selection.getSnapshot().sessionId
+    const current = selected !== undefined && byId[selected] !== undefined ? selected : undefined
+    this.list.set({ ids, byId, current })
    this.pruneScopes(byId)
  }

@@ -197,10 +256,18 @@ export class SessionsService {
      }
      this.scopes.delete(id)
      this.deferredRemovals.delete(id)
-      void record.fiber.dispose()
+      this.dropScope(id, record)
    }
  }

+  /** Dispose a scope fiber and its session-keyed slot-store instances together (single lifecycle axis). */
+  private dropScope(id: SessionId, record: ScopeRecord): void {
+    void record.fiber.dispose()
+    // Optional lookup: slots and sessions are sibling services with no
+    // declared dependency; a slots-less boot (object-layer tests) skips.
+    this.rootCtx.get('slots')?.pruneStoreScope(id)
+  }
+
  /** Run deferred teardowns whose session is no longer watched (called when the watch moves). */
  private sweepDeferred(): void {
    for (const id of [...this.deferredRemovals]) {
@@ -220,7 +287,7 @@ export class SessionsService {
       * future teardown path cannot double-dispose. */
      if (record !== undefined) {
        this.scopes.delete(id)
-        void record.fiber.dispose()
+        this.dropScope(id, record)
      }
    }
  }
--- a/packages/client/runtime/src/client/slots.ts
+++ b/packages/client/runtime/src/client/slots.ts
@@ -1,22 +1,113 @@
 /**
- * SlotsService: cordis Service wrapper over the pure SlotCore (ui-slots).
- * Every mutation re-emits as the 'slots/changed' cordis event; define/register
- * run through the caller's ctx.effect so a plugin's registrations are
- * collected when its fiber unloads (cordis-native cascade).
+ * SlotsService: the cordis Service layer of the slot system over the pure
+ * SlotCore (ui-slots owns registration semantics, the declaration ledger,
+ * the load-time validations, and the unload cascade). This layer owns what
+ * needs the runtime: the 'slots/changed' event bridge, register through the
+ * caller's ctx.effect (fiber unload collects registrations), the renderer
+ * install seam (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.
 */
 /* eslint-disable @typescript-eslint/no-redundant-type-constituents --
- * `keyof SlotMap & string` is the declare-merge key pattern: SlotMap is empty
- * in this compilation unit (intersection reads `never`) but consumers merge
- * keys in; the rule fires on the empty-map view, not on real redundancy. */
+ * `keyof SlotMap & string` is the declare-merge key pattern: SlotMap only
+ * holds this package's 'root' row in this compilation unit, but consumers
+ * merge keys in; the rule fires on the narrow-map view, not on real
+ * redundancy. */
 import { Service } from 'cordis'
 import type { Context } from 'cordis'
 import { SlotCore } from '@deepseek-ai/dsh-client-ui-slots'
-import type { ComposedProps, RegisterArgs, SlotComponent, SlotEntry, SlotEntryDef, SlotMap, SlotSpec } from '@deepseek-ai/dsh-client-ui-slots'
-import type { ClientContext } from './index.ts'
+import type {
+  ChildrenDecl, ComposedProps, HandleOf, InjectParams, KindOptions, OwnerOf,
+  SlotComponent, SlotEntryDef, SlotMap, SlotRenderer, SlotRendererHost,
+  SlotScope, SlotSpec, StoreDecl, StoredEntry, StoreInstanceLike,
+} from '@deepseek-ai/dsh-client-ui-slots'

-/** cordis Service wrapper over the pure SlotCore; mutations re-emit as 'slots/changed'. */
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+  interface SlotMap {
+    /** The built-in render-tree root hole (seeded by SlotCore): rendered only by the shell, occupied by a layout entry. */
+    'root': { kind: 'single'; scope: 'root'; owner: RootOwnerProps }
+  }
+}
+
+/** Root owner share: the shell supplies nothing — the frame is inject-assembled. */
+export interface RootOwnerProps { children?: never }
+
+/** Instance key for root-scoped store records (session records key by session id, so the literal cannot collide). */
+const ROOT_INSTANCE_KEY = 'root'
+
+// FIXME(slot-parity): the engine's arbitrated persist extensions — create()
+// takes the scope key (per-session localStorage suffix) and instances expose
+// clearPersisted() — are not yet on ui-slots' StoreHandle/StoreInstanceLike;
+// these local structural faces bridge until fw-slots lifts them.
+
+/** Store handle face as the engine actually ships it (scope-key-aware create). */
+interface EngineStoreHandle { create(scopeKey?: string): EngineStoreInstance }
+
+/** Engine instance face: the host-contract shape plus persisted-state cleanup. */
+interface EngineStoreInstance extends StoreInstanceLike { clearPersisted(): void }
+
+/** Store axis record: one per live handle, dropped when the last holding entry unloads. */
+interface StoreAxisRecord {
+  /** Scope of the slot the handle mounted under (the core validated cross-scope conflicts). */
+  scope: SlotScope
+  /** Live registrations holding the handle. */
+  refs: number
+  /** Root scope: the single instance under {@link ROOT_INSTANCE_KEY}; session scope: one per session id. */
+  instances: Map<string, EngineStoreInstance>
+}
+
+/**
+ * Register options as the service face declares them (structurally the
+ * core's BaseOptions, re-declared because ui-slots keeps it private).
+ * FIXME(slot-parity): dedupe once ui-slots exports its options type.
+ */
+type RegisterOptions<K extends keyof SlotMap & string, D extends ChildrenDecl, H> = {
+  /** Target slot key (the entry contributes INTO this slot). */
+  name: K
+  /** Child-slot declaration + render authorization + runtime spec, in one table. */
+  children?: D
+  /** Store seat: a shared handle (apply-constructed) or an exclusive factory (framework-called per entry). */
+  store?: H
+  /** Registrant identity label for diagnostics (defaults to the caller's fiber name). */
+  registrant?: string
+} & KindOptions<SlotMap[K]>
+
+/**
+ * Compile-time presence check: an entry declaring children MUST consume
+ * `renderSlot` (declaring is claiming). Structural copy of the core's
+ * private RendersCheck; same FIXME as {@link RegisterOptions}.
+ */
+type RendersCheck<C, D> =
+  [keyof D & keyof SlotMap & string] extends [never] ? unknown
+    : C extends (props: infer P) => unknown
+      ? ('renderSlot' extends keyof P ? unknown
+        : { 'children declared but the component consumes no renderSlot': keyof D & keyof SlotMap & string })
+      : unknown
+
+/** Type-erased options view the implementation works with (the typed overloads proved the shares). */
+interface ErasedRegisterOptions {
+  name: string
+  children?: Record<string, SlotSpec<SlotEntryDef>>
+  store?: StoreDecl
+  inject?: (...args: never[]) => Record<string, unknown>
+  key?: string
+  id?: string
+  order?: number
+  label?: string
+  registrant?: string
+}
+
+/** Erased core call face (the service re-erases at its own boundary; the core's typed face targets end callers). */
+interface ErasedCore { register(options: object, component: unknown): () => void }
+
+/** cordis Service layer of the slot system; see the module doc for the split with SlotCore. */
 export class SlotsService extends Service {
  private readonly _core = new SlotCore()
+  /** Store-instance axis: handle -> mounted scope, refcount, resolved instances. */
+  private readonly _stores = new Map<EngineStoreHandle, StoreAxisRecord>()
+  private _renderer: SlotRenderer | undefined
+  private _host: SlotRendererHost | undefined

  /**
   * @param ctx - owning root context.
@@ -27,44 +118,115 @@ export class SlotsService extends Service {
  }

  /**
-   * Record a slot spec (delegates to SlotCore.define; disposal follows the caller's fiber).
-   * @param key - SlotMap key.
-   * @param spec - kind/scope spec.
-   * @returns disposer.
+   * The single registration API (see SlotCore.register for the full
+   * semantics: children declaration, store seat, inject face, load-time
+   * validation, unload cascade). This layer adds: disposal through the
+   * caller's ctx.effect (fiber unload = cascade), exclusive-factory minting
+   * (`store: createXxxStore` becomes a per-entry handle), the registrant
+   * diagnostics stamp, and store-instance lifecycle on the entry axis.
+   * @param options - name + children + store + inject (+ kind-shaped key/id/order/label).
+   * @param component - pure component typed by the four-share composed props.
+   * @returns disposer (idempotent; stale calls after fiber teardown are no-ops).
   */
-  define<K extends keyof SlotMap & string>(key: K, spec: SlotSpec<SlotMap[K]>): () => void {
+  register<
+    K extends keyof SlotMap & string,
+    const D extends ChildrenDecl = Record<never, never>,
+    H extends StoreDecl | undefined = undefined,
+    C extends SlotComponent<never> = SlotComponent<never>,
+  >(
+    options: RegisterOptions<K, D, H> & { inject?: undefined },
+    component: C
+      & SlotComponent<ComposedProps<K, keyof NoInfer<D> & keyof SlotMap & string, HandleOf<NoInfer<H>>, object>>
+      & RendersCheck<C, D>,
+  ): () => void
+  register<
+    K extends keyof SlotMap & string,
+    I extends object,
+    const D extends ChildrenDecl = Record<never, never>,
+    H extends StoreDecl | undefined = undefined,
+    C extends SlotComponent<never> = SlotComponent<never>,
+  >(
+    options: RegisterOptions<K, D, H> & { inject: (...args: InjectParams<K, H>) => I },
+    component: C
+      & SlotComponent<ComposedProps<K, keyof NoInfer<D> & keyof SlotMap & string, HandleOf<NoInfer<H>>, I>>
+      & RendersCheck<C, D>,
+  ): () => void
+  register(rawOptions: object, component: unknown): () => void {
+    // The typed overloads above proved the shares; the implementation works
+    // on the erased view (same pattern as the core's register).
+    const options = rawOptions as ErasedRegisterOptions
    // eslint-disable-next-line @typescript-eslint/no-misused-promises -- synchronous cleanup; direct return preserves disposer identity
-    return this.ctx.effect(() => this._core.define(key, spec), 'slots.define()')
+    return this.ctx.effect(() => this._register(options, component), 'slots.register()')
  }

  /**
-   * Contribute a component (delegates to SlotCore.register; disposal follows the caller's fiber).
-   * @param key - SlotMap key.
-   * @param component - contributed component.
-   * @param args - kind-shaped options (mandatory for keyed/list kinds); the
-   * inject factory's binding is pinned to ClientContext.
-   * @returns disposer.
+   * Install the shell's renderer (web-react's createSlotRenderer product).
+   * Boot-once: a second install throws. Runs through the caller's ctx.effect,
+   * so shell fiber unload uninstalls the renderer.
+   * @param renderer - the outlet machinery implementing SlotRenderer.
   */
-  register<K extends keyof SlotMap & string, I extends object = Record<string, unknown>>(
-    // Client-context registrations have exactly one ctx shape: pin Ctx to
-    // ClientContext so inject factories dot services without a cast.
-    key: K, component: SlotComponent<ComposedProps<K, NoInfer<I>>>,
-    ...args: RegisterArgs<SlotMap[K], I, ClientContext>): () => void {
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises -- synchronous cleanup; direct return preserves disposer identity
-    return this.ctx.effect(() => this._core.register<K, I, ClientContext>(key, component, ...args), 'slots.register()')
+  install(renderer: SlotRenderer): void {
+    if (this._renderer !== undefined) throw new Error('slot renderer already installed (install() is boot-once)')
+    this.ctx.effect(() => {
+      this._renderer = renderer
+      return () => {
+        if (this._renderer === renderer) this._renderer = undefined
+      }
+    }, 'slots.install()')
  }

  /**
-   * Snapshot entries for a key.
-   * @param key - SlotMap key.
-   * @returns registered entries (stable reference between mutations).
+   * The single ctx-level render entry: the shell renders 'root'; every other
+   * key renders inside components through the props renderSlot face. All
+   * three guards are fail-loud boot-order checks, no fallback.
+   * @param key - must be 'root' (runtime-enforced for dynamically composed callers).
+   * @param owner - owner share for the root entry (the shell supplies {}).
+   * @returns the rendered root tree.
   */
-  entries<K extends keyof SlotMap & string>(key: K): readonly SlotEntry<SlotMap[K]>[] {
+  renderSlot<K extends keyof SlotMap & string>(key: K, owner: OwnerOf<K>): ReturnType<SlotRenderer['renderRoot']> {
+    // Widened: in this package's own program SlotMap holds only 'root', which
+    // would fold the guard to constant-false; the check exists for plain-JS
+    // and cross-program callers where K is wider.
+    if ((key as string) !== 'root') {
+      throw new Error(`ctx-level renderSlot only renders 'root' (got "${key}"); child slots render through the component props face`)
+    }
+    if (this._renderer === undefined) {
+      throw new Error("slot renderer not installed — boot must call ctx.slots.install(createSlotRenderer()) before rendering 'root'")
+    }
+    if (this._core.entries('root').length === 0) {
+      throw new Error("'root' has no registration — a layout entry must register into 'root' before the shell renders it")
+    }
+    return this._renderer.renderRoot(this.hostFace(), owner)
+  }
+
+  /**
+   * Drop the per-session store instances of a dead session (the sessions
+   * service calls this on scope teardown; root-scoped records are untouched).
+   * Persisted state goes with the session — a never-rendered dead session can
+   * still own keys from an earlier page load, so the instance is materialized
+   * transiently just to clear storage (no-op for unpersisted stores).
+   * @param sessionId - the torn-down session.
+   */
+  pruneStoreScope(sessionId: string): void {
+    for (const [handle, record] of this._stores) {
+      if (record.scope !== 'session') continue
+      const instance = record.instances.get(sessionId) ?? handle.create(sessionId)
+      instance.clearPersisted()
+      record.instances.delete(sessionId)
+    }
+  }
+
+  /**
+   * Snapshot entries for a key (render-erased view; stable reference between mutations).
+   * @param key - SlotMap key.
+   * @returns registered entries.
+   */
+  entries(key: keyof SlotMap & string): readonly StoredEntry[] {
    return this._core.entries(key)
  }

  /**
-   * Look up a defined spec.
+   * Look up a declared spec (register-declared or the built-in 'root').
   * @param key - SlotMap key.
   * @returns spec or undefined.
   */
@@ -72,15 +234,6 @@ export class SlotsService extends Service {
    return this._core.spec(key)
  }

-  /**
-   * Dynamic-key escape hatch for spec lookup (renderer-side string keys).
-   * @param key - candidate slot key.
-   * @returns wide-typed spec or undefined.
-   */
-  specDynamic(key: string): SlotSpec<SlotEntryDef> | undefined {
-    return this._core.specDynamic(key)
-  }
-
  /**
   * Subscribe to a key's registration changes (microtask-batched).
   * @param key - SlotMap key.
@@ -100,8 +253,106 @@ export class SlotsService extends Service {
    return this._core.getVersion(key)
  }

-  /** The wrapped pure core (web-react's scopedSlots outlet reads through this). */
+  /** The wrapped pure core (invariant checks read through this). */
  get core(): SlotCore {
    return this._core
  }
+
+  /** Delegating registration path: factory minting + registrant stamp + core write + instance-axis bookkeeping. */
+  private _register(options: ErasedRegisterOptions, component: unknown): () => void {
+    // Exclusive stores pass the factory itself: minted here into a per-entry
+    // handle so the stored entry always carries a resolvable handle (the
+    // core's shared-handle scope pinning applies to it harmlessly).
+    const store = typeof options.store === 'function' ? options.store() : options.store
+    const registrant = options.registrant ?? (this.ctx.fiber as { name?: string } | undefined)?.name
+    const erased: ErasedRegisterOptions = {
+      ...options,
+      ...(store !== undefined ? { store } : {}),
+      ...(registrant !== undefined ? { registrant } : {}),
+    }
+    // Core write first: all load-time validation (undeclared target,
+    // duplicate declaration, kind conflicts, cross-scope handle) throws
+    // there before this layer commits anything.
+    const dispose = (this._core as unknown as ErasedCore).register(erased, component)
+    if (store !== undefined) {
+      // Register succeeded, so the target's spec is on the ledger.
+      const scope = (this._core.specDynamic(options.name) as SlotSpec<never>).scope
+      this._acquire(store, scope)
+    }
+    let disposed = false
+    return () => {
+      if (disposed) return
+      disposed = true
+      dispose()
+      if (store !== undefined) this._release(store)
+    }
+  }
+
+  /** Build (once) the host face the installed renderer reads; sessions resolve lazily at first render. */
+  private hostFace(): SlotRendererHost {
+    if (this._host !== undefined) return this._host
+    const sessions = this.ctx.get('sessions')
+    if (sessions === undefined) {
+      throw new Error("renderSlot('root') before the sessions service mounted — boot order puts runtime apply first")
+    }
+    // Identity-stable view: current rides the list snapshot (arbitrated), but
+    // the provider consumes it as its own observable; one cached object keeps
+    // the renderer's per-source hook cache stable.
+    const current = {
+      getSnapshot: () => sessions.list.getSnapshot().current as string | undefined,
+      subscribe: (fn: () => void) => sessions.list.subscribe(fn),
+    }
+    this._host = {
+      subscribe: (key, fn) => this._core.subscribe(key, fn),
+      getVersion: key => this._core.getVersion(key),
+      entriesOf: key => this._core.entries(key),
+      specOf: key => this._core.specDynamic(key),
+      isLive: entry => this._core.isLive(entry),
+      storeOf: (entry, scopeKey) =>
+        entry.store === undefined ? undefined : this.resolveStore(entry.store as unknown as EngineStoreHandle, scopeKey),
+      sessions: {
+        list: sessions.list,
+        current,
+        cell: id => sessions.cell(id),
+      },
+    }
+    return this._host
+  }
+
+  /** Resolve (create or reuse) the store instance for a registered handle under a scope key. */
+  private resolveStore(handle: EngineStoreHandle, sessionId: string | undefined): StoreInstanceLike {
+    const record = this._stores.get(handle)
+    if (record === undefined) throw new Error('store handle is not registered (entry unloaded, or the handle never went through register)')
+    const key = record.scope === 'session' ? sessionId : ROOT_INSTANCE_KEY
+    if (key === undefined) throw new Error('session-scoped store resolution requires a session id')
+    let instance = record.instances.get(key)
+    if (instance === undefined) {
+      // Session instances get the scope key (the engine suffixes the persist
+      // key per session); root instances stay keyless.
+      instance = record.scope === 'session' ? handle.create(key) : handle.create()
+      record.instances.set(key, instance)
+    }
+    return instance
+  }
+
+  /** Bind (or re-reference) a handle on the axis; cross-scope conflicts already threw in the core. */
+  private _acquire(handle: EngineStoreHandle, scope: SlotScope): void {
+    const record = this._stores.get(handle)
+    if (record === undefined) {
+      this._stores.set(handle, { scope, refs: 1, instances: new Map() })
+      return
+    }
+    record.refs += 1
+  }
+
+  /** Drop one reference; the last holder's unload drops the record (instances go with it — engine stores need no explicit dispose). */
+  private _release(handle: EngineStoreHandle): void {
+    const record = this._stores.get(handle)
+    /* v8 ignore next -- defensive: release only runs from a disposer whose
+     * register acquired the same handle, so the record must exist; kept so a
+     * future call site cannot underflow the axis. */
+    if (record === undefined) return
+    record.refs -= 1
+    if (record.refs === 0) this._stores.delete(handle)
+  }
 }
--- a/packages/client/runtime/tests/client-apply.spec.ts
+++ b/packages/client/runtime/tests/client-apply.spec.ts
@@ -37,6 +37,9 @@ describe('runtime client apply', () => {
  it('mounts ctx.slots + ctx.sessions and wires the stream sinks into the manager', async () => {
    const bench = await mount()
    expect(bench.ctx.get('slots') !== undefined).toBe(true)
+    // The built-in 'root' declaration ships with this package's SlotsService
+    // (the SlotMap 'root' merge lives here since the slot-parity rework).
+    expect(bench.ctx.slots.spec('root')).toEqual({ kind: 'single', scope: 'root' })
    const sessions = bench.ctx.get('sessions')
    expect(sessions !== undefined).toBe(true)
    expect(bench.sinks).toBeDefined()
--- a/packages/client/runtime/tests/invariant.spec.ts
+++ b/packages/client/runtime/tests/invariant.spec.ts
@@ -25,9 +25,11 @@ describe('runtime slots/changed invariant', () => {
    const ctx = await setup()
    expect(() => { emit(ctx, 'unrelated/event', 'x') }).not.toThrow()
    await ctx.plugin(SlotsService).await() // fiber must reach ACTIVE — the audit reads strict ctx.get
-    // A real define bumps the version first and re-emits through onMutate —
-    // the audit sees version > 0 and stays quiet.
-    expect(() => ctx.slots.define('t-single', { kind: 'single', scope: 'root' })).not.toThrow()
+    // A real registration bumps the version first and re-emits through
+    // onMutate — the audit sees version > 0 and stays quiet. (Erased call:
+    // the typed register face rides the wave-1 ui-slots types.)
+    const slots = ctx.slots as unknown as { register(options: object, component: unknown): () => void }
+    expect(() => slots.register({ name: 'root' }, () => null)).not.toThrow()
  })

  it('fails loud on a missing key and on an emission with no applied mutation', async () => {
--- a/packages/client/runtime/tests/sessions-service.spec.ts
+++ b/packages/client/runtime/tests/sessions-service.spec.ts
@@ -1,10 +1,12 @@
 /**
- * SessionsService: list store projection (manager → {ids, byId} with derived
- * titles), scope-tree lifecycle (lazy mint / frozen survival / removed
- * teardown with watch deferral), binding identity, ancestry walk, create.
+ * SessionsService: list store projection (manager → {ids, byId, current}
+ * with derived titles), the migrated current-selection account (open
+ * validation, persisted mask semantics, cell resolution), scope-tree
+ * lifecycle (lazy mint / frozen survival / removed teardown with watch
+ * deferral), binding identity, ancestry walk, create.
 */
 import { Context } from 'cordis'
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 import { SessionsService, scopeOf } from '../src/client/sessions/service.ts'
 import { FakeApiClient, ok } from './fake-api.ts'
@@ -112,6 +114,95 @@ describe('scope tree', () => {
  })
 })

+describe('current selection (migrated from ui-layout, arbitrated into the list snapshot)', () => {
+  afterEach(() => { vi.unstubAllGlobals() })
+
+  it('open() writes list.current; unknown ids fail loud', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    expect(b.svc.list.getSnapshot().current).toBeUndefined()
+    b.svc.open(sid('s1'))
+    expect(b.svc.list.getSnapshot().current).toBe('s1')
+    expect(() => { b.svc.open(sid('ghost')) }).toThrow(/unknown session ghost/)
+    expect(b.svc.list.getSnapshot().current).toBe('s1') // failed open leaves the selection alone
+  })
+
+  it('masks (not destroys) the selection while its session is off the list', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }, { id: 's2' }])
+    b.svc.open(sid('s1'))
+    await feedList(b, [{ id: 's2' }]) // s1 removed → current falls to the empty state
+    expect(b.svc.list.getSnapshot().current).toBeUndefined()
+    await feedList(b, [{ id: 's1' }, { id: 's2' }]) // s1 returns → selection resurfaces
+    expect(b.svc.list.getSnapshot().current).toBe('s1')
+  })
+
+  it('persists the selection under dsh.sessions.current and rehydrates it into a fresh service', async () => {
+    const storage = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (k: string) => storage.get(k) ?? null,
+      setItem: (k: string, v: string) => { storage.set(k, v) },
+    })
+    const first = bench()
+    await feedList(first, [{ id: 's1' }])
+    first.svc.open(sid('s1'))
+    expect(storage.get('dsh.sessions.current')).toContain('s1')
+    // A fresh boot (same storage) recovers the selection once the list holds the session.
+    const second = bench()
+    await feedList(second, [{ id: 's1' }])
+    expect(second.svc.list.getSnapshot().current).toBe('s1')
+  })
+})
+
+describe('cell (render-layer session kit)', () => {
+  it('resolves an identity-stable {sessionId, useSession} pair; unknown ids yield undefined', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    const cell = b.svc.cell('s1')
+    expect(cell).toBeDefined()
+    expect(cell?.sessionId).toBe('s1')
+    expect(cell?.useSession).toBe(b.svc.manager.get(sid('s1')).useSelector)
+    expect(b.svc.cell('s1')).toBe(cell)
+    expect(b.svc.cell('ghost')).toBeUndefined()
+  })
+
+  it('moves the watch like binding(): switching cells sweeps a deferred removal', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    b.svc.cell('s1') // watched
+    await feedList(b, []) // removed while watched → deferred, scope survives
+    expect(b.svc.scope(sid('s1'))).toBeDefined()
+    await feedList(b, [{ id: 's2' }])
+    b.svc.cell('s2') // watch moves → sweep tears s1 down
+    expect(b.svc.scope(sid('s1'))).toBeUndefined()
+  })
+})
+
+describe('slot-store scope prune hook', () => {
+  it('notifies ctx.slots.pruneStoreScope when a scope dies (both teardown paths)', async () => {
+    const b = bench()
+    const pruneStoreScope = vi.fn()
+    b.ctx.reflect.provide('slots', { pruneStoreScope })
+    await feedList(b, [{ id: 's1' }, { id: 's2' }])
+    b.svc.scope(sid('s1'))
+    b.svc.binding(sid('s2')) // s2 watched
+    await feedList(b, []) // s1 unwatched → immediate drop; s2 watched → deferred
+    expect(pruneStoreScope).toHaveBeenCalledWith('s1')
+    expect(pruneStoreScope).not.toHaveBeenCalledWith('s2')
+    await feedList(b, [{ id: 's3' }])
+    b.svc.binding(sid('s3')) // watch moves → deferred sweep drops s2
+    expect(pruneStoreScope).toHaveBeenCalledWith('s2')
+  })
+
+  it('tolerates a slots-less boot (object-layer benches carry no slot service)', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    b.svc.scope(sid('s1'))
+    await feedList(b, []) // teardown without ctx.slots must not throw
+    expect(b.svc.scope(sid('s1'))).toBeUndefined()
+  })
+})
+
 describe('ancestry', () => {
  it('walks parentId links root-first including self; broken links stop the walk', async () => {
    const b = bench()
--- a/packages/client/runtime/tests/slots-service.spec.ts
+++ b/packages/client/runtime/tests/slots-service.spec.ts
@@ -1,80 +1,379 @@
 /**
- * SlotsService: cordis Service wrapper semantics — core delegation, the
- * 'slots/changed' event bridge, and fiber-scoped registration disposal.
+ * SlotsService terminal-design account (design.md §11-3 main landing):
+ * built-in 'root', the three load-time throws (duplicate declaration /
+ * undeclared contribution / cross-scope store handle), the renderer install
+ * seam (double install / not installed / non-root key), store instance
+ * resolution and lifecycle on the ledger axis, and the entry-unload cascade.
 */
 import { Context } from 'cordis'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import type { FC } from 'react'
+import type { SlotRendererHost } from '@deepseek-ai/dsh-client-ui-slots'
 import { SlotsService } from '../src/client/slots.ts'

-// Test-only slot keys (SlotMap is empty in this package; the service is generic over it).
+// Test-only slot keys (merged so the typed entries/spec faces accept them).
 declare module '@deepseek-ai/dsh-client-ui-slots' {
  interface SlotMap {
-    't-single': { kind: 'single'; scope: 'root'; props: object }
-    't-list': { kind: 'list'; scope: 'root'; props: object }
+    't.host': { kind: 'single'; scope: 'root' }
+    't.panel': { kind: 'single'; scope: 'session' }
+    't.rows': { kind: 'list'; scope: 'root' }
  }
 }

 const C: FC<object> = () => null

-async function boot(): Promise<Context> {
+/**
+ * Register/install/renderSlot through a type-erased view: the typed register
+ * face rides wave-1 ui-slots types (red until that wave lands); the runtime
+ * semantics under test are final.
+ */
+interface ErasedService {
+  register(options: object, component: unknown): () => void
+  install(renderer: object): void
+  renderSlot(key: string, owner: object): unknown
+}
+
+interface Bench {
+  ctx: Context
+  svc: SlotsService
+  erased: ErasedService
+}
+
+async function boot(): Promise<Bench> {
  const ctx = new Context()
  ctx.plugin(SlotsService)
  await ctx.fiber.await()
-  return ctx
+  // Service accessor (ctx.get reads the reflect store, which Service-class
+  // plugins do not write; the accessor is the product path).
+  const svc = ctx.slots
+  return { ctx, svc, erased: svc as unknown as ErasedService }
 }

-describe('SlotsService', () => {
-  it('proxies define/register/entries/spec/getVersion to the core', async () => {
-    const ctx = await boot()
-    ctx.slots.define('t-single', { kind: 'single', scope: 'root' })
-    expect(ctx.slots.spec('t-single')).toEqual({ kind: 'single', scope: 'root' })
-    const v0 = ctx.slots.getVersion('t-single')
-    ctx.slots.register('t-single', C)
-    expect(ctx.slots.entries('t-single')).toHaveLength(1)
-    expect(ctx.slots.getVersion('t-single')).toBeGreaterThan(v0)
-    expect(ctx.slots.core.spec('t-single')).toBeDefined()
+/** Engine-shaped instance stub (the arbitrated persist face: scope-keyed create + clearPersisted). */
+interface FakeInstance {
+  useSelector: () => undefined
+  actions: Record<string, never>
+  clearPersisted: ReturnType<typeof vi.fn>
+}
+
+/** Fake store handle factory (create-count and clearPersisted observable). */
+function fakeHandle() {
+  const created: FakeInstance[] = []
+  const handle = {
+    create: vi.fn((_scopeKey?: string): FakeInstance => {
+      const instance: FakeInstance = { useSelector: () => undefined, actions: {}, clearPersisted: vi.fn() }
+      created.push(instance)
+      return instance
+    }),
+  }
+  return { handle, created }
+}
+
+/**
+ * Install a capturing renderer, occupy 'root' (declaring `children` in the
+ * same call — 'root' is single, so the one occupant is also the declarer),
+ * and pull the host face out through renderSlot('root').
+ */
+function captureHost(bench: Bench, children?: object): SlotRendererHost {
+  let host: SlotRendererHost | undefined
+  bench.erased.install({
+    renderRoot: (h: SlotRendererHost) => { host = h; return 'rendered' },
+  })
+  bench.erased.register({ name: 'root', ...(children !== undefined ? { children } : {}) }, C)
+  bench.ctx.reflect.provide('sessions', fakeSessions())
+  bench.erased.renderSlot('root', {})
+  if (host === undefined) throw new Error('renderer never received the host')
+  return host
+}
+
+/** Minimal sessions face for the host seam (list observable + cell). */
+function fakeSessions() {
+  const state = { ids: [], byId: {}, current: undefined as string | undefined }
+  return {
+    list: { getSnapshot: () => state, subscribe: () => () => undefined },
+    cell: (id: string) => (id === 'known' ? { sessionId: id, useSession: () => undefined } : undefined),
+  }
+}
+
+describe("built-in 'root'", () => {
+  it('is declared at construction: spec readable, occupancy open, no plugin needed', async () => {
+    const bench = await boot()
+    expect(bench.svc.spec('root')).toEqual({ kind: 'single', scope: 'root' })
+    expect(() => bench.erased.register({ name: 'root' }, C)).not.toThrow()
+    expect(bench.svc.entries('root')).toHaveLength(1)
  })

-  it("re-emits every mutation as 'slots/changed' with the key", async () => {
-    const ctx = await boot()
-    const seen: string[] = []
-    ctx.on('slots/changed', (key) => { seen.push(key) })
-    ctx.slots.define('t-list', { kind: 'list', scope: 'root' })
-    ctx.slots.register('t-list', C, { id: 'a' })
-    expect(seen).toEqual(['t-list', 't-list'])
+  it('rejects a second declaration of root, attributing the built-in row', async () => {
+    const bench = await boot()
+    expect(() => bench.erased.register({
+      name: 'root', children: { 'root': { kind: 'single', scope: 'root' } },
+    }, C)).toThrow(/already declared.*built-in/)
+  })
+})
+
+describe('load-time validation', () => {
+  it('throws on contributing into an undeclared slot', async () => {
+    const bench = await boot()
+    expect(() => bench.erased.register({ name: 't.host' }, C)).toThrow(/slot "t.host" is not declared/)
  })

-  it('collects a plugin fiber\'s registrations when the fiber unloads (cascade)', async () => {
-    const ctx = await boot()
-    ctx.slots.define('t-single', { kind: 'single', scope: 'root' })
-    const fiber = ctx.plugin({
+  it('throws on a duplicate declaration, naming the slot and the prior declarant', async () => {
+    const bench = await boot()
+    bench.erased.register({ name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } } }, C)
+    bench.erased.register({
+      name: 't.host', children: { 't.rows': { kind: 'list', scope: 'root' } },
+    }, C)
+    expect(() => bench.erased.register({
+      name: 't.rows', id: 'r1', children: { 't.rows': { kind: 'list', scope: 'root' } },
+    }, C)).toThrow(/slot "t.rows" is already declared.*"t.host"/)
+  })
+
+  it('throws when one store handle is bound to two scopes', async () => {
+    const bench = await boot()
+    bench.erased.register({
+      name: 'root',
+      children: {
+        't.host': { kind: 'single', scope: 'root' },
+        't.panel': { kind: 'single', scope: 'session' },
+      },
+    }, C)
+    const { handle } = fakeHandle()
+    bench.erased.register({ name: 't.host', store: handle }, C)
+    expect(() => bench.erased.register({ name: 't.panel', store: handle }, C))
+      .toThrow(/one handle, one scope/)
+  })
+
+  it('commits nothing when the core rejects the entry (children stay undeclared)', async () => {
+    const bench = await boot()
+    bench.erased.register({ name: 'root' }, C) // 'root' single slot now occupied
+    expect(() => bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)).toThrow(/already has a registration/)
+    // The failing call's declaration must not have landed.
+    expect(() => bench.erased.register({ name: 't.host' }, C)).toThrow(/is not declared/)
+  })
+})
+
+describe('renderer install seam', () => {
+  it('throws on renderSlot before install (boot-order guidance)', async () => {
+    const bench = await boot()
+    expect(() => bench.erased.renderSlot('root', {})).toThrow(/renderer not installed/)
+  })
+
+  it('throws on double install', async () => {
+    const bench = await boot()
+    bench.erased.install({ renderRoot: () => null })
+    expect(() => { bench.erased.install({ renderRoot: () => null }) }).toThrow(/already installed/)
+  })
+
+  it('throws on any non-root key (single ctx-level entry)', async () => {
+    const bench = await boot()
+    bench.erased.install({ renderRoot: () => null })
+    expect(() => bench.erased.renderSlot('t.host', {})).toThrow(/only renders 'root'/)
+  })
+
+  it("throws on renderSlot('root') before any root registration", async () => {
+    const bench = await boot()
+    bench.erased.install({ renderRoot: () => null })
+    expect(() => bench.erased.renderSlot('root', {})).toThrow(/no registration/)
+  })
+
+  it('renders through the installed renderer and returns its product', async () => {
+    const bench = await boot()
+    const renderRoot = vi.fn(() => 'tree')
+    bench.erased.install({ renderRoot })
+    bench.erased.register({ name: 'root' }, C)
+    bench.ctx.reflect.provide('sessions', fakeSessions())
+    expect(bench.erased.renderSlot('root', {})).toBe('tree')
+    expect(renderRoot).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('host face', () => {
+  it('serves entriesOf/specOf/isLive off the ledger and flips isLive on disposal', async () => {
+    const bench = await boot()
+    const host = captureHost(bench, { 't.host': { kind: 'single', scope: 'root' } })
+    const dispose = bench.erased.register({ name: 't.host' }, C)
+    const rootEntry = host.entriesOf('root')[0]
+    expect(rootEntry).toBeDefined()
+    expect(rootEntry?.component).toBe(C)
+    expect(host.specOf('root')).toEqual({ kind: 'single', scope: 'root' })
+    expect(host.specOf('t.host')).toEqual({ kind: 'single', scope: 'root' })
+    const childEntry = host.entriesOf('t.host')[0]
+    expect(host.isLive(childEntry as never)).toBe(true)
+    dispose()
+    expect(host.isLive(childEntry as never)).toBe(false)
+    expect(host.entriesOf('t.host')).toHaveLength(0)
+  })
+
+  it('exposes sessions list/current/cell (current riding the list snapshot)', async () => {
+    const bench = await boot()
+    const host = captureHost(bench)
+    expect(host.sessions.list.getSnapshot()).toMatchObject({ ids: [] })
+    expect(host.sessions.current.getSnapshot()).toBeUndefined()
+    expect(host.sessions.cell('known')).toMatchObject({ sessionId: 'known' })
+    expect(host.sessions.cell('ghost')).toBeUndefined()
+  })
+})
+
+describe('store instance axis', () => {
+  /** Boot with 'root' occupied and the three test children declared. */
+  async function storeBench() {
+    const bench = await boot()
+    const host = captureHost(bench, {
+      't.host': { kind: 'single', scope: 'root' },
+      't.rows': { kind: 'list', scope: 'root' },
+      't.panel': { kind: 'single', scope: 'session' },
+    })
+    return { bench, host }
+  }
+
+  it('resolves one instance per (handle x root scope) shared across entries', async () => {
+    const { bench, host } = await storeBench()
+    const { handle } = fakeHandle()
+    bench.erased.register({ name: 't.host', store: handle }, C)
+    bench.erased.register({ name: 't.rows', id: 'a', store: handle }, C)
+    const [hostEntry] = host.entriesOf('t.host')
+    const [rowEntry] = host.entriesOf('t.rows')
+    const a = host.storeOf(hostEntry as never, undefined)
+    const b = host.storeOf(rowEntry as never, undefined)
+    expect(a).toBeDefined()
+    expect(a).toBe(b) // shared handle, same scope key = same instance
+    expect(handle.create).toHaveBeenCalledTimes(1)
+    expect(handle.create).toHaveBeenCalledWith() // root scope: keyless create
+  })
+
+  it('resolves per-session instances keyed by session id, created with the scope key', async () => {
+    const { bench, host } = await storeBench()
+    const { handle } = fakeHandle()
+    bench.erased.register({ name: 't.panel', store: handle }, C)
+    const [entry] = host.entriesOf('t.panel')
+    const s1 = host.storeOf(entry as never, 's1')
+    const s2 = host.storeOf(entry as never, 's2')
+    expect(s1).not.toBe(s2)
+    expect(host.storeOf(entry as never, 's1')).toBe(s1) // cached per key
+    expect(handle.create).toHaveBeenCalledWith('s1')
+    expect(handle.create).toHaveBeenCalledWith('s2')
+    expect(() => host.storeOf(entry as never, undefined)).toThrow(/requires a session id/)
+  })
+
+  it('mints a fresh handle per register for the factory (exclusive) form', async () => {
+    const { bench, host } = await storeBench()
+    const factory = vi.fn(() => fakeHandle().handle)
+    bench.erased.register({ name: 't.host', store: factory }, C)
+    bench.erased.register({ name: 't.rows', id: 'a', store: factory }, C)
+    expect(factory).toHaveBeenCalledTimes(2)
+    const a = host.storeOf(host.entriesOf('t.host')[0] as never, undefined)
+    const b = host.storeOf(host.entriesOf('t.rows')[0] as never, undefined)
+    expect(a).not.toBe(b) // two mints, two instances
+  })
+
+  it('drops instances with the last holding entry and refuses stale resolution', async () => {
+    const { bench, host } = await storeBench()
+    const { handle } = fakeHandle()
+    const d1 = bench.erased.register({ name: 't.host', store: handle }, C)
+    bench.erased.register({ name: 't.rows', id: 'a', store: handle }, C)
+    const rowEntry = host.entriesOf('t.rows')[0]
+    const hostEntry = host.entriesOf('t.host')[0]
+    const shared = host.storeOf(rowEntry as never, undefined)
+    d1() // one holder left: record (and instance) survive
+    expect(host.storeOf(rowEntry as never, undefined)).toBe(shared)
+    expect(() => host.storeOf(hostEntry as never, undefined)).not.toThrow() // handle still live via the row entry
+    // Note: dropping the row entry would sever the last reference; stale
+    // resolution is covered through the cascade spec below.
+  })
+
+  it('pruneStoreScope clears persisted state per dead session, including never-materialized ones', async () => {
+    const { bench, host } = await storeBench()
+    const { handle, created } = fakeHandle()
+    bench.erased.register({ name: 't.panel', store: handle }, C)
+    const [entry] = host.entriesOf('t.panel')
+    const s1 = host.storeOf(entry as never, 's1')
+    expect(s1).toBe(created[0]) // the resolved instance is the fake the handle minted
+    bench.svc.pruneStoreScope('s1')
+    expect(created[0]?.clearPersisted).toHaveBeenCalledTimes(1)
+    expect(host.storeOf(entry as never, 's1')).not.toBe(s1) // instance dropped, next resolve mints anew
+    // Never-rendered dead session: a transient instance is created just to clear storage.
+    const before = created.length
+    bench.svc.pruneStoreScope('s-never')
+    expect(created.length).toBe(before + 1)
+    expect(created[created.length - 1]?.clearPersisted).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('entry-unload cascade', () => {
+  it('kills declared children, their contributions, and the ledger rows with the entry', async () => {
+    const bench = await boot()
+    let host: SlotRendererHost | undefined
+    bench.erased.install({
+      renderRoot: (h: SlotRendererHost) => { host = h; return 'rendered' },
+    })
+    bench.ctx.reflect.provide('sessions', fakeSessions())
+    // The declarer here is NOT the root occupant: root stays occupied by a
+    // separate entry so disposing the declarer only kills its children.
+    const disposeRoot = bench.erased.register({ name: 'root' }, C)
+    bench.erased.renderSlot('root', {})
+    if (host === undefined) throw new Error('renderer never received the host')
+    disposeRoot()
+    const disposeDeclarer = bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)
+    bench.erased.register({ name: 't.host' }, C)
+    const [childEntry] = host.entriesOf('t.host')
+    expect(childEntry).toBeDefined()
+
+    disposeDeclarer()
+    expect(bench.svc.spec('t.host')).toBeUndefined() // ledger row gone
+    expect(host.specOf('t.host')).toBeUndefined() // outlets now render empty
+    expect(bench.svc.entries('t.host')).toHaveLength(0) // contribution cleared
+    expect(host.isLive(childEntry as never)).toBe(false) // stale bindings will throw upstream
+    // The freed key is re-declarable by a new entry (no residue).
+    expect(() => bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)).not.toThrow()
+  })
+
+  it('cascades through cordis fiber disposal (plugin unload = full cleanup)', async () => {
+    const bench = await boot()
+    bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)
+    const fiber = bench.ctx.plugin({
      name: 'occupant',
      inject: ['slots'],
      apply: (pluginCtx: Context) => {
-        pluginCtx.slots.register('t-single', C)
+        ;(pluginCtx.slots as unknown as ErasedService).register({ name: 't.host' }, C)
      },
    })
    await fiber.await()
-    expect(ctx.slots.entries('t-single')).toHaveLength(1)
+    expect(bench.svc.entries('t.host')).toHaveLength(1)
    await fiber.dispose()
-    expect(ctx.slots.entries('t-single')).toHaveLength(0)
-    // The slot definition (registered from root) survives; a new occupant may register.
-    expect(() => ctx.slots.register('t-single', C)).not.toThrow()
+    expect(bench.svc.entries('t.host')).toHaveLength(0)
+    expect(bench.svc.spec('t.host')).toBeDefined() // declarer still live; slot stays declared
  })

-  it('proxies specDynamic/subscribe/getVersion through the core', async () => {
-    const ctx = await boot()
-    ctx.slots.define('t-list', { kind: 'list', scope: 'root' })
-    expect(ctx.slots.specDynamic('t-list')).toEqual({ kind: 'list', scope: 'root' })
-    expect(ctx.slots.specDynamic('never-defined')).toBeUndefined()
-    let notified = 0
-    const unsubscribe = ctx.slots.subscribe('t-list', () => { notified += 1 })
-    ctx.slots.register('t-list', C, { id: 'row' })
-    await new Promise(resolve => setTimeout(resolve, 0)) // microtask-batched flush
-    expect(notified).toBeGreaterThan(0)
-    expect(ctx.slots.getVersion('t-list')).toBeGreaterThan(0)
-    unsubscribe()
+  it('disposer is idempotent (stale second call is a no-op)', async () => {
+    const bench = await boot()
+    const dispose = bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)
+    dispose()
+    expect(() => { dispose() }).not.toThrow()
+    expect(() => bench.erased.register({
+      name: 'root', children: { 't.host': { kind: 'single', scope: 'root' } },
+    }, C)).not.toThrow()
+  })
+})
+
+describe('event bridge', () => {
+  it("re-emits entry writes and child declarations as 'slots/changed'", async () => {
+    const bench = await boot()
+    const seen: string[] = []
+    bench.ctx.on('slots/changed', (key) => { seen.push(key) })
+    bench.erased.register({
+      name: 'root', children: { 't.rows': { kind: 'list', scope: 'root' } },
+    }, C)
+    bench.erased.register({ name: 't.rows', id: 'a' }, C)
+    expect(seen).toEqual(['root', 't.rows', 't.rows'])
  })
-
 })