@hydraharness/harness-client-runtime 0.0.0-stage → 0.1.1-rc.7

package/lib/types/client/sessions/lineage.d.ts

@@ -0,0 +1,47 @@
+import type { ConversationRevision, SessionVersionState, SessionId, SessionSummary } from '@hydraharness/harness-api-remotes/client';
+import type { SessionProjectionMap } from '@hydraharness/harness-session-projection/types';
+import type { PendingInteractionStatus } from './pending.ts';
+/** Host list summary enriched with the latest mux-projected durable title. */
+export interface TitledSessionSummary extends SessionSummary {
+    title?: string;
+    /** Current host-computed projection values for list consumers. */
+    projectionValues?: Readonly<Partial<SessionProjectionMap>>;
+}
+/** One flattened session-list row with lineage depth and live pending interaction. */
+export interface SessionListEntry {
+    /** Session-local transcript paths and the selected version. */
+    versionState?: SessionVersionState | undefined;
+    sessionId: SessionId;
+    title?: string;
+    updatedAt: number;
+    running: boolean;
+    /** Empty-log bit mirrored from the summary; lists hide blank sessions (filtering stays with the consumer). */
+    blank: boolean;
+    parentSessionId?: SessionId;
+    /** Prompt revision identity retained for conversation navigation. */
+    revision?: ConversationRevision | undefined;
+    /** Coarse durable origin for navigation filtering; not a continuation capability. */
+    origin?: 'subagent';
+    cwd?: string;
+    /** Agent preset the session's agent was composed from (summary passthrough). */
+    agentPreset?: string;
+    /** Current host-computed projection values for list consumers. */
+    projectionValues?: Readonly<Partial<SessionProjectionMap>>;
+    /** User interaction currently blocking this session, derived from live mux frames. */
+    pendingInteraction?: PendingInteractionStatus;
+    /** Finished running while not selected and not yet opened — the sidebar's green "done" reminder (clears on select or the next run). */
+    completed: boolean;
+    /** Lineage indent depth: root = 0; the UI just multiplies by the indent width. */
+    depth: number;
+}
+/**
+ * Summaries -> flat list with lineage indentation. Root and sibling order
+ * follows the established input order; this projection never re-sorts a
+ * hydrated list from mutable timestamps.
+ * @param summaries - the host's session.list items.
+ * @param pendingInteractions - current manager-owned interaction status by session.
+ * @param completed - sessions with a pending completion reminder (manager-owned live fact; absent = false).
+ * @returns display rows in render order.
+ */
+export declare function flattenLineage(summaries: readonly TitledSessionSummary[], pendingInteractions?: ReadonlyMap<SessionId, PendingInteractionStatus>, completed?: ReadonlySet<SessionId>): SessionListEntry[];
+//# sourceMappingURL=lineage.d.ts.map

package/lib/types/client/sessions/manager.d.ts

@@ -0,0 +1,300 @@
+import type { IApiClient, HostFrame, MuxFrame, RpcError, RpcRequest, RpcResult, SessionId, SubagentAddress, SubagentCatalog, JobView, WorkspaceId } from '@hydraharness/harness-api-remotes/client';
+import type { PromptRevisionRequest } from '@hydraharness/harness-host-apiproxy/api';
+import type { ConversationRuntime } from './conversation-assembler.ts';
+import type { SessionListEntry } from './lineage.ts';
+import { Session } from './session.ts';
+import type { SessionRemotes } from './remotes.ts';
+/**
+ * List arrival lifecycle, orthogonal to the pull-activity `state` axis:
+ * `pending` (no successful pull yet — an empty items array means "nothing
+ * arrived", not "nothing exists") → `ready` (at least one pull landed).
+ * Monotone: `ready` never steps back — later pull failures and reconnect
+ * re-pulls ride the `state`/`error` axis, which is where failure is modeled
+ * (no `error` phase here; that would duplicate `state`).
+ */
+export type SessionListPhase = 'pending' | 'ready';
+/** Request-local content hit returned to sidebar search consumers. */
+export interface SessionSearchResultItem {
+    sessionId: SessionId;
+    snippet: string;
+}
+/** Immutable session-list snapshot for useSessionList. */
+export interface SessionListSnapshot {
+    items: readonly SessionListEntry[];
+    /** Selected Session id (validated against items; masked to undefined while its session is off the list). */
+    current: SessionId | undefined;
+    state: 'idle' | 'loading' | 'error';
+    /** Arrival lifecycle (see {@link SessionListPhase}); `state` stays the pull-activity axis. */
+    phase: SessionListPhase;
+    error: RpcError | null;
+    subagentsByParent: Readonly<Record<SessionId, SubagentCatalogSnapshot>>;
+    /** Background jobs per session; an absent key is an empty set. */
+    jobsBySession: Readonly<Record<SessionId, readonly JobView[]>>;
+    currentAddress: SubagentAddress | undefined;
+}
+/** One parent-addressed durable catalog projected through the sessions snapshot. */
+export interface SubagentCatalogSnapshot extends SubagentCatalog {
+    state: 'loading' | 'ready' | 'error';
+    error: RpcError | null;
+}
+/** Instance cluster + frame entry + the session list. */
+export declare class SessionManager {
+    private readonly api;
+    private readonly remote;
+    private readonly conversation?;
+    private readonly sessions;
+    /** Pre-instantiation buffer for answerable requests and the queued-turn snapshot, which history
+     *  cannot reconstruct on open. Live requests remain until resolution; queue and replay duplicates
+     *  compact by identity. Instantiation replays and clears it, while removal drops it. */
+    private readonly pendingBuffers;
+    /** Outstanding answerable interactions per session, keyed by their stable request identity.
+     *  Manager-owned rather than read off Session instances because the sidebar must light up for
+     *  sessions never instantiated. Cleared per connection generation — the reopen replay re-adds
+     *  still-pending requests — and on session-removed. */
+    private readonly pendingInteractions;
+    /**
+     * Sessions that finished running while not selected — the sidebar's green
+     * "done" reminder (manager-owned, survives connection generations; cleared
+     * on select and session-removed, re-armed by the next completion).
+     */
+    private readonly completedNotifications;
+    /** Last-observed running bits per session; the true→false edge here arms {@link completedNotifications}. */
+    private readonly prevRunning;
+    /** Per-session projection value stores, retained independently of instance arrival (the
+     *  title-snapshot precedent, generalized): push frames land here whether or not the Session
+     *  is instantiated (list rows read the 'title' key), and an instantiated Session adopts the
+     *  same store so history-baseline seeding and frames converge on one row set. */
+    private readonly projectionStores;
+    private summaries;
+    private listState;
+    /** Arrival phase; the pending → ready edge fires on the first successful pull (see SessionListPhase). */
+    private listPhase;
+    private listError;
+    private listInflight;
+    /** Mutations arriving after a list request starts are replayed over its response. */
+    private listMutations;
+    private readonly addresses;
+    private readonly catalogs;
+    private readonly catalogInflight;
+    /** Catalog owners whose membership changed while a pull was in flight: one trailing refresh after it settles. */
+    private readonly catalogStale;
+    private readonly openCatalogs;
+    private readonly catalogDebounce;
+    /**
+     * Background jobs per session, last-wins from `session/jobs`. An empty set
+     * is stored as an absent key, so absence and `[]` are one representation.
+     */
+    private readonly jobsBySession;
+    private selected;
+    private listSnapshotCache;
+    /** Entry-identity cache (reference stability): list rebuilds reuse the previous entry
+     *  object when every field matches — wire refreshes mint all-new summary objects, so identity
+     *  must be recovered by value or every SessionListItem memo misses on every refresh. */
+    private entryCache;
+    private itemsCache;
+    private readonly notifier;
+    /**
+     * @param api - shared wire client.
+     * @param restoredSelection - persisted real-Session selection candidate.
+     */
+    constructor(api: IApiClient, remote: SessionRemotes, restoredSelection?: SessionId, restoredAddress?: SubagentAddress, conversation?: ConversationRuntime | undefined);
+    /**
+     * Select a listed Session or a retained catalog-addressed child.
+     * @param sessionId - listed or catalog-addressed Session id.
+     */
+    select(sessionId: SessionId): void;
+    /**
+     * Select a healthy child through its durable direct-parent address.
+     * @param address - catalog-derived parent and child ids.
+     */
+    selectSubagent(address: SubagentAddress): void;
+    /** Clear the selection (the layout falls to the no-session view state). */
+    clearSelection(): void;
+    /**
+     * Return the durable catalog address retained for one child.
+     * @param sessionId - possible addressed child id.
+     * @returns The direct-parent address, when navigation discovered one.
+     */
+    subagentAddress(sessionId: SessionId): SubagentAddress | undefined;
+    /**
+     * Resolve an address for breadcrumb navigation without retaining transport authority.
+     * @param sessionId - possible child id in an already-loaded catalog.
+     * @returns A retained or catalog-derived direct-parent address.
+     */
+    navigationAddress(sessionId: SessionId): SubagentAddress | undefined;
+    /**
+     * Drop a session instance (scope-prune companion: instance
+     * and scope share one lifecycle). The host session log is the durable
+     * truth — a later get() lazily rebuilds and open() backfills history.
+     * @param sessionId - the session to drop.
+     */
+    drop(sessionId: SessionId): void;
+    /**
+     * Lazy build: return the existing instance or construct one (no auto-open —
+     * open is triggered by the container's select callback).
+     * @param sessionId - the session to get.
+     * @returns the resident instance.
+     */
+    get(sessionId: SessionId): Session;
+    private createSession;
+    /** Rebuild every resident Session after one coalesced registry transaction. */
+    rebuildConversationRegistry(): void;
+    /** Resident per-session projection store (create-on-demand; outlives instantiation). */
+    private projectionStore;
+    /**
+     * Refresh one direct-child catalog, reusing its in-flight request.
+     * @param parentSessionId - catalog owner.
+     */
+    refreshSubagents(parentSessionId: SessionId): Promise<void>;
+    /**
+     * Mark whether a catalog menu is consuming live membership updates.
+     * @param parentSessionId - catalog owner.
+     * @param open - current menu state.
+     */
+    setSubagentCatalogOpen(parentSessionId: SessionId, open: boolean): void;
+    /** Full refresh via session.list (single-flight: an in-flight call is reused). */
+    refreshList(): Promise<void>;
+    /**
+     * Search visible session message content without adding transient query
+     * state to the list snapshot.
+     * @param query - non-blank literal phrase.
+     * @param signal - cancellation for superseded UI queries.
+     * @returns the Host result or a folded transport error.
+     */
+    search(query: string, signal: AbortSignal): Promise<RpcResult<{
+        items: SessionSearchResultItem[];
+        hasMore: boolean;
+    }>>;
+    /**
+     * Contract session.create; on success merge into summaries immediately (no
+     * wait for the next refresh). A created session is blank by definition
+     * (entity birth precedes the first message).
+     * @param opts - target workspace or working directory, plus an optional caller-owned id.
+     * @returns the create result.
+     */
+    create(opts?: {
+        workspaceId?: WorkspaceId;
+        cwd?: string;
+        sessionId?: SessionId;
+        reuseWorkspaceBlank?: true;
+    }): Promise<RpcResult<{
+        sessionId: SessionId;
+    }>>;
+    /**
+     * Permanently delete a session and remove it from the local projection.
+     * @param sessionId - session and conversation identity to delete.
+     * @returns the Host result, including every affected session id.
+     */
+    delete(sessionId: SessionId): Promise<RpcResult<{
+        deleted: true;
+        sessionIds: SessionId[];
+    }>>;
+    /**
+     * Contract session.fork; on success merge the child into summaries
+     * immediately (same synchronous-addressability guarantee as create). The
+     * child carries the source's history, so it is never blank; lineage rides
+     * parentSessionId so the list nests it under its source. A child published
+     * before Workspace attachment fails is also reconciled into the list.
+     * @param opts - source session and the optional seq anchoring the cut.
+     * @returns the fork result (the child session id).
+     */
+    fork(opts: {
+        sessionId: SessionId;
+        atSeq?: number;
+        beforeSeq?: number;
+    }): Promise<RpcResult<{
+        sessionId: SessionId;
+    }>>;
+    /**
+     * Admit one immutable edit/retry and publish its Host-confirmed summary.
+     * @param input - Source address and caller-owned idempotency key.
+     * @returns durable generation attempt identity or the original RPC error.
+     */
+    revise(input: PromptRevisionRequest): Promise<RpcResult<{
+        sessionId: SessionId;
+    }>>;
+    /**
+     * View or reference a stored path without creating another Session object.
+     * @param sessionId - Owning session.
+     * @param versionId - Stored path.
+     * @param mode - View or reference operation.
+     * @returns Host acknowledgement and refreshed catalog.
+     */
+    selectVersion(sessionId: SessionId, versionId: import('@hydraharness/harness-session/types').SessionVersionId, mode: 'view' | 'reference'): Promise<void>;
+    /**
+     * Insert-or-enrich a locally synthesized summary: a new id prepends; an
+     * existing entry only gains fields it lacks (the session-added frame and the
+     * create() echo race — whichever lands second must fill the placeholder's
+     * missing cwd/parentSessionId, never overwrite list-refresh data).
+     */
+    private mergeSummary;
+    /**
+     * Record a host-confirmed composition switch (see ISessions.noteAgentPreset).
+     * @param sessionId - the switched session.
+     * @param agentPreset - the preset id the host confirmed.
+     */
+    noteAgentPreset(sessionId: SessionId, agentPreset: string): void;
+    /** Apply immediately and retain for replay when a list response is in flight. */
+    private recordMutation;
+    /**
+     * uSES subscription entry for useSessionList.
+     * @param listener - change callback.
+     * @returns the unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Cached list snapshot (rebuilt lazily when dirty with no listeners).
+     * @returns the cached reference (stable until the next flush).
+     */
+    getListSnapshot(): SessionListSnapshot;
+    /** Add or refresh one stable pending-interaction identity. */
+    private trackPending;
+    /** Settle one pending-interaction identity without disturbing sibling waits. */
+    private resolvePending;
+    /**
+     * Mux frame entry: sessionId-bearing frames go only to instantiated sessions
+     * (no lazy build; non-pending frames for uninstantiated sessions drop —
+     * history backfills them on open).
+     * @param envelope - the frame with its wire rpcId.
+     */
+    handleMuxEnvelope(envelope: RpcRequest<MuxFrame>): void;
+    /**
+     * Host frame entry: list upkeep + per-instance running/removed/agent-error relay.
+     * @param envelope - the frame with its wire rpcId.
+     */
+    handleHostEnvelope(envelope: RpcRequest<HostFrame>): void;
+    private handleHostFrame;
+    /**
+     * The moment a connection generation dies (before any next-generation frame
+     * can arrive — onConnected waits for the readiness handshake while replayed
+     * frames flow from stream open, so clearing there would race the replay):
+     * drop generation-scoped live state. Interactions resolved while disconnected
+     * send no frame, so stale statuses and buffered answerable frames must not
+     * survive into the next generation — mux-open replay re-adds every still-pending
+     * request with its live rpcId.
+    */
+    handleDisconnected(): void;
+    /** After each connection generation: refresh the session baseline and rebuild opened windows. */
+    handleConnected(): void;
+    /** Debounce membership refetches while one parent catalog is selected or open. */
+    private scheduleCatalogRefresh;
+    /** Apply one Agent-driver transition to loaded and in-flight catalogs. */
+    private updateCatalogActivity;
+    /** Preserve and project a positive expandability hint after one direct subagent publishes. */
+    private markCatalogParentExpandable;
+    /** Apply one positive expandability hint to every loaded catalog containing that unique row id. */
+    private applyCatalogParentExpandable;
+    /** Fold request-local row mutations into one catalog result before publication. */
+    private withCatalogMutations;
+    /**
+     * Reconcile completion reminders against the latest summaries, eagerly after
+     * every mutation and pull (a snapshot-build-time pass would collapse
+     * consecutive status frames into one observation). A running→idle edge of a
+     * non-selected session arms its reminder; running disarms it; removal drops
+     * it. First observation only records the running bit — sessions already
+     * idle at load get no reminder.
+     */
+    private syncCompletedNotifications;
+    private buildListSnapshot;
+}
+//# sourceMappingURL=manager.d.ts.map

package/lib/types/client/sessions/notifier.d.ts

@@ -0,0 +1,35 @@
+/** Subscription + batched notification primitive (shared by Session and SessionManager). */
+export declare class Notifier {
+    private readonly rebuild;
+    private listeners;
+    private dirty;
+    private notifyPending;
+    private scheduled;
+    private scheduleGeneration;
+    /** @param rebuild - snapshot rebuild function injected by the owner (writes the owner's snapshotCache). */
+    constructor(rebuild: () => void);
+    /**
+     * uSES subscription entry.
+     * @param listener - change callback.
+     * @returns the unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    /** State-change entry: mark dirty and schedule the batched flush. */
+    markDirty(): void;
+    /** Stream-change entry: mark dirty and publish the cumulative state at most once per frame. */
+    markFrameDirty(): void;
+    /**
+     * Synchronous flush: controlled-input writes must notify in the same tick as
+     * onChange, or React rolls the DOM back to the stale value and the caret jumps to the end.
+     */
+    notifyNow(): void;
+    /**
+     * Pre-getSnapshot check: rebuild synchronously when dirty (read path
+     * before first subscribe / while unobserved). Notification stays pending.
+     */
+    ensureFresh(): void;
+    private schedule;
+    private invalidateSchedule;
+    private flush;
+}
+//# sourceMappingURL=notifier.d.ts.map

package/lib/types/client/sessions/partial.d.ts

@@ -0,0 +1,40 @@
+import type { StreamChunk } from '@hydraharness/harness-llm/types';
+import type { AssistantBlock, PartialAssistant } from './conversation.ts';
+/**
+ * Whether a stream chunk changes the partial assistant projection shown by the UI.
+ * @param type - Stream chunk discriminant.
+ * @returns Whether publishing the accumulated partial can change the visible snapshot.
+ */
+export declare function isVisibleAssistantChunk(type: string): boolean;
+/** assistant/chunk accumulator: folds StreamChunks into AssistantBlock[] with block-level immutability. */
+export declare class PartialAccumulator {
+    readonly turn: number;
+    readonly step: number;
+    private blocks;
+    private changed;
+    private snapshot;
+    /**
+     * @param turn - Owning agent turn.
+     * @param step - Owning model step.
+     * @param initialBlocks - Materialized prefix when accumulation begins after history replay.
+     */
+    constructor(turn: number, step: number, initialBlocks?: readonly AssistantBlock[]);
+    /**
+     * Fold one chunk.
+     * @param chunk - the stream chunk.
+     * @returns whether it caused a visible change (usage/finish return false, skipping notification).
+     */
+    push(chunk: StreamChunk): boolean;
+    /**
+     * Current partial projection.
+     * @returns the cached snapshot (the blocks array reference only changes after a mutation).
+     */
+    toPartial(): PartialAssistant;
+}
+/**
+ * Create the empty client projection for one streamed Assistant block kind.
+ * @param blockType - wire block kind.
+ * @returns empty projected block ready to receive deltas.
+ */
+export declare function emptyAssistantBlock(blockType: string): AssistantBlock;
+//# sourceMappingURL=partial.d.ts.map

package/lib/types/client/sessions/pending.d.ts

@@ -0,0 +1,55 @@
+import type { ClientResponse, MuxFrame, RpcId, RpcReceipt, SessionId } from '@hydraharness/harness-api-remotes/client';
+/** Kind-keyed payload map: the requested frame's domain fields (envelope fields stripped). */
+export interface PendingPayloads {
+    approval: Omit<Extract<MuxFrame, {
+        type: 'approval/requested';
+    }>, 'type' | 'sessionId'>;
+    question: Omit<Extract<MuxFrame, {
+        type: 'question/requested';
+    }>, 'type' | 'sessionId'>;
+}
+/** Pending-interaction discriminant (the keys of PendingPayloads). */
+export type PendingKind = keyof PendingPayloads;
+/** Session-list summary of the user action currently blocking progress. */
+export type PendingInteractionStatus = 'approval' | 'plan-review' | 'question';
+/** Kind-discriminated union of concrete waits: narrowing on `kind` types `payload`. */
+export type PendingInteraction = {
+    [K in PendingKind]: PendingWait<K>;
+}[PendingKind];
+/**
+ * One pending host-owned interaction wait: an immutable render face
+ * (kind/key/sessionId/payload) plus the response carrier. respond() backfills
+ * the requested frame's rpcId into a client-response envelope — no consumer
+ * ever sees the raw rpcId. Settlement is expressed only by pending-list
+ * membership (the settled flag is a fail-loud guard, not a render input).
+ */
+export declare class PendingWait<K extends PendingKind = PendingKind> {
+    #private;
+    /** Interaction kind (union discriminant). */
+    readonly kind: K;
+    /** Opaque render identity, `<prefix>:<rpcId>` — stable across baseline replay, usable as a React key. */
+    readonly key: string;
+    /** Owning session. */
+    readonly sessionId: SessionId;
+    /** The requested frame's domain fields, verbatim. */
+    readonly payload: PendingPayloads[K];
+    /**
+     * Minted by Session on a requested frame (public construction is the test-fixture path).
+     * @param kind - interaction kind.
+     * @param rpcId - the requested frame's stable envelope id (kept private; respond echoes it).
+     * @param sessionId - owning session.
+     * @param payload - the requested frame's domain fields.
+     * @param respond - the client-response carrier (api.respond).
+     */
+    constructor(kind: K, rpcId: RpcId, sessionId: SessionId, payload: PendingPayloads[K], respond: (message: ClientResponse) => Promise<RpcReceipt>);
+    /**
+     * Send a result for this wait: wraps it into the client-response envelope
+     * with the rpcId backfilled. Throws synchronously once settled.
+     * @param result - the result shell (ok value / error envelope), domain-encoded by the caller.
+     * @returns the carrier receipt.
+     */
+    respond(result: ClientResponse['result']): Promise<RpcReceipt>;
+    /** Session-only settlement mark (the authoritative resolved frame arrived); respond() throws afterwards. */
+    markSettled(): void;
+}
+//# sourceMappingURL=pending.d.ts.map

package/lib/types/client/sessions/projection-store.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Generic per-session projection value store (push model; see the
+ * session-projection subsystem page, docs/subsystems/session-projection.md):
+ * the host is the only computation site; the client holds finished
+ * whole values per key — `key → { value, seq }` — seeded by the history tail
+ * page's projections block and updated by `session/projection` push frames,
+ * under the single rule **higher seq wins**. No client-side domain folding
+ * exists: a domain ships projection support with zero client code. Per-key
+ * bare observable faces feed `useProjection` (ui-renderer binds them).
+ */
+import type { SessionProjectionMap } from '@hydraharness/harness-session-projection/types';
+import type { ObservableSnapshot } from '../contract/store.ts';
+export type { SessionProjectionMap } from '@hydraharness/harness-session-projection/types';
+/**
+ * The fifth framework hook seat (see the session-projection subsystem page,
+ * docs/subsystems/session-projection.md): key-addressed
+ * projection reader delivered through the standard kit. `undefined` uniformly
+ * means capability absent — host unit unmounted, or no baseline/frame has
+ * carried the key yet. The selector overload mirrors useSession (per-key uSES
+ * binding; reference stability holds because a key's value reference changes
+ * only when a frame or baseline lands).
+ */
+export type UseProjection = {
+    <K extends Extract<keyof SessionProjectionMap, string>>(key: K): SessionProjectionMap[K] | undefined;
+    <K extends Extract<keyof SessionProjectionMap, string>, S>(key: K, selector: (value: SessionProjectionMap[K] | undefined) => S, eq?: (a: S, b: S) => boolean): S;
+};
+/**
+ * Tail-page projections baseline — structurally identical to the wire's
+ * `SessionProjectionsBlock` (apiproxy api layer), restated here so the
+ * React-free store depends only on the type table, not the wire package's
+ * response vocabulary.
+ */
+export interface ProjectionsBaseline {
+    /** The consistent-cut seq (equals the window tail seq by construction). */
+    asOfSeq: number;
+    /** Whole current values by key; a registered key absent here means the capability is absent. */
+    values: Partial<SessionProjectionMap>;
+}
+/**
+ * One session's projection values. Framework semantics, uniform across every
+ * key: a baseline seeds rows at its cut, a push frame updates one row, and in
+ * both paths a lower-or-equal seq loses — a replayed frame cannot regress a
+ * value, a stale baseline cannot overwrite a newer frame. A key the store has
+ * never seen reads `undefined` (capability absent). Faces are identity-stable
+ * per key (create-on-demand, cached) so the React side binds each exactly
+ * once; the store-level channel (`subscribeAny`) serves coarse consumers (the
+ * manager's list projection reads the `title` key).
+ */
+export declare class ProjectionValueStore {
+    private readonly rows;
+    private readonly channels;
+    private valuesCache;
+    /** Coarse any-key channel (no snapshot cache to rebuild: reads hit rows directly). */
+    private readonly anyNotifier;
+    /**
+     * Key-addressed bare observable face (the useProjection resolution path).
+     * Always defined — absence is an `undefined` snapshot, never a missing
+     * face, so a component may subscribe before the key ever carries a value.
+     * @param key - projection key.
+     * @returns the identity-stable face for this key.
+     */
+    faceOf(key: string): ObservableSnapshot<unknown>;
+    /**
+     * Current whole value for a key (erased framework read; typed reads go
+     * through `useProjection`'s map lookup).
+     * @param key - projection key.
+     * @returns the value, or undefined while the key is absent.
+     */
+    get(key: string): unknown;
+    /**
+     * Read every current projection value as one reference-stable snapshot.
+     * @returns The same frozen value map until a row changes.
+     */
+    values(): Readonly<Partial<SessionProjectionMap>>;
+    /**
+     * Subscribe to any-key changes (microtask-batched) — the manager's list
+     * rebuild channel.
+     * @param listener - change callback.
+     * @returns the unsubscribe function.
+     */
+    subscribeAny(listener: () => void): () => void;
+    /**
+     * Apply one finished value (the `session/projection` push-frame path).
+     * @param key - projection key.
+     * @param value - whole value computed by the host unit.
+     * @param seq - the unit's watermark at emission.
+     */
+    apply(key: string, value: unknown, seq: number): void;
+    /**
+     * Seed from a history tail page's projections block: every carried key
+     * lands under the same seq rule as frames; a key the block omits is
+     * capability-absent as of the cut — its row clears unless a newer frame
+     * already superseded the cut (a stale baseline can neither overwrite nor
+     * clear newer values).
+     * @param baseline - the response's projections block.
+     */
+    seed(baseline: ProjectionsBaseline): void;
+    /**
+     * Drop rows past a mux-generation baseline (`session/subscribed.lastSeq`):
+     * a row claiming knowledge beyond the host's own durable baseline rode
+     * state a restart lost — under last-wins it would wrongly outrank the
+     * host's recomputed (lower-seq) values forever. Durable replay and the next
+     * baseline re-seed whatever truly survived (the title-snapshot precedent,
+     * generalized).
+     * @param lastSeq - the subscribed frame's durable baseline seq.
+     */
+    truncate(lastSeq: number): void;
+    private changed;
+    private channel;
+}
+//# sourceMappingURL=projection-store.d.ts.map

package/lib/types/client/sessions/provide.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The session standard-props provide channel: provider roster, bundle
+ * materialization (fail-loud on undeclared/missing/duplicate members), the
+ * static no-session projection, and the atomic current-session projection
+ * observable. One implementation — SessionRuntime drives it from wire
+ * truth, the test runtime's sessions double drives it from fixtures — so
+ * the materialization rules and the projection semantics cannot drift
+ * between production and the test bench.
+ */
+import type { HostObservable, SessionMaybeProvideInfo, SessionProvideInfo } from '@hydraharness/harness-client-ui-slots';
+import type { SessionBinding, SessionProvideDescriptor } from './service.ts';
+/** The owner-side hooks: how the channel reaches the owner's live bundles and current selection. */
+export interface SessionProvideChannelHost {
+    /**
+     * Re-materialize every already-materialized bundle against the new roster
+     * (call {@link SessionProvideChannel.materializeInfo} per live binding).
+     * Lazily-materialized sessions pick the new roster up on first resolve.
+     */
+    rebuildBundles(): void;
+    /** Resolve the current selection's bundle (the owner's maybe-provide lookup). */
+    resolveCurrent(): SessionMaybeProvideInfo;
+}
+/**
+ * Provider roster + materialization + current projection. The channel owns
+ * every rule a provider contribution must satisfy; owners keep only their
+ * per-session bundle storage and the definition of "current".
+ */
+export declare class SessionProvideChannel {
+    private readonly host;
+    private readonly providers;
+    private maybeInfoCache;
+    /** Latest published current bundle (identity comparison dedupes republish). */
+    private currentSnapshot;
+    /** Projection subscribers (plain cell: bundles hold live session sources, so no store freeze may touch them). */
+    private readonly listeners;
+    /**
+     * Atomic current-session provide projection: selection changes and
+     * provider-roster changes publish through this one source, so a roster
+     * change under a stable current id republishes the bundle instead of
+     * stranding mounted entries.
+     */
+    readonly currentProvideInfo: HostObservable<SessionMaybeProvideInfo>;
+    /**
+     * @param host - owner-side bundle storage and current-selection resolution.
+     */
+    constructor(host: SessionProvideChannelHost);
+    /** The static no-session projection under the current roster (declared names present, values undefined). */
+    get maybeInfo(): SessionMaybeProvideInfo;
+    /**
+     * Register a per-session standard-props provider (see
+     * SessionRuntime.provide for the product contract). Live bundles rebuild
+     * immediately; misdeclared providers fail loud here, at the registration
+     * edge, and the registration rolls back — the channel never stays on a
+     * roster it cannot materialize.
+     * @param descriptor - static member roster plus per-session resolver.
+     * @returns disposer removing the provider.
+     */
+    provide(descriptor: SessionProvideDescriptor): () => void;
+    /**
+     * Re-derive the current selection's bundle and publish it when it changed.
+     * Bundles are identity-stable per (scope, roster) materialization, so an
+     * identity compare is exact; synchronous notify — call sites (the owner's
+     * list subscription, provide()) already sit behind their own batching or
+     * registration edges.
+     */
+    publishCurrent(): void;
+    /**
+     * Materialize the standard-props bundle for one session (fails loud on
+     * undeclared, missing, and duplicate member names).
+     * @param binding - session assembly handle fed to every resolver.
+     * @returns the materialized bundle (identity-stable until the next materialization).
+     */
+    materializeInfo(binding: SessionBinding): SessionProvideInfo;
+    /** Rebuild the static projection and the owner's live bundles, then republish the current one. */
+    private applyRosterChange;
+    /** Build the static no-session kit and reject duplicate declared names. */
+    private materializeMaybeInfo;
+}
+//# sourceMappingURL=provide.d.ts.map