@khorsheed/dsh-room 0.1.0

package/lib/types/client/room-store.js

@@ -0,0 +1,244 @@
+/**
+ * The session the main view shows, read off both host lines: alpha.2 deleted
+ * the list's `current` for the per-row `retainedBy.mainView` reference count;
+ * 0.1.5 carries only `current`.
+ * @param list - the sessions list snapshot.
+ * @returns the main-view session id, or undefined when no session is shown.
+ */
+export function mainSessionId(list) {
+    return Object.values(list.byId).find(summary => (summary.retainedBy?.mainView ?? 0) > 0)?.id
+        ?? list.current;
+}
+/** Poll cadence while the current room has running members. */
+export const ROOM_POLL_INTERVAL_MS = 2_000;
+/**
+ * Debounce coalescing the live-feed refresh: one room journal append usually
+ * arrives inside a burst of session events (the tool call, its result, the
+ * task/task-update edges), so the refresh waits for a quiet beat.
+ */
+export const ROOM_LIVE_REFRESH_DEBOUNCE_MS = 300;
+export class RoomStore {
+    ctx;
+    gateway;
+    room = new Map();
+    states = new Map();
+    listeners = new Set();
+    poller;
+    current;
+    /** The session the live feed is subscribed to (undefined = unattached). */
+    liveAttached;
+    liveUnsubscribe;
+    liveTimer;
+    /**
+     * @param ctx - client root context (the sessions list feed).
+     * @param gateway - the mounted room Remote, undefined when the mount failed.
+     */
+    constructor(ctx, gateway) {
+        this.ctx = ctx;
+        this.gateway = gateway;
+    }
+    /**
+     * Follow the current session: a new current room session gets its first
+     * pull and its live-feed subscription, and polling re-evaluates on every
+     * switch.
+     * @returns disposer (unsubscribe everything + stop polling).
+     */
+    start() {
+        const unsubscribe = this.ctx.sessions.list.subscribe(() => {
+            const current = mainSessionId(this.ctx.sessions.list.getSnapshot());
+            if (current === this.current)
+                return;
+            this.current = current;
+            if (current !== undefined)
+                void this.ensure(current);
+            this.attachLive();
+            this.adjustPolling();
+        });
+        const current = mainSessionId(this.ctx.sessions.list.getSnapshot());
+        if (current !== undefined) {
+            this.current = current;
+            void this.ensure(current);
+            this.attachLive();
+        }
+        return () => {
+            unsubscribe();
+            this.detachLive();
+            this.stopPolling();
+        };
+    }
+    /**
+     * The composer selector's synchronous read.
+     * @param sessionId - session to probe.
+     * @returns cached verdict, or undefined while the first pull is in flight.
+     */
+    isRoomCached(sessionId) {
+        return this.room.get(sessionId);
+    }
+    /**
+     * The cached room state (stable reference between refreshes — safe as a
+     * useSyncExternalStore snapshot).
+     * @param sessionId - room session.
+     * @returns the cached state, or undefined before the first successful pull.
+     */
+    getCached(sessionId) {
+        return this.states.get(sessionId);
+    }
+    /**
+     * Subscribe to cache changes.
+     * @param listener - called after any map mutation.
+     * @returns unsubscribe.
+     */
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    /**
+     * First pull for a session: isRoom, then getState when it is one.
+     * No-ops on a cached verdict.
+     * @param sessionId - session to ensure.
+     */
+    async ensure(sessionId) {
+        if (this.room.has(sessionId) || this.gateway === undefined)
+            return;
+        const carried = await this.gateway.isRoom({ sessionId });
+        if (!carried.ok)
+            return; // A transport failure is not a non-room verdict.
+        if (!carried.value) {
+            this.room.set(sessionId, false);
+            this.notify();
+            return;
+        }
+        await this.refresh(sessionId);
+    }
+    /**
+     * Re-pull the room state (after an own mutation, a live-feed nudge, or a
+     * poll tick).
+     * @param sessionId - room session.
+     */
+    async refresh(sessionId) {
+        if (this.gateway === undefined)
+            return;
+        const carried = await this.gateway.getState({ sessionId });
+        if (!carried.ok || !carried.value.ok)
+            return;
+        const was = this.room.get(sessionId);
+        this.room.set(sessionId, true);
+        this.states.set(sessionId, carried.value.value);
+        this.notify();
+        // A promotion flip (unknown/non-room → room) must re-elect the composer.
+        if (was !== true)
+            this.onPromoted?.();
+        // A completed pull is also the binding-availability retry point: the
+        // runtime may mint the session's binding after the list's current flip.
+        this.attachLive();
+        this.adjustPolling();
+    }
+    /**
+     * Subscribe the CURRENT session's live conversation feed so host-side
+     * journal appends nudge a refresh. The session binding is minted lazily by
+     * the runtime (it can lag the list's current flip), so every completed pull
+     * re-attempts the attach; an unattached store simply keeps its other
+     * triggers until one lands.
+     */
+    attachLive() {
+        if (this.liveAttached === this.current && this.liveUnsubscribe !== undefined)
+            return;
+        this.detachLive();
+        if (this.current === undefined)
+            return;
+        // Optional-call: the ISessions contract always provides binding, but a
+        // test double is allowed to omit it (no live feed in that bench).
+        const binding = this.ctx.sessions.binding?.(this.current);
+        // The session summary no longer notifies for arbitrary journal appends.
+        // Observe the public event window as a refresh signal, without folding it.
+        const face = binding?.eventSource ?? binding?.session;
+        if (face === undefined)
+            return;
+        this.liveUnsubscribe = face.subscribe(() => { this.onLiveEvent(); });
+        this.liveAttached = this.current;
+    }
+    /** Drop the live-feed subscription and any pending debounced refresh. */
+    detachLive() {
+        this.liveUnsubscribe?.();
+        this.liveUnsubscribe = undefined;
+        this.liveAttached = undefined;
+        if (this.liveTimer !== undefined)
+            clearTimeout(this.liveTimer);
+        this.liveTimer = undefined;
+    }
+    /**
+     * One live-feed nudge, debounced so an event burst costs one probe: a known
+     * room refreshes its state; a session cached NOT a room re-probes `isRoom`
+     * (a promotion lands as a host-side `room/created` append the client never
+     * initiated — the room_invite/room_message tools promote in place); a
+     * unknown verdict retries ensure after the same debounce.
+     */
+    onLiveEvent() {
+        if (this.current === undefined)
+            return;
+        if (this.liveTimer !== undefined)
+            clearTimeout(this.liveTimer);
+        this.liveTimer = setTimeout(() => {
+            this.liveTimer = undefined;
+            const current = this.current;
+            if (current === undefined)
+                return;
+            if (this.room.get(current) === true) {
+                void this.refresh(current);
+            }
+            else if (this.room.get(current) === false) {
+                void this.reprobe(current);
+            }
+            else {
+                void this.ensure(current);
+            }
+        }, ROOM_LIVE_REFRESH_DEBOUNCE_MS);
+    }
+    /**
+     * Re-probe a cached-non-room session's verdict: a promotion flips the cache
+     * and pulls the state (the composer takeover follows on the next notify).
+     * @param sessionId - the session whose verdict may have changed.
+     */
+    async reprobe(sessionId) {
+        if (this.gateway === undefined)
+            return;
+        const carried = await this.gateway.isRoom({ sessionId });
+        if (!carried.ok || !carried.value)
+            return;
+        // refresh flips the verdict and fires onPromoted on a unknown/false → true flip.
+        await this.refresh(sessionId);
+    }
+    notify() {
+        for (const listener of [...this.listeners])
+            listener();
+    }
+    /**
+     * Called when a session's verdict flips unknown/false → true (an in-place
+     * promotion): the composer chain elects at RENDER time and nothing
+     * re-renders the outlet for a promotion of an idle session, so the client
+     * wires this to re-register the composer entry (a slot version bump
+     * re-renders — and re-elects — the outlet).
+     */
+    onPromoted;
+    adjustPolling() {
+        const running = this.current !== undefined
+            && this.room.get(this.current) === true
+            && (this.states.get(this.current)?.runs.some(entry => entry.state === 'running') ?? false);
+        if (running && this.poller === undefined) {
+            this.poller = setInterval(() => {
+                if (this.current !== undefined)
+                    void this.refresh(this.current);
+            }, ROOM_POLL_INTERVAL_MS);
+        }
+        else if (!running) {
+            this.stopPolling();
+        }
+    }
+    stopPolling() {
+        if (this.poller !== undefined)
+            clearInterval(this.poller);
+        this.poller = undefined;
+    }
+}

package/lib/types/client/slots.d.ts

@@ -0,0 +1,319 @@
+/**
+ * Slot-facing types of the room client half: the injected action faces and
+ * the composed props of its slot entries.
+ */
+import type { LocalAgentUi } from '@khorsheed/dsh-local-agent/client';
+import type { ReactNode } from 'react';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+import type { RoomProviderList } from '../types.ts';
+import type { LocalAgentModelInfo, LocalAgentPromptResult } from '@khorsheed/dsh-local-agent/types';
+import type { RoomChromeVisibility } from './preset-visibility.ts';
+import type { RoomStore } from './room-store.ts';
+/** A mutation outcome with a localized failure message. */
+export type RoomMutationOutcome = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/** Injected action face of the session-header 邀请 agent action. */
+export type InviteAgentInjected = RoomInviteInjected;
+/** Full props of the 'conversation.session.header.actions' entry. */
+export type InviteAgentActionProps = PropsRuntime<'conversation.session.header.actions'> & InjectFace<InviteAgentInjected> & PropsLocale<'room'>;
+/** Injected face of the dock capsules (goal capsule + task capsule). */
+export interface RoomTasksInjected {
+    /** The client-side room state store (tasks and the goal ride the replayed state). */
+    readonly roomStore: RoomStore;
+    /** Add a pending task to a member's lane, optionally waiting on another member. */
+    readonly addTask: (member: string, title: string, blockedBy?: string) => Promise<RoomMutationOutcome>;
+    /**
+     * Close an open task. The status is the closing state: 'done' by default;
+     * the failed row's [关闭] passes 'cancelled' — the failure already speaks
+     * for itself, and a failed task must not count as goal progress.
+     */
+    readonly closeTask: (taskId: string, status?: 'done' | 'cancelled') => Promise<RoomMutationOutcome>;
+    /** Set (or, with a blank text, clear) the room's goal. */
+    readonly setGoal: (text: string) => Promise<RoomMutationOutcome>;
+}
+/**
+ * The invite dialog's injected share (sessionId binds at inject time). The
+ * three dialog hosts — the members tab, the session-header 邀请 agent action,
+ * and the fresh-room dock's invite capsule — take exactly this face; none
+ * inherits another's surface actions.
+ */
+export interface RoomInviteInjected {
+    readonly renderHarnessModelPicker?: LocalAgentUi['renderHarnessModelPicker'] | undefined;
+    /** The room session's own cwd (the invite dialog's empty-cwd placeholder). */
+    readonly roomCwd?: string | undefined;
+    /** Invite a CLI member. */
+    readonly invite: (values: RoomInviteValues) => Promise<RoomInviteOutcome>;
+    /** List the invitable providers (undefined on transport failure). */
+    readonly listProviders: () => Promise<RoomProviderList | undefined>;
+    /**
+     * Pick a member-level working directory through the official picker call
+     * (`uiWorkspace.pickDirectory` on host 0.1.2 — the picker UI itself is not
+     * reusable: ui-workspace's flow holes adopt the pick as a workspace).
+     * Resolves null on cancel or when the host serves no native
+     * directory-picking capability.
+     */
+    readonly browseDirectory: () => Promise<string | null>;
+    /**
+     * The roster's current names, read from the store cache at call time (the
+     * invite dialog's name dice never rolls one of these). Empty on a cache
+     * miss — the host's duplicate check stays the backstop.
+     */
+    readonly listNames: () => readonly string[];
+    /**
+     * The pickable model surface of one harness (the localAgentGateway
+     * `harnessModel` read), feeding the invite dialog's model row: choices for
+     * the menu, the effective default the unset field displays. Undefined = no
+     * surface (a composition without the local-agent family's client half, or a
+     * brokerless harness): the field stays a plain text input, blank following
+     * the harness default.
+     */
+    readonly modelSurface: (harness: string) => Promise<LocalAgentModelInfo | undefined>;
+    /**
+     * The preset-composition visibility of room's session chrome (M3'
+     * self-hide): the invite chip returns null when this says no, and the
+     * members tab's registration toggle reads it. Every unreadable path fails
+     * open, and an actual room always shows.
+     */
+    readonly roomChrome: RoomChromeVisibility;
+}
+/**
+ * The main agent's durable per-session model selection (the host's
+ * session-controller vocabulary, duck-typed so room never imports
+ * ui-model-selection — the service is probed through `ctx.get`).
+ */
+export interface RoomModelSelection {
+    readonly provider: string;
+    readonly model: string;
+    readonly reasoningEffort?: string;
+}
+/** One adapter-owned reasoning effort of an exact model route. */
+export interface RoomModelEffort {
+    readonly id: string;
+    readonly name: string;
+}
+/** One catalog model inside its provider group. */
+export interface RoomCatalogModel {
+    readonly id: string;
+    readonly name: string;
+    readonly reasoning?: {
+        readonly efforts: readonly RoomModelEffort[];
+        readonly defaultEffort?: string;
+    };
+}
+/** One provider and its successfully loaded model catalog. */
+export interface RoomModelGroup {
+    readonly id: string;
+    readonly name: string;
+    readonly models: readonly RoomCatalogModel[];
+}
+/** The directory snapshot the room's main-agent model picker renders from. */
+export interface RoomModelDirectoryState {
+    /** Effective selection: the durable next-request projection, then the host default. */
+    readonly current: RoomModelSelection | null;
+    /** Successfully loaded provider groups (last good load). */
+    readonly groups: readonly RoomModelGroup[];
+    /** Lifecycle of the in-flight operation. */
+    readonly status: 'idle' | 'loading' | 'ready' | 'selecting' | 'error';
+    /** Whole-request or selection failure text; null when none. */
+    readonly error: string | null;
+}
+/**
+ * The duck-typed slice of ui-model-selection's per-session ModelDirectory
+ * (`ctx.modelDirectories.directoryFor(sessionId)`) the composer's main-agent
+ * model picker consumes — the SAME directory the official composer seat
+ * (`conversation.input.model`) renders, so a switch here is exactly the
+ * official seat's switch: `select()` writes the durable per-session selection
+ * through the session controller's selectModel remote and the shared store
+ * notifies every reader. Absent service = no picker (degrade, never throw).
+ */
+export interface RoomModelDirectory {
+    /** The shared snapshot store (useSyncExternalStore-safe). */
+    readonly store: {
+        readonly subscribe: (listener: () => void) => () => void;
+        readonly getSnapshot: () => RoomModelDirectoryState;
+    };
+    /** Ensure the shared advisory catalog is loaded (errors land on the store). */
+    readonly load: () => Promise<unknown>;
+    /**
+     * Select the complete provider/model/reasoning selection. 0.1.5 rejects on
+     * a refused switch; alpha.2 never rejects and answers the RemoteResult
+     * instead — a settled object carrying `ok` reports the outcome there, any
+     * other resolution reads as success.
+     */
+    readonly select: (selection: RoomModelSelection) => Promise<unknown>;
+}
+/**
+ * Injected face of the composer takeover entry: the dispatch submit plus the
+ * task-board actions (sessionId binds at inject time), because the takeover
+ * renders the task board itself — the `conversation.input.dock` seat rides
+ * the hidden official fallback. The takeover also inherits the official bar's
+ * Stop duty: the fallback's Stop button hides with it, so `stop` re-homes the
+ * main agent's turn cancel (the runtime session face's `cancel()`). The
+ * invite share rides along for the fresh-room dock's invite capsule.
+ * `modelDirectory` is the official per-session model directory for the room's
+ * own main agent (bare messages ARE its turns); undefined on a host without
+ * ui-model-selection — the picker simply does not render.
+ */
+export interface RoomComposerInjected extends RoomTasksInjected, RoomInviteInjected {
+    readonly reconcileDelivery?: ((deliveryId: string, outcome: 'done' | 'cancelled', evidence: string) => Promise<RoomMutationOutcome>) | undefined;
+    readonly planCommand?: ((command: string) => Promise<RoomMutationOutcome>) | undefined;
+    readonly openPlanSession?: ((sessionId: string) => void) | undefined;
+    readonly renderMemberInbox?: LocalAgentUi['renderMemberInbox'] | undefined;
+    readonly renderMemberConfiguration?: LocalAgentUi['renderMemberConfiguration'] | undefined;
+    readonly stopMember?: ((name: string) => void) | undefined;
+    /**
+     * Dispatch an @-message into the room and refresh the store on success.
+     * Bare messages never reach here — the composer releases them to the
+     * official submit path (useInput/inputActions) itself. `targets` carries
+     * the mention-menu picks (explicit addressing wherever the `@name` sits in
+     * the sentence); the host unions them with the parsed leading tokens.
+     */
+    readonly submit: (sessionId: SessionId, text: string, targets?: readonly string[]) => Promise<RoomMutationOutcome>;
+    /** Interrupt the room's own main-agent turn (the hidden official bar's Stop). */
+    readonly stop: () => void;
+    /**
+     * The official per-session model directory of the room's main agent (the
+     * session's root agent). The picker writes the SESSION selection only — an
+     * @-addressed member dispatch rides room's own submit remote and is never
+     * touched by it. undefined = host without ui-model-selection: no picker.
+     */
+    readonly modelDirectory?: RoomModelDirectory | undefined;
+}
+/** The composer takeover match: the session is a cached room. */
+export interface RoomComposerMatch {
+    readonly room: true;
+}
+/** Full props of the 'conversation.composer' chain entry. */
+export type RoomComposerProps = PropsRuntime<'conversation.composer'> & {
+    matched: RoomComposerMatch;
+} & InjectFace<RoomComposerInjected> & PropsLocale<'room'>;
+/** Full props of the 'conversation.view' members-tab entry. */
+export type MembersViewProps = PropsRuntime<'conversation.view'> & InjectFace<RoomMembersInjected> & PropsLocale<'room'>;
+/** The invite form's values (sessionId binds at inject time). */
+export interface RoomInviteValues {
+    readonly provider: string;
+    readonly name: string;
+    readonly instructions?: string;
+    /** Member-level working directory (omitted = inherits the room session's cwd). */
+    readonly cwd?: string;
+    readonly firstTask?: string;
+    /** The delegation's invite-time model (omitted = follow the harness default). */
+    readonly model?: string;
+}
+/** The invite outcome: the receipt's pendingFirstTask picks the success copy. */
+export type RoomInviteOutcome = {
+    readonly ok: true;
+    readonly pendingFirstTask: boolean;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/** Injected face of the members tab. */
+export interface RoomMembersInjected extends RoomInviteInjected {
+    readonly renderMemberConfiguration?: ((childSessionId: string) => ReactNode) | undefined;
+    /** The client-side room state store (roster + runs). */
+    readonly roomStore: RoomStore;
+    /** Open a session (the member's child-session trajectory jump). */
+    readonly openSession: (sessionId: SessionId) => void;
+    /** Remove the named member from the roster. */
+    readonly setCoordinator?: ((memberId: string, expectedRevision: number) => Promise<RoomMutationOutcome>) | undefined;
+    readonly removeMember: (member: string) => Promise<RoomMutationOutcome>;
+    /**
+     * Edit the named member: rename, cwd override (null clears back to
+     * inheriting the room cwd), role instructions (null clears them), intended
+     * model (null clears it back to the harness default). Only the present
+     * fields change.
+     */
+    readonly updateMember: (member: string, patch: RoomMemberPatch) => Promise<RoomMutationOutcome>;
+    /**
+     * A CLI member's model surface (the localAgentGateway `memberModel` read,
+     * duck-typed): null = no broker (no model hint, pre-broker behavior),
+     * undefined = gateway absent or RPC failure. Absent = no model hints at all.
+     */
+    readonly memberModel?: ((childSessionId: string) => Promise<LocalAgentModelInfo | null | undefined>) | undefined;
+    /**
+     * Switch (undefined = clear the override → follow settings) a live member's
+     * session-level model (the localAgentGateway `setMemberModel` write): the
+     * edit dialog's immediate-effect half; its structured refusal (a round in
+     * flight) rides the dialog's error line. undefined = RPC failure (the
+     * journaled persist still proceeds).
+     */
+    readonly setMemberModel?: ((childSessionId: string, model?: string) => Promise<LocalAgentPromptResult | undefined>) | undefined;
+    /**
+     * The room session's official model directory (the same instance
+     * RoomModelPicker renders): the main-agent card's model hint. undefined =
+     * host without ui-model-selection.
+     */
+    readonly modelDirectory?: RoomModelDirectory | undefined;
+}
+/** One member edit (every field optional; null clears the field). */
+export interface RoomMemberPatch {
+    /** New @-addressing name (unique, no whitespace, no "@"). */
+    readonly rename?: string;
+    /** New role instructions; null clears them. */
+    readonly instructions?: string | null;
+    /** New cwd override; null clears back to inheriting the room cwd. */
+    readonly cwd?: string | null;
+    /** New intended model; null clears back to the harness default. */
+    readonly model?: string | null;
+}
+/** Injected face of the member-speech chat node. */
+export interface RoomSpeechInjected {
+    /** The client-side room state store (provider/kind lookup for the identity row). */
+    readonly roomStore: RoomStore;
+    /** Open a session (the speech's child-session jump). */
+    readonly openSession: (sessionId: SessionId) => void;
+}
+/** Full props of the 'room-speech' chat-node renderer. */
+export type RoomSpeechViewProps = PropsRuntime<'conversation.chat.node', 'room-speech'> & InjectFace<RoomSpeechInjected> & PropsLocale<'room'>;
+/** Injected face of the member-run chat node. */
+export interface RoomRunInjected {
+    readonly renderMemberOutput?: LocalAgentUi['renderMemberOutput'] | undefined;
+    /** The client-side room state store (the roster carries the jump target). */
+    readonly roomStore: RoomStore;
+    /** Open a session (the whole-row jump into the member's child session). */
+    readonly openSession: (sessionId: SessionId) => void;
+    /** Cancel the named member's in-flight run through the Remote. */
+    readonly cancelMember: (member: string) => Promise<void>;
+}
+/** Full props of the 'room-run' chat-node renderer. */
+export type RoomRunViewProps = PropsRuntime<'conversation.chat.node', 'room-run'> & InjectFace<RoomRunInjected> & PropsLocale<'room'>;
+/** Full props of the 'room-event' chat-node renderer. */
+export type RoomEventViewProps = PropsRuntime<'conversation.chat.node', 'room-event'> & PropsLocale<'room'>;
+/** Injected face of the relay (member notification) chat node. */
+export interface RoomRelayInjected {
+    /** The client-side room state store (member colors come from the roster order). */
+    readonly roomStore: RoomStore;
+    /** Confirm a pending relay (dispatches the notification to the recipient). */
+    readonly confirmRelay: (relayId: string) => Promise<void>;
+    /** Dismiss a pending relay (the notification never reaches anyone). */
+    readonly dismissRelay: (relayId: string) => Promise<void>;
+}
+/** Full props of the 'room-relay' chat-node renderer. */
+export type RoomRelayViewProps = PropsRuntime<'conversation.chat.node', 'room-relay'> & InjectFace<RoomRelayInjected> & PropsLocale<'room'>;
+/** Injected face of the task-advance chat node. */
+export interface RoomTaskLineInjected {
+    /** The client-side room state store (the goal-progress suffix). */
+    readonly roomStore: RoomStore;
+}
+/** Full props of the 'room-task-line' chat-node renderer. */
+export type RoomTaskLineViewProps = PropsRuntime<'conversation.chat.node', 'room-task-line'> & InjectFace<RoomTaskLineInjected> & PropsLocale<'room'>;
+/**
+ * Props of the dock capsules (goal capsule + task capsule), rendered by the
+ * RoomComposer itself above the input card — NOT a slot entry:
+ * `conversation.input.dock` lives inside the official composer fallback,
+ * which the takeover hides. The invite share serves the fresh-room state:
+ * a room with neither a goal nor any task renders a single 「＋ 邀请成员」
+ * capsule instead of the pair, opening the invite dialog straight from the
+ * dock.
+ */
+export type RoomDockCapsulesProps = {
+    readonly sessionId: SessionId;
+    readonly formalPlans?: boolean;
+} & RoomTasksInjected & RoomInviteInjected & PropsLocale<'room'>;
+//# sourceMappingURL=slots.d.ts.map

package/lib/types/client/slots.js

@@ -0,0 +1 @@
+export {};

package/lib/types/deliveries.d.ts

@@ -0,0 +1,5 @@
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types';
+import type { RoomDelivery } from './types.ts';
+/** Accepted delivery intents and their latest durable outcomes. */
+export declare function replayDeliveries(events: readonly SessionEvent[]): RoomDelivery[];
+//# sourceMappingURL=deliveries.d.ts.map

package/lib/types/deliveries.js

@@ -0,0 +1,20 @@
+/** Accepted delivery intents and their latest durable outcomes. */
+export function replayDeliveries(events) {
+    const rows = new Map();
+    for (const event of events) {
+        if (event.type === 'room/dispatch' && event.data.targetIds !== undefined) {
+            for (const memberId of event.data.targetIds) {
+                const id = `${event.seq}:${memberId}`;
+                if (!rows.has(id))
+                    rows.set(id, { id, dispatchSeq: event.seq, memberId, status: 'queued', text: event.data.text, origin: event.data.origin ?? 'human', ...event.data.plan === undefined ? {} : { plan: event.data.plan } });
+            }
+        }
+        else if (event.type === 'room/delivery-state') {
+            const row = rows.get(event.data.id);
+            if (row === undefined || row.memberId !== event.data.memberId || row.dispatchSeq !== event.data.dispatchSeq)
+                continue;
+            rows.set(row.id, { ...row, status: event.data.state, ...event.data.error === undefined ? {} : { error: event.data.error } });
+        }
+    }
+    return [...rows.values()];
+}