@deepseek-ai/dsh-client-test-runtime 0.0.1-rc.1

package/lib/invariant.js

@@ -0,0 +1,25 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@deepseek-ai/dsh-client-test-runtime`.
+* @module @deepseek-ai/dsh-client-test-runtime/invariant
+*/
+const PACKAGE_NAME = "@deepseek-ai/dsh-client-test-runtime";
+/** Cordis companion plugin name. */
+const name = "client-test-runtime-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this test-support package owns no production event
+* stream or mutable data — it assembles the runtime SlotsService and renderer
+* (whose packages own their invariants) around test doubles; its own behavior
+* is exercised by its package tests.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/fixtures.d.ts

@@ -0,0 +1,46 @@
+/** 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';
+/**
+ * Fixture overrides for the session behavior face: any subset of the
+ * production ISession verbs (typed against it, so a face change surfaces
+ * here at compile time), plus extra members feature-specific casts consume.
+ * The open Record tail means a misnamed EXTRA member is not caught by the
+ * compiler (it grafts as dead weight); the ISession verbs stay safe — a
+ * misnamed verb leaves the fail-loud stub in place, which names itself at
+ * the first call.
+ */
+export type SessionBehaviorOverrides = Partial<ISession> & Record<string, unknown>;
+/**
+ * act-wrapped mutation runner shared by every runtime object: public mutators
+ * funnel through it so tests never handle SlotCore microtask batching or
+ * React act themselves.
+ */
+export type Stabilizer = (fn: () => void | Promise<void>) => Promise<void>;
+/**
+ * Session fixture accepted by {@link TestSessions.add}: identity plus optional
+ * snapshot/list-row overrides and the session behavior face the feature under
+ * test actually calls (kept open — the runtime never fakes methods a test did
+ * not supply, so an unstubbed call fails loud at the call site).
+ */
+export interface SessionFixture {
+    id: string;
+    /** Overrides merged over {@link conversationSnapshot} (sessionId comes from `id`). */
+    snapshot?: Partial<Omit<ConversationSnapshot, '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;
+}
+/**
+ * A complete quiescent conversation snapshot (open window, no traffic).
+ * @param sessionId - owning session id.
+ * @returns the snapshot; spread fixture overrides on top.
+ */
+export declare function conversationSnapshot(sessionId: SessionId): ConversationSnapshot;
+/**
+ * A ready workspace list with no workspaces (the shape WorkspacesService
+ * projects after both baselines land).
+ * @returns the initial state of the test workspaces store.
+ */
+export declare function workspaceListState(): WorkspaceListState;
+//# sourceMappingURL=fixtures.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,194 @@
+/**
+ * jsdom slot test runtime: a real small runtime — Cordis `Context`, the
+ * runtime `SlotsService`, and the web-react 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.
+ *
+ * Not part of the product plugin graph (no `dsh.client`); feature packages
+ * depend on it in devDependencies only. It copies no SlotCore/renderer/store
+ * machinery — everything mounts the production implementations.
+ * @module @deepseek-ai/dsh-client-test-runtime
+ */
+import { Context } from '@deepseek-ai/cordis';
+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 { SlotsService } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ChildrenDecl, ComposedProps, OwnerOf, SlotComponent, SlotMap, 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 { 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 { TestWorkspaces } from './workspaces.ts';
+export { conversationSnapshot, workspaceListState } from './fixtures.ts';
+export type { SessionBehaviorOverrides, SessionFixture, Stabilizer } from './fixtures.ts';
+export { makeTranslate } from './translate.ts';
+export { usePinnedBrowserLanguages } from './locale-env.ts';
+/**
+ * One rendered slot's local view, from {@link SlotTestRuntime.renderSlot}:
+ * the `data-slot` wrapper is the snapshot root (`expect(view.container)
+ * .toMatchSnapshot()` captures exactly this slot's output), Testing Library
+ * queries are bound inside it, and `update` re-renders with new owner props.
+ */
+export interface SlotView<K extends keyof SlotMap & string> {
+    /** The `<div data-slot="<key>">` wrapper around the slot's rendered output. */
+    readonly container: HTMLElement;
+    /** Testing Library queries scoped to {@link SlotView.container}. */
+    readonly view: BoundFunctions<typeof queries>;
+    /**
+     * Replace the owner props and flush the re-render (the render-site update:
+     * in production the owner recomputes the share and React re-renders).
+     * @param owner - the next owner props share.
+     */
+    update(owner: OwnerOf<K>): void;
+}
+/**
+ * Mounted feature plugin handle: the live fiber plus an act-wrapped,
+ * idempotent dispose (unload cascade: entries, declared child slots, store
+ * instances, and provided services all fall together).
+ */
+export interface FeatureHandle {
+    /** The plugin's live Cordis fiber (state assertions, escape hatch). */
+    readonly fiber: Fiber;
+    /**
+     * Dispose the plugin fiber inside React act; repeated calls no-op.
+     * @returns completion of the unload cascade.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * The test-owned 'root' occupant: declares the child slots a suite needs
+ * through the REAL `slots.register`, with a caller-supplied minimal frame —
+ * the runtime never guesses a feature's page structure.
+ */
+export declare class TestRoot {
+    private readonly slots;
+    private readonly stabilize;
+    private disposeEntry;
+    /**
+     * @param slots - the runtime SlotsService.
+     * @param stabilize - the owning runtime's act wrapper.
+     */
+    constructor(slots: SlotsService, stabilize: Stabilizer);
+    /**
+     * Register the root frame, declaring (and thereby claiming) the child
+     * slots. One declaration per runtime — a second call fails loud in the
+     * core ('root' is a single slot).
+     * @param children - child-slot declaration table (declaration + render authorization + runtime spec).
+     * @param frame - minimal frame component; its props derive from the declared keys (composed-props contract).
+     * @returns completion of the act-wrapped registration.
+     */
+    declare<const D extends ChildrenDecl>(children: D, frame: SlotComponent<ComposedProps<'root', never, keyof NoInfer<D> & keyof SlotMap & string, undefined, object>>): Promise<void>;
+    /** Remove the root registration and collapse its declarations (runtime dispose path). */
+    release(): void;
+}
+/**
+ * The assembled test runtime. Obtain via {@link SlotTestRuntime.create};
+ * dispose with {@link SlotTestRuntime.dispose} (afterEach). Public mutators
+ * are act-wrapped throughout — tests never handle SlotCore microtask
+ * 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). */
+    readonly ctx: Context;
+    /** The production SlotsService mounted on {@link SlotTestRuntime.ctx}. */
+    readonly slots: SlotsService;
+    /** The test-owned 'root' occupant. */
+    readonly root: TestRoot;
+    /** Sessions double (list/current observable, cells, scopes, behavior faces). */
+    readonly sessions: TestSessions;
+    /** Workspaces double (list observable, recorded intent actions). */
+    readonly workspaces: TestWorkspaces;
+    private readonly stabilizer;
+    private host;
+    private readonly views;
+    private readonly handles;
+    private disposed;
+    /** Auto-frame state ({@link SlotTestRuntime.declare} / {@link SlotTestRuntime.renderSlot}). */
+    private readonly ownerCell;
+    private readonly autoDeclared;
+    private autoRootView;
+    private constructor();
+    /**
+     * Assemble a runtime: real Context, mounted SlotsService, installed
+     * renderer, and the session/workspace doubles provided as services.
+     * @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
+     * (deliberate load-order suspension tests use `ctx.plugin` directly).
+     * @param plugin - plugin value (function, class, or `{ inject, apply }` object).
+     * @returns handle owning the fiber's explicit disposal.
+     */
+    mount(plugin: Plugin): Promise<FeatureHandle>;
+    /**
+     * Render the root slot tree through the ctx-level entry (the shell's own
+     * entry point): `ctx.slots.renderSlot('root', {})` under Testing Library.
+     * @returns the Testing Library view.
+     */
+    renderRoot(): RenderResult;
+    /**
+     * Declare child slots under an auto-generated root frame — the single-slot
+     * mounting path for local DOM snapshots. Each key later supplied through
+     * {@link SlotTestRuntime.renderSlot} renders inside its own
+     * `<div data-slot="<key>">` wrapper (the snapshot root). Mutually exclusive
+     * with {@link TestRoot.declare} ('root' is a single slot); one call per
+     * runtime.
+     * @param children - child-slot declaration table (same contract as TestRoot.declare).
+     * @returns completion of the act-wrapped registration.
+     */
+    declare(children: ChildrenDecl): Promise<void>;
+    /**
+     * Render one declared slot with its owner props and return the local view.
+     * The whole root tree mounts through the production assembly path
+     * (renderer, scope providers, store axis); only this key's output lands in
+     * the returned container. Call again with another key to view a sibling
+     * slot of the same tree.
+     * @param key - a key declared through {@link SlotTestRuntime.declare}.
+     * @param owner - owner props share for the render site.
+     * @returns the slot-local view (snapshot container, scoped queries, owner updates).
+     */
+    renderSlot<K extends keyof SlotMap & string>(key: K, owner: OwnerOf<K>): SlotView<K>;
+    /**
+     * Resolve the store instance the renderer would hand a slot's component
+     * (identity assertions, action-driven writes). Requires a prior
+     * {@link SlotTestRuntime.renderRoot} — the host face exists only inside the
+     * installed renderer, exactly as in production.
+     * @param key - slot key whose first entry declares the store.
+     * @param scopeKey - session id for session-scope slots; omit for root scope.
+     * @returns the live store instance.
+     */
+    storeOf(key: keyof SlotMap & string, scopeKey?: string): StoreInstanceLike;
+    /**
+     * Flush pending ledger/store notifications inside act — for mutations made
+     * outside the runtime's own methods (e.g. a direct `slots.register`).
+     * @returns completion of the act pass.
+     */
+    flush(): Promise<void>;
+    /**
+     * Tear down: unmount React trees first, then dispose feature fibers, the
+     * root registration, minted session scopes, and persisted test state.
+     * Idempotent.
+     * @returns completion of the teardown.
+     */
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-test-runtime`.
+ * @module @deepseek-ai/dsh-client-test-runtime/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "client-test-runtime-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/locale-env.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pin `navigator.languages`/`navigator.language` for every test in the
+ * calling file (or describe block), restoring the environment's own values
+ * afterwards. Call at suite level, like the other vitest hooks.
+ * @param primary - most preferred BCP 47 tag; also becomes `navigator.language`.
+ * @param rest - further tags in preference order.
+ */
+export declare function usePinnedBrowserLanguages(primary: string, ...rest: string[]): void;
+//# sourceMappingURL=locale-env.d.ts.map

package/lib/types/sessions.d.ts

@@ -0,0 +1,263 @@
+/** Test-owned sessions face: the SlotsService host contract 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';
+/**
+ * The fixture-backed session face: conversation reads delegate to the
+ * fixture's snapshot store; ISession 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.
+ */
+export declare class FixtureSession implements SessionFace {
+    readonly sessionId: SessionId;
+    private readonly store;
+    /**
+     * The useProjection seat: identity-stable per-key faces over the fixture's
+     * projection values (set via {@link TestSessions.setProjection}).
+     */
+    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 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;
+    /**
+     * Subscribe to fixture snapshot changes.
+     * @param fn - change callback.
+     * @returns unsubscribe.
+     */
+    subscribe(fn: () => void): () => void;
+    /**
+     * Fail-loud stub; supply `prompt` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    prompt(): never;
+    /**
+     * Fail-loud stub; supply `readAttachment` on the fixture's session face to exercise it.
+     * @param _attachmentId - opaque durable attachment id.
+     * @returns never — always throws.
+     */
+    readAttachment(_attachmentId: AttachmentIdType): never;
+    /**
+     * Fail-loud stub; supply `updateQueue` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    updateQueue(): never;
+    /**
+     * Fail-loud stub; supply `cancel` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    cancel(): never;
+    /**
+     * Fail-loud stub; supply `command` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    command(): never;
+    /**
+     * Fail-loud stub; supply `loadOlder` on the fixture's session face to exercise it.
+     * @returns never — always throws.
+     */
+    loadOlder(): 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.
+ *
+ * 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.
+ */
+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 SessionsService
+     * mirror): selection changes and provider-roster changes publish through
+     * this one source — the member the SlotsService 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';
+        args: unknown[];
+    }[];
+    /** The wire schema's `session.search` result bound (production parity). */
+    readonly searchResultLimit = 20;
+    /** Replaceable search behavior (see {@link TestSessions.stubSearch}). */
+    private searchStub;
+    /**
+     * @param stabilize - the owning runtime's act wrapper.
+     * @param rootCtx - the runtime's Cordis root; scope fibers mount under it.
+     */
+    constructor(stabilize: Stabilizer, rootCtx: Context);
+    /**
+     * Add a session from a fixture and (by default) make it current.
+     * @param fixture - identity + snapshot/summary overrides + behavior face.
+     * @param opts - pass `current: false` to add without selecting.
+     * @returns the stable session id (branded view of `fixture.id`).
+     */
+    add(fixture: SessionFixture, opts?: {
+        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).
+     * @param id - session id.
+     * @param mutate - draft mutator.
+     */
+    updateSnapshot(id: string, mutate: (draft: ConversationSnapshot) => void): Promise<void>;
+    /**
+     * Update a session's list row (the wire-echo stand-in: title settles,
+     * running flips — components subscribed via useSessions re-render).
+     * @param id - session id.
+     * @param patch - summary fields to merge over the row.
+     */
+    updateSummary(id: string, patch: Partial<Omit<SessionSummary, 'id'>>): Promise<void>;
+    /**
+     * Switch the current selection (undefined = the no-session empty state).
+     * @param id - session id to select, or undefined to clear.
+     */
+    setCurrent(id: string | undefined): Promise<void>;
+    /**
+     * Remove a session: list row, scope fiber, and per-session store instances
+     * (with persisted state) die together — the same single lifecycle axis the
+     * production SessionsService 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
+     * resolve it.
+     * @param id - session id.
+     * @returns the scoped context, or undefined for unknown sessions.
+     */
+    scope(id: string): AgentContext | undefined;
+    /**
+     * Session assembly binding (inject factories and provide resolvers receive it).
+     * @param id - session id.
+     * @returns sessionId + behavior face + scoped ctx, or undefined when unknown.
+     */
+    binding(id: string): TestSessionBinding | undefined;
+    /**
+     * Read the session scope tag off a context (service-method boundary mirror).
+     * @param ctx - any client context.
+     * @returns the session id, or undefined on root contexts.
+     */
+    scopeOf(ctx: Context): SessionId | undefined;
+    /**
+     * Resolve the scoped session face off a context (production `sessionOf`
+     * mirror).
+     * @param ctx - any client context.
+     * @returns the fixture session face, or undefined off-scope.
+     */
+    sessionOf(ctx: Context): SessionFace | undefined;
+    /**
+     * Service-level selection call (recorded, then applied to the list store
+     * synchronously — inject callbacks call this outside any act window; the
+     * store notify is microtask-batched so the next stabilized step observes it).
+     * @param id - session id.
+     */
+    open(id: SessionId): void;
+    /** Open an existing fixture through its catalog address. */
+    openSubagent(address: SubagentAddress): void;
+    /** Resolve the current fixture's retained catalog address. */
+    subagentAddress(id: SessionId): SubagentAddress | undefined;
+    /** Record catalog consumption; fixture callers drive snapshots explicitly. */
+    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;
+    /**
+     * Replace the sidebar-search result page (the call is still recorded).
+     * @param impl - hits for a query, as the Host would rank them.
+     */
+    stubSearch(impl: (query: string, signal: AbortSignal) => {
+        items: SessionSearchResultItem[];
+        hasMore: boolean;
+    }): void;
+    /**
+     * Content search over the fixture corpus (recorded). The default answers an
+     * empty page: content ranking is Host behavior, so a scenario that asserts
+     * hits declares them through {@link TestSessions.stubSearch}.
+     * @param query - non-blank literal phrase.
+     * @param signal - cancellation for a superseded search (recorded and forwarded).
+     * @returns the stubbed or empty result page.
+     */
+    search(query: string, signal: AbortSignal): ReturnType<ISessions['search']>;
+    /**
+     * Recorded fork stub: no child materializes (benches asserting the full
+     * fork flow drive the production service; this face only proves the call).
+     * @param opts - source session id, optional cut anchor, and client title policy.
+     * @returns the source id (no child record is created).
+     */
+    fork(opts: {
+        sessionId: SessionId;
+        atSeq?: number;
+        increaseTitle?: boolean;
+    }): Promise<SessionId>;
+    /**
+     * 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.
+     */
+    behavior(id: string): FixtureSession;
+    /** Dispose minted scope fibers (runtime dispose path). */
+    disposeScopes(): Promise<void>;
+    private bindingOf;
+    private require;
+}
+//# sourceMappingURL=sessions.d.ts.map

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

@@ -0,0 +1,25 @@
+/** Test double for the client settings-scope seam. */
+import { vi } from 'vitest';
+import type { SettingsScope, SettingsScopeSnapshot } from '@deepseek-ai/dsh-client-runtime/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>;
+    /** @returns how many listeners are currently subscribed (disposal assertions). */
+    listenerCount(): number;
+    /**
+     * Replace part of the snapshot and notify subscribers, as a Host
+     * acceptance would.
+     * @param next - snapshot fields to replace.
+     */
+    publish(next: Partial<SettingsScopeSnapshot<T>>): void;
+}
+/**
+ * Build an in-memory settings scope for service specs: starts in the host
+ * loading state, records writes, and lets the test publish Host acceptances.
+ * @returns the stub handle.
+ */
+export declare function stubSettingsScope<T>(): StubSettingsScope<T>;
+//# sourceMappingURL=settings-scope.d.ts.map

package/lib/types/snapshot.d.ts

@@ -0,0 +1,14 @@
+import type { SnapshotSerializer } from 'vitest';
+/**
+ * The serializer plugin. Matches DOM elements whose subtree carries a scoped
+ * class or svg internals; serializes a normalized clone, which no longer
+ * matches, so printing falls through to the built-in DOM element serializer.
+ */
+export declare const domSnapshotSerializer: SnapshotSerializer;
+/**
+ * Register {@link domSnapshotSerializer} with vitest's expect (idempotent).
+ * SlotTestRuntime.create() calls this; specs that snapshot DOM outside the
+ * runtime import and call it themselves.
+ */
+export declare function registerDomSnapshotSerializer(): void;
+//# sourceMappingURL=snapshot.d.ts.map

package/lib/types/translate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Test double of the locale lookup chain: a translate stub over plain
+ * dictionaries, mirroring LocaleService's resolution order (first dictionary
+ * that owns the key wins, then the key itself stays visible) and its
+ * `{name}` template interpolation. Specs stub the framework-injected `t`
+ * seat with `makeTranslate(zh, commonZh)` instead of re-implementing the
+ * chain per suite.
+ */
+/**
+ * Build a translate stub resolving through `dicts` in order (namespace
+ * first, then the shared common vocabulary), falling back to the key.
+ * @param dicts - dictionaries consulted in order.
+ * @returns the translate function (assignable to any `XxxProps['t']` seat).
+ */
+export declare function makeTranslate(...dicts: readonly Record<string, string>[]): (key: string, params?: Record<string, unknown>) => string;
+//# sourceMappingURL=translate.d.ts.map