@crazx/dsh-client-test-runtime 0.1.5-alpha.1.zw.3

package/lib/types/fixtures.d.ts

@@ -0,0 +1,71 @@
+/** 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
+ * 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>;
+/** 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
+ * 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 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 Session Controller snapshot.
+ * @param sessionId - owning session id.
+ * @returns the snapshot; spread fixture overrides on top.
+ */
+export declare function sessionSnapshot(sessionId: SessionId): SessionSnapshot;
+/**
+ * A target-neutral Conversation snapshot.
+ * @param overrides - target roster or activity overrides.
+ * @returns an immutable fixture value.
+ */
+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

@@ -0,0 +1,212 @@
+/**
+ * jsdom slot test runtime: a real small runtime — Cordis `Context`, the
+ * renderer-owned `SlotRegistry`, the `ui-session` adapter, and the UI renderer — assembled around
+ * test-owned session/workspace doubles and a fail-loud file-upload stub, 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 { SlotRegistry } from '@deepseek-ai/dsh-client-ui-renderer/client';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+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-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 { 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';
+/**
+ * Bind an observable source to the production renderer's selector hook.
+ * @param source - Observable snapshot source.
+ * @returns Typed React selector hook.
+ */
+export declare function bindSnapshotSelector<T>(source: HostObservable<T>): SnapshotSelectorHook<T>;
+/**
+ * Create the production slot renderer used by client feature tests.
+ * @returns Slot renderer instance.
+ */
+export declare function createSlotRenderer(): SlotRenderer;
+/**
+ * One rendered slot's local view, from {@link SlotTestRuntime.renderSlot}:
+ * the renderer's own `[data-slot]` outlet anchor 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 renderer's `<div data-slot="<key>">` anchor 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>;
+}
+/** Mutable fail-loud file-upload stub installed by {@link SlotTestRuntime}. */
+export interface TestFileUpload {
+    /** Availability reported to the feature under test. */
+    available: boolean;
+    /** Test-supplied upload behavior; the default rejects every call. */
+    upload: (sessionId: SessionId, ...args: unknown[]) => Promise<unknown>;
+}
+/**
+ * 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 SlotRegistry.
+     * @param stabilize - the owning runtime's act wrapper.
+     */
+    constructor(slots: SlotRegistry, 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 for owner APIs and explicit test-only services. */
+    readonly ctx: Context;
+    /** The production SlotRegistry mounted on {@link SlotTestRuntime.ctx}. */
+    readonly slots: SlotRegistry;
+    /** 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;
+    /** Mutable file-upload stub; replace `upload` in suites that exercise the capability. */
+    readonly fileUpload: TestFileUpload;
+    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 readonly disposeWorkspaceSource;
+    private constructor();
+    /**
+     * Assemble a runtime: real Context, mounted SlotRegistry, installed
+     * renderer, and the session/workspace doubles provided as services.
+     * @returns the ready runtime.
+     */
+    static create(): Promise<SlotTestRuntime>;
+    /**
+     * 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>;
+    /** 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.
+     * @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 the renderer's own
+     * `<div data-slot="<key>">` outlet anchor (the snapshot root — the frame
+     * adds no wrapper of its own). 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/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/remote.d.ts

@@ -0,0 +1,58 @@
+/** 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 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.
+ *
+ * `$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
+ * this double for the containment guarantee `$on` documents — assert that
+ * against the real service.
+ */
+export declare class TestRemote {
+    private readonly subscriptions;
+    /**
+     * 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, 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.
+     */
+    emit(event: string, args: readonly unknown[]): void;
+    /**
+     * Subscribe to one forwarded host event.
+     * @param event - forwarded host event name.
+     * @param listener - receives the Host argument list verbatim.
+     * @returns disposer removing this subscription.
+     */
+    $on(event: string, listener: (...args: never[]) => void): () => void;
+    /**
+     * Generated-namespace mount, unsupported by this double.
+     * @returns never; always rejects.
+     */
+    $mount(): Promise<() => Promise<void>>;
+}
+//# sourceMappingURL=remote.d.ts.map

package/lib/types/sessions.d.ts

@@ -0,0 +1,276 @@
+/** Test-owned Session Controller faces over declarative fixtures. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AttachmentIdType } from '@deepseek-ai/dsh-attachment';
+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: 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.
+ */
+export declare class FixtureSession implements SessionFace {
+    readonly sessionId: SessionId;
+    private readonly store;
+    /** Mutable event source consumed only by Conversation assembly. */
+    readonly eventSource: MutableSessionEventSource;
+    /**
+     * 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 - Session Controller snapshot store.
+     * @param overrides - fixture-declared behavior face, grafted over the stubs.
+     */
+    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.
+     * @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;
+    /**
+     * 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.
+     * @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 `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;
+}
+/**
+ * Sessions test double behind the renderer host and feature injects: owns the
+ * 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/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>;
+    private readonly records;
+    /** Calls observed on the service-level face, newest last. */
+    readonly calls: {
+        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.
+     */
+    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 Session Controller lifecycle state through an immer draft.
+     * @param id - session id.
+     * @param mutate - draft mutator.
+     */
+    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).
+     * @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 Client Sessions service drives on session death, minus staging.
+     * @param id - session id.
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * 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): SessionBinding | 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;
+    /**
+     * 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
+     * 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>;
+    /** Clear the current selection (recorded; the production no-session flow). */
+    clear(): void;
+    /** History stubs: the test runtime has no selection history — both bounds report empty. */
+    canBack(): boolean;
+    canForward(): boolean;
+    back(): void;
+    forward(): 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.
+     */
+    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 carried by the Controller binding.
+     */
+    behavior(id: string): FixtureSession;
+    /** Dispose minted scope fibers (runtime dispose path). */
+    disposeScopes(): Promise<void>;
+    private bindingOf;
+    private require;
+}
+//# sourceMappingURL=sessions.d.ts.map