@sevenfold/setto-client 0.27.0 → 0.28.1

package/dist/modules/chat/SettoChat.d.ts

@@ -7,6 +7,8 @@ type Message = {
     id?: string;
     role: 'visitor' | 'assistant' | 'human' | 'system';
     content: string;
+    /** Server insert time; absent on local optimistic and streaming turns. */
+    created_at?: string;
     reveal?: boolean;
     avatarUrl?: string | null;
     authorName?: string | null;
@@ -20,9 +22,23 @@ type Message = {
 export declare function nextWordBoundary(content: string, visibleLength: number): number;
 export declare function sineOut(progress: number): number;
 export declare function isAtChatBottom(scrollHeight: number, scrollTop: number, clientHeight: number): boolean;
+export declare function chatComposerSpace(height: number): number;
 export declare function AgentJoinedEvent({ message }: {
     message: Message;
 }): import("react/jsx-runtime").JSX.Element;
+/**
+ * A teammate is composing. The row opts out of the transcript's polite live
+ * region so start/stop bursts are not announced, while its label stays
+ * readable when a screen-reader user browses the log.
+ */
+export declare function TeamTypingRow({ label, avatarUrl }: {
+    label: string;
+    avatarUrl: string | null;
+}): import("react/jsx-runtime").JSX.Element;
+/** "Sett"/"Seen" under the visitor's latest message; not announced live. */
+export declare function SeenMarker({ label }: {
+    label: string;
+}): import("react/jsx-runtime").JSX.Element;
 export declare function SiteChatMarkdown({ content, reveal }: {
     content: string;
     reveal?: boolean;

package/dist/modules/chat/realtime.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Pure decisions behind the visitor widget's Realtime doorbell, typing
+ * indicators and read markers. Realtime carries no chat data: every event only
+ * prompts the widget to refetch through the visitor-bound HTTP API, so these
+ * helpers never see message text, names or ids in a payload.
+ */
+/** Fallback poll while no Realtime channel is subscribed (today's cadence). */
+export declare const POLL_FALLBACK_MS = 5000;
+/** Slow safety poll while the conversation channel is subscribed. */
+export declare const POLL_SUBSCRIBED_MS = 30000;
+/** Bursts of `changed` events collapse into one refetch. */
+export declare const CHANGED_DEBOUNCE_MS = 250;
+/** A visitor sends `typing: true` at most this often while composing. */
+export declare const TYPING_THROTTLE_MS = 2500;
+/** A team typing row disappears this long after the last `typing: true`. */
+export declare const TYPING_EXPIRY_MS = 6000;
+export type ChatSide = 'team' | 'visitor';
+export type TypingSignal = {
+    side: ChatSide;
+    typing: boolean;
+};
+export type ReadSignal = {
+    side: ChatSide;
+    at: string;
+};
+/** The subset of a transcript message these decisions read. */
+export type TimelineMessage = {
+    id?: string;
+    role: string;
+    kind?: string;
+    created_at?: string;
+    authorName?: string | null;
+    avatarUrl?: string | null;
+};
+export declare function pollIntervalMs(subscribed: boolean): number;
+/** Only a server-issued conversation topic is joined; clients never build one. */
+export declare function conversationTopic(value: unknown): string | null;
+export declare function parseTypingSignal(payload: unknown): TypingSignal | null;
+export declare function parseReadSignal(payload: unknown): ReadSignal | null;
+/**
+ * Epoch milliseconds with sub-millisecond precision. Postgres returns
+ * microseconds (`…:05.123456+00:00`), which engines may truncate or reject, so
+ * the fraction is added separately and a missing zone is read as UTC.
+ */
+export declare function timestampValue(value: string | null | undefined): number | null;
+/** Monotonic merge: keep whichever valid timestamp is later. */
+export declare function laterTimestamp(current: string | null, next: string | null | undefined): string | null;
+export type TypingSender = {
+    /** Call on every draft change. */
+    update(draft: string): void;
+    /** Draft emptied, message sent, composer blurred or channel leaving. */
+    stop(): void;
+    /** Forget local state without sending (the channel is gone). */
+    reset(): void;
+};
+/**
+ * Throttles visitor typing signals. `send` returns false when the channel is
+ * not subscribed, in which case nothing is considered sent.
+ */
+export declare function createTypingSender(send: (typing: boolean) => boolean, now?: () => number): TypingSender;
+/** The widget shows only team typing; returns the new expiry deadline. */
+export declare function nextTeamTypingDeadline(current: number | null, signal: TypingSignal, now: number): number | null;
+/** Identity of the newest human reply, used to hide typing once it lands. */
+export declare function latestHumanMessageKey(messages: readonly TimelineMessage[]): string | null;
+/** First name and photo of the latest teammate who replied or joined. */
+export declare function teamTypingIdentity(messages: readonly TimelineMessage[]): {
+    name: string | null;
+    avatarUrl: string | null;
+};
+export declare function teamTypingLabel(norwegian: boolean, name: string | null): string;
+/**
+ * Index of the visitor message that carries "Sett"/"Seen", or -1. Only the
+ * latest visitor message qualifies, and only once it has a server timestamp
+ * that a teammate's read receipt has reached.
+ */
+export declare function seenVisitorMessageIndex(messages: readonly TimelineMessage[], humanJoined: boolean, teamReadAt: string | null): number;
+export type ReadMarkerContext = {
+    humanJoined: boolean;
+    chatOpen: boolean;
+    pageVisible: boolean;
+    /** The latest `through` already sent or in flight for this conversation. */
+    lastSent: string | null;
+};
+/**
+ * The `through` value to POST as the visitor's read marker, or null when no
+ * marker should be sent: no human has joined, the chat is closed or hidden, or
+ * nothing newer than the last marker has arrived from Barista or the team.
+ */
+export declare function readMarkerThrough(messages: readonly TimelineMessage[], context: ReadMarkerContext): string | null;
+export type RefreshTicket = {
+    conversationId: string | null;
+    /** Increments whenever a visitor turn starts. */
+    turn: number;
+    /** Increments whenever a newer refetch or conversation load starts. */
+    request: number;
+};
+/**
+ * What to do with a conversation refetch when it resolves. A response that
+ * lands during (or overlapped) a visitor turn would replace the locally
+ * streaming answer, so it is deferred and re-requested once the turn ends.
+ */
+export declare function refreshOutcome(started: RefreshTicket, current: RefreshTicket & {
+    busy: boolean;
+}): 'apply' | 'defer' | 'drop';