@stapel/chat-react 0.1.0

package/src/model/readMarker.ts

@@ -0,0 +1,32 @@
+/**
+ * The read marker, and the one rule that governs it: it only ever moves
+ * forward.
+ *
+ * The server already enforces that (`services.mark_read` never lowers
+ * `last_read_seq`), so a client that sends a smaller value is not corrupting
+ * anything — it is spending a request to be ignored, and, worse, telling the
+ * UI a story that the next list refresh will contradict. The guard is here so
+ * the client's own belief matches the server's.
+ *
+ * WHY THE CLIENT HAS TO REMEMBER AT ALL. `ConversationResponse.participants[]`
+ * carries `last_read_seq` — for every participant, with no marker for which
+ * one is the caller (the response has no "me"). `unread_count` is the only
+ * caller-relative number the endpoint returns. So the highest marker THIS
+ * client has reported cannot be read back off the wire; it is remembered in
+ * the query cache (`chatQueryKeys.readMarker`), which the session layer wipes
+ * at logout along with everything else.
+ */
+
+/**
+ * The value to send, or `null` for "already reported — send nothing".
+ *
+ * `candidate` of 0 (an empty thread) is never sent: there is no such seq.
+ */
+export function nextReadMarker(
+  known: number | undefined,
+  candidate: number
+): number | null {
+  if (!Number.isFinite(candidate) || candidate <= 0) return null;
+  if (known !== undefined && candidate <= known) return null;
+  return candidate;
+}

package/src/model/runtime.ts

@@ -0,0 +1,90 @@
+import { createModuleRuntime } from "@stapel/core";
+import type { CreateModuleRuntimeOptions, ModuleRuntime } from "@stapel/core";
+import { createChatApi } from "../api/chatApi.js";
+import type { ChatApi } from "../api/chatApi.js";
+import { canOpenWebSocket } from "../realtime/chatSocket.js";
+import type {
+  ChatReconnectOptions,
+  ChatWebSocketFactory,
+} from "../realtime/chatSocket.js";
+import { deriveChatSocketBase } from "../realtime/streams.js";
+
+/**
+ * Host-side realtime configuration. Every field is optional and every default
+ * degrades to polling rather than to a broken socket — a host that says
+ * nothing gets the right behaviour on a WSGI deployment (no sockets at all)
+ * and on an ASGI one (sockets, if the origin can be resolved).
+ */
+export interface ChatRealtimeOptions {
+  /**
+   * Where this deployment mounts `stapel_chat.routing.websocket_urlpatterns`,
+   * e.g. `wss://shop.example/ws/chat/`. Omit to derive it from `baseUrl`
+   * (the canonical `/ws/chat/` at the API's own origin). Pass `null` to turn
+   * the socket transport OFF explicitly — a host that knows its backend runs
+   * under WSGI says so here instead of letting every tab fail a handshake
+   * six times first.
+   */
+  readonly socketUrl?: string | null;
+  /** Injectable socket transport (tests, instrumentation, React Native). */
+  readonly webSocket?: ChatWebSocketFactory;
+  /** Reconnect backoff knobs. */
+  readonly reconnect?: ChatReconnectOptions;
+  /**
+   * Origin used to resolve a relative `baseUrl`. Defaults to the browser's
+   * own; irrelevant when `baseUrl` is absolute.
+   */
+  readonly origin?: string | null;
+}
+
+/** The realtime configuration as the transport seam reads it. */
+export interface ChatRealtimeConfig {
+  /** `null` — this build will not open sockets; the seam polls. */
+  readonly socketBase: string | null;
+  readonly webSocket: ChatWebSocketFactory | undefined;
+  readonly reconnect: ChatReconnectOptions | undefined;
+}
+
+/**
+ * The wired chat runtime — core's `ModuleRuntime` bound to this pair's API,
+ * PLUS the one thing chat has and a plain REST pair does not: where its
+ * socket lives. The socket URL is runtime configuration, not module state, so
+ * it rides here rather than through a second provider.
+ */
+export type ChatRuntime = ModuleRuntime<ChatApi> & {
+  readonly realtime: ChatRealtimeConfig;
+};
+
+export interface CreateChatRuntimeOptions extends CreateModuleRuntimeOptions {
+  readonly realtime?: ChatRealtimeOptions;
+}
+
+function currentOrigin(): string | null {
+  return typeof location !== "undefined" ? location.origin : null;
+}
+
+function resolveRealtime(
+  baseUrl: string,
+  options: ChatRealtimeOptions | undefined
+): ChatRealtimeConfig {
+  const explicit = options?.socketUrl;
+  const socketBase =
+    explicit === null
+      ? null
+      : explicit !== undefined
+        ? explicit
+        : canOpenWebSocket()
+          ? deriveChatSocketBase(baseUrl, options?.origin ?? currentOrigin())
+          : null;
+  return {
+    socketBase,
+    webSocket: options?.webSocket,
+    reconnect: options?.reconnect,
+  };
+}
+
+export function createChatRuntime(
+  options: CreateChatRuntimeOptions
+): ChatRuntime {
+  const runtime = createModuleRuntime(createChatApi, options);
+  return { ...runtime, realtime: resolveRealtime(options.baseUrl, options.realtime) };
+}

package/src/model/threadWindow.ts

@@ -0,0 +1,173 @@
+/**
+ * The thread store: a merged, `seq`-ordered window over a conversation, and
+ * the four pure functions that move it.
+ *
+ * WHY A WINDOW AND NOT A PAGE LIST. A chat thread grows at BOTH ends: older
+ * history is paged backwards on scroll, new messages arrive at the tip while
+ * the reader is looking at it. TanStack's bidirectional infinite query cannot
+ * express the second half — `getPreviousPageParam` is answered from the page
+ * the server sent, and at the tip the server correctly says "no previous
+ * page", which would freeze the tail forever. So the thread is ONE cache
+ * entry holding a contiguous run of messages, and the two directions are two
+ * merges into it.
+ *
+ * THE ORDERING RULE IS THE BACKEND'S, NOT OURS. `seq` is a gapless, total
+ * per-conversation order (`stapel-chat/MODULE.md`: "seq is gapless and total
+ * — the canonical anchor for history and the resume cursor for realtime"), and
+ * ordering by timestamp is an explicit anti-pattern there: two messages in the
+ * same millisecond still have a definite order. Everything below therefore
+ * sorts, dedupes and detects gaps by `seq` alone.
+ *
+ * ONE MORE THING THE PAGINATOR MAKES US DO. Item order depends on the
+ * DIRECTION asked for: core's `AnchorPagination` returns newest-first for
+ * `next` and reverses to oldest-first for `prev` (`pagination.py`,
+ * `items[::-1]`). Rather than remember which call produced which order, every
+ * merge sorts by `seq` — the total order is cheaper to apply than to
+ * remember.
+ */
+import type { ChatMessage, MessagePage } from "../api/types.js";
+
+/**
+ * A contiguous run of messages, ascending by `seq`.
+ *
+ * "Contiguous" is load-bearing: because `seq` is gapless, a window whose seqs
+ * are consecutive integers provably has no hole in it. Every merge below
+ * either preserves that or refuses the merge and reports a gap — it never
+ * quietly stitches two runs with a hole between them, which is the defect
+ * that makes a chat show yesterday's message under today's.
+ */
+export interface ChatThreadWindow {
+  /** Ascending by `seq`, no duplicates, no holes. */
+  readonly messages: readonly ChatMessage[];
+  /** Older history exists before `messages[0]`. */
+  readonly hasOlder: boolean;
+  /** Anchor for the next backfill page (`direction=next`), if any. */
+  readonly olderAnchor: string | null;
+}
+
+/** A merge that either advanced the window, or found a hole and refused. */
+export interface ThreadMergeResult {
+  readonly window: ChatThreadWindow;
+  /**
+   * `true` when the incoming messages do not touch the window's tip: more
+   * arrived than one page holds. The caller re-hydrates (the REST twin of the
+   * socket's `error{resync}`) rather than rendering a thread with a hole.
+   */
+  readonly gap: boolean;
+}
+
+export const EMPTY_THREAD_WINDOW: ChatThreadWindow = {
+  messages: [],
+  hasOlder: false,
+  olderAnchor: null,
+};
+
+function ascending(items: readonly ChatMessage[]): ChatMessage[] {
+  return [...items].sort((a, b) => a.seq - b.seq);
+}
+
+/** The tip: the highest `seq` in the window, or 0 for an empty one. */
+export function threadLastSeq(window: ChatThreadWindow): number {
+  const last = window.messages[window.messages.length - 1];
+  return last ? last.seq : 0;
+}
+
+/** The oldest `seq` in the window, or 0 for an empty one. */
+export function threadFirstSeq(window: ChatThreadWindow): number {
+  const first = window.messages[0];
+  return first ? first.seq : 0;
+}
+
+/**
+ * A fresh window from the newest page (`GET …/messages` with no anchor).
+ * This is also the resync path: whatever was loaded before is dropped,
+ * because a window that cannot be proven contiguous is worse than a short
+ * one.
+ */
+export function threadWindowFromPage(page: MessagePage): ChatThreadWindow {
+  return {
+    messages: ascending(page.items),
+    hasOlder: page.has_next,
+    olderAnchor: page.next_anchor ?? null,
+  };
+}
+
+/**
+ * Merge a backfill page (`direction=next` from the window's oldest seq) onto
+ * the FRONT. Anything at or above the current oldest is dropped as a
+ * duplicate — the anchor is exclusive, so this only fires on a retry.
+ */
+export function mergeOlderPage(
+  window: ChatThreadWindow,
+  page: MessagePage
+): ChatThreadWindow {
+  const first = threadFirstSeq(window);
+  const older = ascending(page.items).filter(
+    (message) => first === 0 || message.seq < first
+  );
+  if (older.length === 0) {
+    return { ...window, hasOlder: page.has_next, olderAnchor: page.next_anchor ?? null };
+  }
+  return {
+    messages: [...older, ...window.messages],
+    hasOlder: page.has_next,
+    olderAnchor: page.next_anchor ?? null,
+  };
+}
+
+/**
+ * Merge a tail page (`direction=prev` anchored on the window's tip) onto the
+ * END — the poll-by-seq step.
+ *
+ * Two independent hole detectors, because either one alone can be fooled:
+ *  - the seq test (`first new seq === tip + 1`), which is only meaningful
+ *    because seq is gapless;
+ *  - the paginator's own `has_prev`, which is how a window that was TRUNCATED
+ *    (more messages above the anchor than `limit`) says so.
+ */
+export function mergeNewerPage(
+  window: ChatThreadWindow,
+  page: MessagePage
+): ThreadMergeResult {
+  const tip = threadLastSeq(window);
+  const newer = ascending(page.items).filter((message) => message.seq > tip);
+  if (newer.length === 0) {
+    // Nothing new. `has_prev` cannot be trusted to mean anything here — there
+    // is no window to be truncated — so this is simply "still up to date".
+    return { window, gap: false };
+  }
+  const firstNew = newer[0];
+  // `tip + 1` also covers the empty window: the first message of a
+  // conversation is seq 1, so a page starting at 5 into an empty thread is a
+  // hole, not a beginning.
+  const contiguous = firstNew !== undefined && firstNew.seq === tip + 1;
+  if (!contiguous || page.has_prev) {
+    return { window, gap: true };
+  }
+  return {
+    window: { ...window, messages: [...window.messages, ...newer] },
+    gap: false,
+  };
+}
+
+/**
+ * Merge ONE message onto the end — a live socket frame, or the row a `send`
+ * just returned.
+ *
+ * Already-known seq is dropped (the socket dedupes too, but the sender's own
+ * REST answer and the frame it fans out to itself are two paths to the same
+ * row, and only this rule makes them idempotent). A seq beyond the tip + 1 is
+ * a hole: the window is left untouched and the caller re-hydrates.
+ */
+export function mergeMessage(
+  window: ChatThreadWindow,
+  message: ChatMessage
+): ThreadMergeResult {
+  const tip = threadLastSeq(window);
+  if (message.seq <= tip) return { window, gap: false };
+  if (message.seq !== tip + 1) return { window, gap: true };
+  return {
+    window: { ...window, messages: [...window.messages, message] },
+    gap: false,
+  };
+}

package/src/nav/manifest.ts

@@ -0,0 +1,36 @@
+/**
+ * This pair's contribution to the scripted-fullstack nav contract
+ * (`@stapel/core`'s `NavEntry`/`PackageNavManifest`).
+ * `scripts/gen-nav-manifest.mjs` reads `navEntries` below, stamps
+ * `package`/`version` from THIS package's own `package.json`, and emits
+ * `packages/chat-react/nav-manifest.json` plus this package's slice of the
+ * root aggregate.
+ *
+ * ONE ENTRY, MEMBER-ONLY. Chat is a member surface end to end: every endpoint
+ * is `IsAuthenticated`, and the socket closes 4401 without a session. The
+ * public storefront links INTO it ("message the seller"), but the link lands
+ * on a member route — which is why `surface` is stated explicitly here rather
+ * than left to be derived: a public container that forgot the audience filter
+ * would otherwise mount an inbox for visitors who have none.
+ *
+ * The thread route (`/…/chat/:id`) is deliberately NOT an entry: it is not a
+ * menu destination, and the nav contract addresses routes by static path. A
+ * container mounts `<ConversationThreadPanel conversationId={…}/>` under its
+ * own `:id` child route.
+ */
+import type { NavEntry } from "@stapel/core";
+
+export const navEntries: readonly NavEntry[] = [
+  {
+    id: "chat.conversations",
+    labelKey: "chat.nav.conversations",
+    icon: "MessageOutlined",
+    route: { path: "chat" },
+    component: { export: "ConversationListPanel", subpath: "default" },
+    placement: { level: "top" },
+    menuVisibleDefault: true,
+    requiresAuth: true,
+    surface: "member",
+    order: 25,
+  },
+];

package/src/realtime/chatSocket.ts

@@ -0,0 +1,304 @@
+/**
+ * A resumable client for stapel-chat's own socket protocol.
+ *
+ * The module is store-first and transport-thin: the socket never owns state,
+ * it relays the durable `seq`-ordered journal (`consumers.py` header). This
+ * client is the mirror image of that discipline —
+ *
+ *  - **resume, not subscribe.** Every (re)connect opens with
+ *    `hello{last_seq}` carrying the seq the CONSUMER already holds, so the
+ *    server replays exactly what was missed and then goes live. A reconnect
+ *    after five seconds or five minutes is the same operation.
+ *  - **idempotent by seq.** The server drops frames it has already sent; this
+ *    client drops frames whose `seq` it has already surfaced. The
+ *    replay/live overlap after a resume is therefore invisible to the
+ *    consumer, on both ends of the wire.
+ *  - **a gap is not a stall.** Past `REPLAY_LIMIT` the server answers
+ *    `error{resync}`; this client forwards it verbatim and stops pretending
+ *    to be up to date. Re-hydration is the consumer's job (it owns the REST
+ *    history), which is what keeps correctness independent of delivery.
+ *  - **a refusal is not a retry.** Close codes 4401 (unauthenticated) and
+ *    4403 (not a participant) are answers, not faults: reconnecting would
+ *    hammer the host with a question it already declined. Everything else is
+ *    a fault and reconnects with exponential backoff + jitter.
+ *
+ * No React, no `@stapel/core`, no DOM assumptions beyond an injectable socket
+ * factory — the future `@stapel/realtime` substrate is meant to replace this
+ * file wholesale, so nothing above it may reach into it.
+ */
+import { decodeServerFrame } from "./frames.js";
+import type { ChatServerFrame } from "./frames.js";
+import {
+  CHAT_WS_CLOSE_NOT_PARTICIPANT,
+  CHAT_WS_CLOSE_UNAUTHENTICATED,
+} from "./frames.js";
+
+/**
+ * Connection state, named as the realtime spec (§7) names it, so the
+ * substrate migration is a rename of nothing.
+ *
+ *  - `connecting` — a socket is being opened (including a reconnect wait),
+ *  - `open` — connected; frames are arriving,
+ *  - `degraded` — the socket dropped and a reconnect is pending,
+ *  - `closed` — it will not come back on its own (deliberate close, a
+ *    refusal, or the retry budget spent).
+ */
+export type ChatConnectionState = "connecting" | "open" | "degraded" | "closed";
+
+/** Why the socket will not come back. `undefined` while it still might. */
+export type ChatSocketRefusal =
+  | "unauthenticated"
+  | "not_participant"
+  | "unreachable";
+
+export interface ChatSocketStatus {
+  readonly state: ChatConnectionState;
+  /** Set only in `closed`, and only when the reason is known. */
+  readonly refusal: ChatSocketRefusal | undefined;
+  /** Consecutive failed connects since the last `open`. */
+  readonly attempt: number;
+}
+
+/** The callbacks the transport hands back to this client. */
+export interface ChatSocketHandlers {
+  readonly onOpen: () => void;
+  /** One decoded payload (the `data` of a message event). */
+  readonly onData: (data: unknown) => void;
+  readonly onClose: (code: number) => void;
+  readonly onError: () => void;
+}
+
+/** What a transport must offer: send text, close. */
+export interface ChatSocketConnection {
+  send(payload: string): void;
+  close(): void;
+}
+
+/**
+ * Opens one socket. Injectable so tests drive the protocol without a network
+ * and a host can wrap the socket (instrumentation, a proxy, React Native).
+ */
+export type ChatWebSocketFactory = (
+  url: string,
+  handlers: ChatSocketHandlers
+) => ChatSocketConnection;
+
+/** Reconnect backoff knobs (exponential, jittered, capped). */
+export interface ChatReconnectOptions {
+  readonly baseDelayMs?: number;
+  readonly maxDelayMs?: number;
+  /** Consecutive failures after which the socket gives up (and the caller
+   * falls back to polling). Default 6. */
+  readonly maxAttempts?: number;
+}
+
+/** Cancel handle for a scheduled callback. */
+export type ChatCancel = () => void;
+
+export interface ChatSocketOptions {
+  /** Fully-qualified socket URL, e.g. `wss://host/ws/chat/<uuid>`. */
+  readonly url: string;
+  /**
+   * The highest seq the CONSUMER holds, read afresh at every connect. A
+   * function, not a value, because the consumer keeps advancing while the
+   * socket is down — which is the whole point of resuming by seq.
+   */
+  readonly lastSeq: () => number;
+  readonly onFrame: (frame: ChatServerFrame) => void;
+  readonly onStatus: (status: ChatSocketStatus) => void;
+  readonly webSocket?: ChatWebSocketFactory;
+  readonly reconnect?: ChatReconnectOptions;
+  /** Injectable timer (tests). Returns its own cancel. */
+  readonly schedule?: (fn: () => void, ms: number) => ChatCancel;
+  /** Injectable jitter source (tests). */
+  readonly random?: () => number;
+}
+
+export interface ChatSocket {
+  /** Current status (also pushed through `onStatus`). */
+  status(): ChatSocketStatus;
+  /** Acknowledge delivery up to `seq` (the server tracks it; nothing
+   * depends on it — a dropped ack costs nothing). */
+  ack(seq: number): void;
+  /** Liveness probe. */
+  ping(): void;
+  /** Close deliberately: no reconnect, no further callbacks. */
+  close(): void;
+}
+
+const DEFAULT_BASE_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 15_000;
+const DEFAULT_MAX_ATTEMPTS = 6;
+
+function defaultSchedule(fn: () => void, ms: number): ChatCancel {
+  const handle = setTimeout(fn, ms);
+  return () => {
+    clearTimeout(handle);
+  };
+}
+
+/**
+ * The browser transport. Uses `addEventListener` rather than the `on*`
+ * properties so the structural contract above stays independent of the DOM
+ * `WebSocket` type (and so a host wrapper can be a plain object).
+ */
+export function browserWebSocketFactory(
+  url: string,
+  handlers: ChatSocketHandlers
+): ChatSocketConnection {
+  const socket = new WebSocket(url);
+  socket.addEventListener("open", () => {
+    handlers.onOpen();
+  });
+  socket.addEventListener("message", (event: MessageEvent<unknown>) => {
+    handlers.onData(event.data);
+  });
+  socket.addEventListener("close", (event: CloseEvent) => {
+    handlers.onClose(event.code);
+  });
+  socket.addEventListener("error", () => {
+    handlers.onError();
+  });
+  return {
+    send: (payload) => {
+      socket.send(payload);
+    },
+    close: () => {
+      socket.close();
+    },
+  };
+}
+
+/** True when the environment can open a socket at all (SSR / node cannot). */
+export function canOpenWebSocket(): boolean {
+  return typeof WebSocket !== "undefined";
+}
+
+function refusalFor(code: number): ChatSocketRefusal | undefined {
+  if (code === CHAT_WS_CLOSE_UNAUTHENTICATED) return "unauthenticated";
+  if (code === CHAT_WS_CLOSE_NOT_PARTICIPANT) return "not_participant";
+  return undefined;
+}
+
+/**
+ * Open a resumable conversation socket. Connects immediately; returns the
+ * handle that closes it. Every state change is pushed through `onStatus`, so
+ * a React layer can render the transport without polling this object.
+ */
+export function createChatSocket(options: ChatSocketOptions): ChatSocket {
+  const factory = options.webSocket ?? browserWebSocketFactory;
+  const schedule = options.schedule ?? defaultSchedule;
+  const random = options.random ?? Math.random;
+  const baseDelay = options.reconnect?.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const maxDelay = options.reconnect?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const maxAttempts = options.reconnect?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+
+  let connection: ChatSocketConnection | null = null;
+  let cancelRetry: ChatCancel | null = null;
+  let disposed = false;
+  let attempt = 0;
+  /** Highest seq handed to the consumer — the dedup cursor. */
+  let maxSeqSeen = 0;
+  let status: ChatSocketStatus = {
+    state: "connecting",
+    refusal: undefined,
+    attempt: 0,
+  };
+
+  function setStatus(
+    state: ChatConnectionState,
+    refusal?: ChatSocketRefusal
+  ): void {
+    status = { state, refusal, attempt };
+    options.onStatus(status);
+  }
+
+  function send(frame: unknown): void {
+    if (!connection) return;
+    try {
+      connection.send(JSON.stringify(frame));
+    } catch {
+      // A send on a socket that just died is not an error worth surfacing:
+      // the close handler is already on its way and will reconnect.
+    }
+  }
+
+  function backoffDelay(): number {
+    const exponential = baseDelay * 2 ** Math.max(0, attempt - 1);
+    const capped = Math.min(exponential, maxDelay);
+    // Full jitter — a fleet of tabs reconnecting after one server blip must
+    // not arrive as one wave.
+    return Math.round(capped * (0.5 + random() * 0.5));
+  }
+
+  function connect(): void {
+    if (disposed) return;
+    setStatus("connecting");
+    // The consumer may have advanced by REST while we were down; never hand
+    // it a frame it already has.
+    maxSeqSeen = Math.max(maxSeqSeen, options.lastSeq());
+    connection = factory(options.url, {
+      onOpen: () => {
+        if (disposed) return;
+        attempt = 0;
+        send({ type: "hello", last_seq: options.lastSeq() });
+        setStatus("open");
+      },
+      onData: (data) => {
+        if (disposed) return;
+        const frame = decodeServerFrame(data);
+        // An unreadable frame must NOT advance the cursor — the gap it would
+        // hide is exactly what resume-by-seq exists to close.
+        if (!frame) return;
+        if (frame.type === "message") {
+          if (frame.seq <= maxSeqSeen) return;
+          maxSeqSeen = frame.seq;
+        }
+        options.onFrame(frame);
+      },
+      onError: () => {
+        // `error` always precedes `close` on a browser socket; the close
+        // handler owns the reconnect so the two cannot both schedule one.
+      },
+      onClose: (code) => {
+        if (disposed) return;
+        connection = null;
+        const refusal = refusalFor(code);
+        if (refusal) {
+          // The host answered the question. Asking again, faster, is the
+          // classic way to turn a 4403 into an outage.
+          setStatus("closed", refusal);
+          return;
+        }
+        attempt += 1;
+        if (attempt >= maxAttempts) {
+          setStatus("closed", "unreachable");
+          return;
+        }
+        setStatus("degraded");
+        cancelRetry = schedule(connect, backoffDelay());
+      },
+    });
+  }
+
+  connect();
+
+  return {
+    status: () => status,
+    ack: (seq) => {
+      send({ type: "ack", seq });
+    },
+    ping: () => {
+      send({ type: "ping" });
+    },
+    close: () => {
+      disposed = true;
+      cancelRetry?.();
+      cancelRetry = null;
+      const open = connection;
+      connection = null;
+      open?.close();
+      status = { state: "closed", refusal: undefined, attempt };
+    },
+  };
+}