@deepseek-ai/dsh-client-test-runtime 0.1.1-rc.2 → 0.1.2-alpha.3

package/lib/types/fixtures.d.ts

@@ -1,5 +1,9 @@
-/** Session/workspace fixture shapes and snapshot defaults for the test runtime. */
-import type { ConversationSnapshot, ISession, SessionId, SessionSummary, WorkspaceListState } from '@deepseek-ai/dsh-client-runtime/client';
+/** Controller and UI-domain fixture shapes for the client test runtime. */
+import type { ISession, SessionEventLikeEntry, SessionSnapshot, SessionSummary } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { WorkspaceSnapshot } from '@deepseek-ai/dsh-api-workspace-controller/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import { type ConversationSnapshot } from '@deepseek-ai/dsh-client-ui-conversation/client';
+import { type ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
 /**
  * Fixture overrides for the session behavior face: any subset of the
  * production ISession verbs (typed against it, so a face change surfaces
@@ -16,6 +20,12 @@ export type SessionBehaviorOverrides = Partial<ISession> & Record<string, unknow
  * React act themselves.
  */
 export type Stabilizer = (fn: () => void | Promise<void>) => Promise<void>;
+/** Mutable top-level snapshot fields accepted by fixture update callbacks. */
+export type FixtureSnapshot<T> = {
+    -readonly [Key in keyof T]: T[Key];
+};
+/** Writable test representation of the immutable Session Controller snapshot. */
+export type SessionFixtureSnapshot = FixtureSnapshot<SessionSnapshot>;
 /**
  * Session fixture accepted by {@link TestSessions.add}: identity plus optional
  * snapshot/list-row overrides and the session behavior face the feature under
@@ -24,23 +34,38 @@ export type Stabilizer = (fn: () => void | Promise<void>) => Promise<void>;
  */
 export interface SessionFixture {
     id: string;
-    /** Overrides merged over {@link conversationSnapshot} (sessionId comes from `id`). */
-    snapshot?: Partial<Omit<ConversationSnapshot, 'sessionId'>>;
+    /** Overrides merged over {@link sessionSnapshot}; Conversation data arrives through the event feed. */
+    snapshot?: Partial<Omit<SessionSnapshot, 'sessionId'>>;
     /** List-row overrides merged over the defaults derived from `id`. */
     summary?: Partial<Omit<SessionSummary, 'id'>>;
     /** Session behavior face: exactly the methods the feature under test calls (ISession subset + extras). */
     session?: SessionBehaviorOverrides;
+    /** Initial contiguous event window consumed by Conversation assembly. */
+    events?: readonly SessionEventLikeEntry[];
+    /** Whether the initial event window has an older page. */
+    hasMore?: boolean;
 }
 /**
- * A complete quiescent conversation snapshot (open window, no traffic).
+ * A complete quiescent Session Controller snapshot.
  * @param sessionId - owning session id.
  * @returns the snapshot; spread fixture overrides on top.
  */
-export declare function conversationSnapshot(sessionId: SessionId): ConversationSnapshot;
+export declare function sessionSnapshot(sessionId: SessionId): SessionSnapshot;
 /**
- * A ready workspace list with no workspaces (the shape WorkspaceRuntime
- * projects after both baselines land).
- * @returns the initial state of the test workspaces store.
+ * A target-neutral Conversation snapshot.
+ * @param overrides - target roster or activity overrides.
+ * @returns an immutable fixture value.
  */
-export declare function workspaceListState(): WorkspaceListState;
+export declare function conversationSnapshot(overrides?: Partial<ConversationSnapshot>): ConversationSnapshot;
+/**
+ * A Chat target snapshot.
+ * @param overrides - Chat target overrides.
+ * @returns an immutable fixture value.
+ */
+export declare function chatSnapshot(overrides?: Partial<ChatSnapshot>): ChatSnapshot;
+/**
+ * A ready Workspace Controller snapshot with no Workspace rows.
+ * @returns the initial state of the test Workspace source.
+ */
+export declare function workspaceSnapshot(): WorkspaceSnapshot;
 //# sourceMappingURL=fixtures.d.ts.map

package/lib/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * jsdom slot test runtime: a real small runtime — Cordis `Context`, the
- * runtime `SlotRegistry`, and the UI renderer — assembled around
+ * renderer-owned `SlotRegistry`, the `ui-session` adapter, and the UI renderer — assembled around
  * test-owned session/workspace doubles, so feature specs exercise
  * declaration, registration, scope, store, inject, rendering, updates, and
  * disposal without hand-building the machinery per suite.
@@ -15,20 +15,22 @@ import type { Fiber, Plugin } from '@deepseek-ai/cordis';
 import type { RenderResult } from '@testing-library/react';
 import type { queries } from '@testing-library/dom';
 import type { BoundFunctions } from '@testing-library/dom';
-import { SlotRegistry } from '@deepseek-ai/dsh-client-runtime/client';
+import { SlotRegistry } from '@deepseek-ai/dsh-client-ui-renderer/client';
 import type { ChildrenDecl, ComposedProps, HostObservable, OwnerOf, SlotComponent, SlotMap, SlotRenderer, SnapshotSelectorHook, StoreInstanceLike } from '@deepseek-ai/dsh-client-ui-slots';
 import { TestSessions } from './sessions.ts';
 import { TestWorkspaces } from './workspaces.ts';
 import type { Stabilizer } from './fixtures.ts';
-export type { UseSession } from '@deepseek-ai/dsh-client-ui-renderer/client';
+export type { UseSession } from '@deepseek-ai/dsh-client-ui-session/client';
 export { domSnapshotSerializer, registerDomSnapshotSerializer } from './snapshot.ts';
 export { FixtureSession, TestSessions } from './sessions.ts';
 export { stubSettingsScope } from './settings-scope.ts';
 export type { StubSettingsScope } from './settings-scope.ts';
+export { scriptedSettingsRemote } from './settings-remote.ts';
+export type { ScriptedNamespace, ScriptedSettingsRemote } from './settings-remote.ts';
 export { TestWorkspaces } from './workspaces.ts';
-export { TestRemote } from './remote.ts';
-export { conversationSnapshot, workspaceListState } from './fixtures.ts';
-export type { SessionBehaviorOverrides, SessionFixture, Stabilizer } from './fixtures.ts';
+export { RemoteError, TestRemote } from './remote.ts';
+export { chatSnapshot, conversationSnapshot, sessionSnapshot, workspaceSnapshot, } from './fixtures.ts';
+export type { FixtureSnapshot, SessionBehaviorOverrides, SessionFixture, SessionFixtureSnapshot, Stabilizer, } from './fixtures.ts';
 export { makeTranslate } from './translate.ts';
 export { usePinnedBrowserLanguages } from './locale-env.ts';
 /**
@@ -108,7 +110,7 @@ export declare class TestRoot {
  * batching or React act themselves.
  */
 export declare class SlotTestRuntime {
-    /** The runtime's Cordis root (escape hatch: extra services via `ctx.provide`, raw `ctx.plugin` mounts). */
+    /** The runtime's Cordis root for owner APIs and explicit test-only services. */
     readonly ctx: Context;
     /** The production SlotRegistry mounted on {@link SlotTestRuntime.ctx}. */
     readonly slots: SlotRegistry;
@@ -127,6 +129,7 @@ export declare class SlotTestRuntime {
     private readonly ownerCell;
     private readonly autoDeclared;
     private autoRootView;
+    private readonly disposeWorkspaceSource;
     private constructor();
     /**
      * Assemble a runtime: real Context, mounted SlotRegistry, installed
@@ -134,17 +137,6 @@ export declare class SlotTestRuntime {
      * @returns the ready runtime.
      */
     static create(): Promise<SlotTestRuntime>;
-    /**
-     * Provide an extra service the feature under test injects (e.g. a layout
-     * fake). Sugar over `ctx.provide`, typed against the Context declaration
-     * merge: for a declared service name the fake must be a subset of that
-     * service's outward face (Partial — supply only what the feature calls),
-     * so a production face change breaks the fake at compile time. Undeclared
-     * names stay unchecked (ad-hoc test services).
-     * @param name - service name.
-     * @param value - service implementation (test double).
-     */
-    provide<K extends string>(name: K, value: K extends keyof Context ? Partial<Context[K]> : unknown): void;
     /**
      * Mount a feature plugin on a real fiber. Required services are prechecked
      * so a missing provider fails loud instead of suspending the fiber forever
@@ -153,6 +145,8 @@ export declare class SlotTestRuntime {
      * @returns handle owning the fiber's explicit disposal.
      */
     mount(plugin: Plugin): Promise<FeatureHandle>;
+    /** Release the default Workspace hook before mounting its production owner. */
+    releaseWorkspaceSource(): void;
     /**
      * Render the root slot tree through the ctx-level entry (the shell's own
      * entry point): `ctx.slots.renderSlot('root', {})` under Testing Library.

package/lib/types/remote.d.ts

@@ -1,18 +1,17 @@
-/** Test-owned Remote face: `$on` subscriptions driven by the internal forwarded-event plumbing. */
+/** Test-owned Remote face: `$on` subscriptions with an explicit test event driver. */
 import type { Context } from '@deepseek-ai/cordis';
+export { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 /**
  * Remote service test double for the forwarded-event path. Feature specs need
  * `ctx.remote.$on` to exist (their plugins inject `remote`) and need forwarded
- * host events to reach those subscribers, but not the generated namespaces or
- * the wire — so this double implements subscription and dispatch only.
+ * Host events to reach those subscribers, but not the wire — so this double
+ * implements subscription plus an explicit `emit` driver available only on the
+ * concrete test object. A spec that also calls one namespace scripts it through
+ * the constructor rather than reaching the real Client Remote service.
  *
- * Dispatch is driven the same way production drives it: `client/runtime` owns the
- * host frame sink and hands each decoded `host/remote-event` frame to
- * `$dispatch`. A spec therefore exercises its refresh chains by calling
- * `$dispatch(name, args)` on this double.
- *
- * `$mount` rejects: a spec that reaches a generated namespace through this
- * double has outgrown it and needs the real Client Remote service.
+ * `$mount` rejects: a spec that needs a real generated contribution installed —
+ * codecs, descriptors, and the wire — has outgrown this double and needs the
+ * real Client Remote service.
  *
  * One deliberate asymmetry with production: a throwing listener propagates out
  * of the emit instead of being contained and logged, so a spec cannot lean on
@@ -22,17 +21,27 @@ import type { Context } from '@deepseek-ai/cordis';
 export declare class TestRemote {
     private readonly subscriptions;
     /**
-     * Register the double as `ctx.remote`.
+     * Fixed Host facts mirrored from the production `ctx.remote.$host`. Plain
+     * mutable field: a spec assigns it to script a non-loopback or homed Host.
+     */
+    $host: {
+        home: string | undefined;
+        isLoopback: boolean;
+    };
+    /**
+     * Register the double as `ctx.remote`, plus one service per scripted
+     * namespace so a plugin injecting `remote.<name>` also unparks.
      * @param ctx - the spec's root Context.
+     * @param namespaces - scripted namespace faces reached as `ctx.remote.<name>`.
      */
-    constructor(ctx: Context);
+    constructor(ctx: Context, namespaces?: Readonly<Record<string, object>>);
     /**
      * Deliver one forwarded host event to its subscribers, standing in for the
      * carrier that owns the frame sink.
      * @param event - forwarded host event name.
      * @param args - the Host argument list, verbatim.
      */
-    $dispatch(event: string, args: readonly unknown[]): void;
+    emit(event: string, args: readonly unknown[]): void;
     /**
      * Subscribe to one forwarded host event.
      * @param event - forwarded host event name.

package/lib/types/sessions.d.ts

@@ -1,12 +1,15 @@
-/** Test-owned sessions face: the SlotRegistry host contract over declarative fixtures. */
+/** Test-owned Session Controller faces over declarative fixtures. */
 import type { Context } from '@deepseek-ai/cordis';
 import type { AttachmentIdType } from '@deepseek-ai/dsh-attachment';
-import type { AgentContext, ConversationSnapshot, ISessions, ProjectionsFace, SessionFace, SessionId, SessionListState, SessionProvideDescriptor, SessionSearchResultItem, SessionSummary, SnapshotStore, SubagentAddress } from '@deepseek-ai/dsh-client-runtime/client';
-import type { HostObservable, SessionMaybeProvideInfo, SessionProvideInfo } from '@deepseek-ai/dsh-client-ui-slots';
-import type { SessionFixture, Stabilizer } from './fixtures.ts';
+import { MutableSessionEventSource } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { AgentContext, ISessions, ProjectionsFace, SessionBinding, SessionFace, SessionListState, SessionEventLikeEntry, SessionLiveEventEntry, SessionSearchResultItem, SessionSnapshot, SessionSummary, SubmissionHandle } from '@deepseek-ai/dsh-api-session-controller/client';
+import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SessionFixture, SessionFixtureSnapshot, Stabilizer } from './fixtures.ts';
 /**
- * The fixture-backed session face: conversation reads delegate to the
- * fixture's snapshot store; ISession verbs are fail-loud stubs unless the
+ * The fixture-backed session face: lifecycle reads delegate to the fixture's
+ * snapshot store; Session verbs are fail-loud stubs unless the
  * fixture supplies them (the runtime never fakes behavior a test did not
  * declare — an unstubbed call names itself instead of half-working). Extra
  * fixture methods are grafted verbatim for feature-side casts.
@@ -14,21 +17,22 @@ import type { SessionFixture, Stabilizer } from './fixtures.ts';
 export declare class FixtureSession implements SessionFace {
     readonly sessionId: SessionId;
     private readonly store;
+    /** Mutable event source consumed only by Conversation assembly. */
+    readonly eventSource: MutableSessionEventSource;
     /**
-     * The useProjection seat: identity-stable per-key faces over the fixture's
-     * projection values (set via {@link TestSessions.setProjection}).
+     * Identity-stable per-key faces over fixture-controlled projection values.
      */
     readonly projections: ProjectionsFace & {
         set(key: string, value: unknown): void;
     };
     /**
      * @param sessionId - host identity (branded view of the fixture id).
-     * @param store - conversation snapshot store (updateSnapshot writes it).
+     * @param store - Session Controller snapshot store.
      * @param overrides - fixture-declared behavior face, grafted over the stubs.
      */
-    constructor(sessionId: SessionId, store: SnapshotStore<ConversationSnapshot>, overrides: Record<string, unknown>);
-    /** @returns the fixture conversation snapshot (useSession read side). */
-    getSnapshot(): ConversationSnapshot;
+    constructor(sessionId: SessionId, store: SnapshotStore<SessionFixtureSnapshot>, overrides: Record<string, unknown>);
+    /** @returns the fixture Session Controller snapshot (useSession read side). */
+    getSnapshot(): SessionSnapshot;
     /**
      * Subscribe to fixture snapshot changes.
      * @param fn - change callback.
@@ -40,6 +44,14 @@ export declare class FixtureSession implements SessionFace {
      * @returns never — always throws.
      */
     prompt(): never;
+    /**
+     * Minimal local-echo registration: mints an identity without touching the
+     * fixture snapshot (submission echoes are client-only presentation state).
+     * Supply `beginSubmission` on the fixture's session face to observe echoes.
+     * @returns a handle whose abandon is a no-op.
+     */
+    beginSubmission(): SubmissionHandle;
+    private submissionSeq;
     /**
      * Fail-loud stub; supply `readAttachment` on the fixture's session face to exercise it.
      * @param _attachmentId - opaque durable attachment id.
@@ -66,53 +78,44 @@ export declare class FixtureSession implements SessionFace {
      * @returns never — always throws.
      */
     loadOlder(): never;
+    /**
+     * Fail-loud stub; supply `loadThrough` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    loadThrough(): never;
     /**
      * Fail-loud stub; supply `rename` on the fixture's session face to exercise it.
      * @returns never — always throws.
      */
     rename(): never;
 }
-/** Test binding shape handed to provider resolvers and feature injects (a SessionBinding whose session is the fixture face). */
-export interface TestSessionBinding {
-    readonly sessionId: SessionId;
-    readonly session: FixtureSession;
-    readonly ctx: AgentContext;
-}
 /**
  * Sessions test double behind the renderer host and feature injects: owns the
- * list/current observable, the standard-props provide channel (the runtime's
- * `useSession` contribution included), scope minting through the production
- * `createScope`, and the session behavior face supplied per fixture.
+ * list/current observable, scope minting through the production `createScope`,
+ * stable Controller bindings, and the session behavior face supplied per
+ * fixture. `ui-session` owns standard-source materialization.
  *
  * Implements the same ISessions face features receive as `ctx.sessions`, so
  * a production face change breaks this double at compile time; the extra
- * members (add/updateSnapshot/setCurrent/remove/behavior/calls/stubSearch and
- * the legacy provideInfo/maybeProvideInfo lookups) are bench-only surface.
+ * members (add/updateSessionSnapshot/event-window drivers/setCurrent/remove/
+ * behavior/calls/stubs) are bench-only surface.
  */
 export declare class TestSessions implements ISessions {
     private readonly stabilize;
     private readonly rootCtx;
     /** The useSessions standard feed (list rows + current selection). */
     readonly list: SnapshotStore<SessionListState>;
-    /**
-     * Atomic current-session provide projection (production SessionRuntime
-     * mirror): selection changes and provider-roster changes publish through
-     * this one source — the member the SlotRegistry host face hands the
-     * renderer's SessionProvider.
-     */
-    readonly currentProvideInfo: HostObservable<SessionMaybeProvideInfo>;
     private readonly records;
-    /** The production provide channel (roster, materialization rules, current projection) — no test-side mirror. */
-    private readonly channel;
     /** Calls observed on the service-level face, newest last. */
     readonly calls: {
-        method: 'open' | 'openSubagent' | 'setSubagentCatalogOpen' | 'refreshSubagents' | 'clear' | 'search' | 'fork';
+        method: 'create' | 'open' | 'openSubagent' | 'setSubagentCatalogOpen' | 'refreshSubagents' | 'clear' | 'refresh' | 'search' | 'fork';
         args: unknown[];
     }[];
     /** The wire schema's `session.search` result bound (production parity). */
     readonly searchResultLimit = 20;
     /** Replaceable search behavior (see {@link TestSessions.stubSearch}). */
     private searchStub;
+    private createStub;
     /**
      * @param stabilize - the owning runtime's act wrapper.
      * @param rootCtx - the runtime's Cordis root; scope fibers mount under it.
@@ -128,12 +131,31 @@ export declare class TestSessions implements ISessions {
         current?: boolean;
     }): Promise<SessionId>;
     /**
-     * Update a session's conversation snapshot through an immer draft (the
-     * live-stream stand-in: components subscribed via useSession re-render).
+     * Update Session Controller lifecycle state through an immer draft.
      * @param id - session id.
      * @param mutate - draft mutator.
      */
-    updateSnapshot(id: string, mutate: (draft: ConversationSnapshot) => void): Promise<void>;
+    updateSessionSnapshot(id: string, mutate: (draft: SessionFixtureSnapshot) => void): Promise<void>;
+    /**
+     * Replace a Session's complete contiguous event window.
+     * @param id - Session identity.
+     * @param entries - complete event window.
+     * @param hasMore - whether older history remains.
+     */
+    replaceEvents(id: string, entries: readonly SessionEventLikeEntry[], hasMore?: boolean): Promise<void>;
+    /**
+     * Prepend one older contiguous event page.
+     * @param id - Session identity.
+     * @param entries - older entries.
+     * @param hasMore - whether another older page remains.
+     */
+    prependEvents(id: string, entries: readonly SessionEventLikeEntry[], hasMore?: boolean): Promise<void>;
+    /**
+     * Append one live event to a Session's contiguous window.
+     * @param id - Session identity.
+     * @param entry - live event entry.
+     */
+    appendEvent(id: string, entry: SessionLiveEventEntry): Promise<void>;
     /**
      * Update a session's list row (the wire-echo stand-in: title settles,
      * running flips — components subscribed via useSessions re-render).
@@ -149,31 +171,10 @@ export declare class TestSessions implements ISessions {
     /**
      * Remove a session: list row, scope fiber, and per-session store instances
      * (with persisted state) die together — the same single lifecycle axis the
-     * production SessionRuntime drives on session death, minus staging.
+     * production Client Sessions service drives on session death, minus staging.
      * @param id - session id.
      */
     remove(id: string): Promise<void>;
-    /**
-     * Register a per-session standard-props provider (production `provide`
-     * contract: hooks become `use<Name>` selector hooks on the render side,
-     * props spread verbatim; duplicate names fail loud at materialization).
-     * @param descriptor - static member roster plus per-session resolver.
-     * @returns disposer removing the provider.
-     */
-    provide(descriptor: SessionProvideDescriptor): () => void;
-    /**
-     * Resolve the definite per-session standard-props bundle (host face member).
-     * @param id - session id.
-     * @returns the identity-stable bundle, or undefined for unknown sessions.
-     */
-    provideInfo(id: string): SessionProvideInfo | undefined;
-    /**
-     * Resolve the current-session-optional standard kit (host face member):
-     * unknown or absent ids return the static no-session projection.
-     * @param id - current session id, when selected.
-     * @returns a definite or no-session provide bundle.
-     */
-    maybeProvideInfo(id: string | undefined): SessionMaybeProvideInfo;
     /**
      * Resolve (mint on first touch) the session-scoped Cordis context through
      * the production `createScope`, so real `scopeOf`/scope-addressed services
@@ -187,7 +188,7 @@ export declare class TestSessions implements ISessions {
      * @param id - session id.
      * @returns sessionId + behavior face + scoped ctx, or undefined when unknown.
      */
-    binding(id: string): TestSessionBinding | undefined;
+    binding(id: string): SessionBinding | undefined;
     /**
      * Read the session scope tag off a context (service-method boundary mirror).
      * @param ctx - any client context.
@@ -201,6 +202,13 @@ export declare class TestSessions implements ISessions {
      * @returns the fixture session face, or undefined off-scope.
      */
     sessionOf(ctx: Context): SessionFace | undefined;
+    /**
+     * Install Session creation behavior for navigation tests.
+     * @param impl - implementation that must return an already-added fixture id.
+     */
+    stubCreate(impl: (opts: Parameters<ISessions['create']>[0]) => Promise<SessionId>): void;
+    /** Create through the installed test behavior and require an addressable binding. */
+    create(opts?: Parameters<ISessions['create']>[0]): Promise<SessionId>;
     /**
      * Service-level selection call (recorded, then applied to the list store
      * synchronously — inject callbacks call this outside any act window; the
@@ -216,10 +224,10 @@ export declare class TestSessions implements ISessions {
     setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
     /** Record a catalog refresh; fixture callers drive snapshots explicitly. */
     refreshSubagents(parentSessionId: SessionId): Promise<void>;
-    /** Apply a confirmed preset switch into the fixture list, as production does. */
-    noteAgentPreset(sessionId: SessionId, agentPreset: string): void;
     /** Clear the current selection (recorded; the production no-session flow). */
     clear(): void;
+    /** Record a list refresh; fixture callers publish list state explicitly. */
+    refresh(): Promise<void>;
     /**
      * Replace the sidebar-search result page (the call is still recorded).
      * @param impl - hits for a query, as the Host would rank them.
@@ -252,7 +260,7 @@ export declare class TestSessions implements ISessions {
      * The session face of a fixture (typed view for assertions; fixture
      * behavior methods are grafted onto it).
      * @param id - session id.
-     * @returns the FixtureSession the binding and provide channel carry.
+     * @returns the FixtureSession carried by the Controller binding.
      */
     behavior(id: string): FixtureSession;
     /** Dispose minted scope fibers (runtime dispose path). */

package/lib/types/settings-remote.d.ts

@@ -0,0 +1,83 @@
+/** Test double for the `settings` Remote namespace a bench's plugins inject. */
+import { vi } from 'vitest';
+/** The minimum a scripted namespace view carries for the double's own bookkeeping. */
+export interface ScriptedNamespace {
+    /** Namespace key the write addresses. */
+    ns: string;
+}
+/** One scripted `settings` namespace face plus the controls a bench drives it with. */
+export interface ScriptedSettingsRemote<View extends ScriptedNamespace> {
+    /**
+     * The namespace face handed to `TestRemote` as `settings`. A plugin injecting
+     * `remote.settings` unparks on it, which is what most benches need; the
+     * describe answer is the same one the shared mirror would read.
+     */
+    settings: {
+        describe(): Promise<{
+            ok: true;
+            value: {
+                writable: boolean;
+                hasDocument: boolean;
+                namespaces: readonly View[];
+            };
+        }>;
+        update(ns: string, patch: unknown, expectedRevision: number | undefined): Promise<{
+            ok: true;
+            value: View;
+        } | {
+            ok: false;
+            error: {
+                code: string;
+                message: string;
+                details: object;
+            };
+        }>;
+        replace(ns: string, section: unknown, expectedRevision: number | undefined): Promise<{
+            ok: true;
+            value: View;
+        } | {
+            ok: false;
+            error: {
+                code: string;
+                message: string;
+                details: object;
+            };
+        }>;
+        mutate(ns: string, ops: unknown, expectedRevision: number | undefined): Promise<{
+            ok: true;
+            value: View;
+        } | {
+            ok: false;
+            error: {
+                code: string;
+                message: string;
+                details: object;
+            };
+        }>;
+    };
+    /** Spy behind `settings.update`, for argument assertions. */
+    update: ReturnType<typeof vi.fn>;
+    /** Spy behind `settings.replace`, for argument assertions. */
+    replace: ReturnType<typeof vi.fn>;
+    /** Spy behind `settings.mutate`, for argument assertions. */
+    mutate: ReturnType<typeof vi.fn>;
+    /**
+     * Replace what the next describe answers with, as a Host commit would.
+     * @param namespaces - the namespace views to serve from now on.
+     */
+    publish(namespaces: readonly View[]): void;
+}
+/**
+ * Build a scripted `settings` Remote namespace for a bench. Each write answers
+ * with the addressed namespace unchanged, so a bench that only needs its
+ * plugins to activate scripts nothing; one asserting a write reads the
+ * corresponding spy or replaces the face.
+ * @param namespaces - namespace views the first describe answers with.
+ * @param options - deployment facts the describe answer reports.
+ * @returns the face and its controls.
+ */
+export declare function scriptedSettingsRemote<View extends ScriptedNamespace>(namespaces?: readonly View[], options?: {
+    writable?: boolean;
+    hasDocument?: boolean;
+}): ScriptedSettingsRemote<View>;
+//# sourceMappingURL=settings-remote.d.ts.map

package/lib/types/settings-scope.d.ts

@@ -1,12 +1,14 @@
 /** Test double for the client settings-scope seam. */
 import { vi } from 'vitest';
-import type { SettingsScope, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SettingsScope, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-ui-settings/client';
 /** Handle over one stubbed scope: the scope, its write spy, and publication controls. */
 export interface StubSettingsScope<T> {
     /** The scope face handed to the service under test. */
     scope: SettingsScope<T>;
     /** Spy behind `scope.set`; resolves immediately. */
     set: ReturnType<typeof vi.fn>;
+    /** Spy behind `scope.mutate`; resolves immediately. */
+    mutate: ReturnType<typeof vi.fn>;
     /** Spy behind `scope.unset`; resolves immediately. */
     unset: ReturnType<typeof vi.fn>;
     /** @returns how many listeners are currently subscribed (disposal assertions). */

package/lib/types/workspaces.d.ts

@@ -1,5 +1,15 @@
-import type { DirectoryListing, IWorkspaces, SessionId, SnapshotStore, WorkspaceId, WorkspaceListState, WorkspaceView } from '@deepseek-ai/dsh-client-runtime/client';
-import type { Stabilizer } from './fixtures.ts';
+import type { IWorkspaces, WorkspaceId, WorkspaceSnapshot, WorkspaceView } from '@deepseek-ai/dsh-api-workspace-controller/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { FixtureSnapshot, Stabilizer } from './fixtures.ts';
+/** Writable test representation of the immutable Workspace Controller snapshot. */
+type WorkspaceFixtureSnapshot = FixtureSnapshot<WorkspaceSnapshot>;
+/** Callable command names on the production Workspace Controller face. */
+type WorkspaceAction = {
+    [Key in keyof IWorkspaces]: IWorkspaces[Key] extends (...args: never[]) => unknown ? Key : never;
+}[keyof IWorkspaces];
+/** Test replacement retaining one Controller command's parameters and result. */
+type WorkspaceStub<Key extends WorkspaceAction> = (...args: Parameters<IWorkspaces[Key]>) => ReturnType<IWorkspaces[Key]>;
 /**
  * Workspaces test double. Implements the same IWorkspaces face features
  * receive as `ctx.workspaces`, so a production face change breaks this
@@ -10,7 +20,7 @@ import type { Stabilizer } from './fixtures.ts';
 export declare class TestWorkspaces implements IWorkspaces {
     private readonly stabilize;
     /** The useWorkspaces standard feed. */
-    readonly list: SnapshotStore<WorkspaceListState>;
+    readonly list: SnapshotStore<WorkspaceFixtureSnapshot>;
     /** Calls observed on the action face, newest last. */
     readonly calls: {
         method: string;
@@ -26,26 +36,13 @@ export declare class TestWorkspaces implements IWorkspaces {
      * Update the workspace list state through an immer draft.
      * @param mutate - draft mutator.
      */
-    update(mutate: (draft: WorkspaceListState) => void): Promise<void>;
+    update(mutate: (draft: WorkspaceFixtureSnapshot) => void): Promise<void>;
     /**
      * Replace an action's behavior (the recorded call is still appended first).
-     * @param method - action name (e.g. 'connectWorkspace').
+     * @param method - Controller action name (e.g. 'create').
      * @param impl - replacement behavior.
      */
-    stub(method: string, impl: (...args: unknown[]) => unknown): void;
-    /**
-     * Connect a workspace to its reusable/new blank session (recorded). The
-     * default resolves the workspace id back as the session id; stub for
-     * cross-session flows.
-     * @param workspaceId - target workspace.
-     * @returns the connected session id.
-     */
-    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
-    /**
-     * New-session flow (recorded; stubbed behavior runs when installed).
-     * @param workspaceId - optional explicit workspace target.
-     */
-    startSession(workspaceId?: WorkspaceId): void;
+    stub<Key extends WorkspaceAction>(method: Key, impl: WorkspaceStub<Key>): void;
     /**
      * Create a Workspace (recorded). The default echoes a view derived from
      * the input; stub for failure or list-coupled flows.
@@ -55,30 +52,6 @@ export declare class TestWorkspaces implements IWorkspaces {
     create(input: {
         path: string;
     }): Promise<WorkspaceView>;
-    /**
-     * Open a path with the host OS default application (recorded; default no-op).
-     * @param path - host-resolvable path.
-     */
-    openPath(path: string): Promise<void>;
-    /**
-     * Directory picker (recorded). The default cancels (null); stub to select.
-     * @returns the picked path, or null.
-     */
-    pickDirectory(): Promise<string | null>;
-    /**
-     * Browse listing (recorded). The default serves an empty home level; stub
-     * to shape a tree.
-     * @param path - absolute directory to list; absent lists the home level.
-     * @returns the level's listing.
-     */
-    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
-    /**
-     * Browse child creation (recorded). The default joins parent and name.
-     * @param path - absolute existing parent directory.
-     * @param name - single path segment.
-     * @returns the created directory's absolute path.
-     */
-    createDirectory(path: string, name: string): Promise<string>;
     /**
      * Rename a Workspace (recorded). The default echoes a minimal view.
      * @param workspaceId - target workspace.
@@ -112,4 +85,5 @@ export declare class TestWorkspaces implements IWorkspaces {
      */
     archiveSession(sessionId: SessionId): Promise<void>;
 }
+export {};
 //# sourceMappingURL=workspaces.d.ts.map