@openmarket/rooms-client 0.1.0

package/dist/social-types.d.ts

@@ -0,0 +1,338 @@
+import type { RoomLedgerSecretPayload } from "./shared/rooms-protocol.js";
+export interface RoomSocialConfig {
+    apiUrl: string;
+    apiKey: string;
+}
+export type RoomSuggestionSource = "init" | "alert_create" | "market_lookup" | "status" | "digest";
+export interface RoomSuggestionIntent {
+    symbols?: string[];
+    entities?: string[];
+    categories?: string[];
+    roomHints?: string[];
+    reason?: string;
+}
+export interface RoomSuggestionRequest {
+    source: RoomSuggestionSource;
+    intent?: RoomSuggestionIntent;
+    limit?: number;
+}
+export interface RoomSuggestion {
+    room: string;
+    title: string;
+    proof: {
+        online: number;
+        heat: "surging" | "active_now";
+        latestActivity?: string;
+        followingOnline?: number;
+        followingHandles?: string[];
+        friendsOnline?: number;
+        friendHandles?: string[];
+    };
+    copy: string;
+    suggestionId: string;
+}
+export interface RoomFollow {
+    userId: string;
+    profileUrl?: string | undefined;
+}
+export interface RoomFollowTarget {
+    userId: string;
+    username: string;
+}
+export interface RoomFollowResult {
+    target: RoomFollowTarget;
+    isNewFollow?: boolean;
+}
+export interface RoomAttachment {
+    /** Object key under room-attachments/; clients sign it at render time. */
+    key: string;
+    name: string;
+    size: number;
+    mime: string;
+    scanStatus?: "pending" | "clean" | "held" | undefined;
+}
+export interface RoomAttachmentUpload {
+    /** The stored attachment plus its first signed URL, for immediate render. */
+    attachment: RoomAttachment & {
+        url: string;
+        expiresAt: string | null;
+    };
+}
+export interface RoomPublicProfile {
+    userId: string;
+    displayName?: string | undefined;
+    username?: string | undefined;
+    handle?: string | undefined;
+    profileDescription?: string | undefined;
+    profileUrl?: string | undefined;
+    followerCount?: number | undefined;
+    memberSince?: string | number | null | undefined;
+}
+export interface RoomFriend {
+    friendshipId: string;
+    userId: string;
+    username: string;
+    acceptedAt: string | number;
+    lastMessageAt?: string | number;
+}
+export interface RoomFriendRequest {
+    friendshipId: string;
+    userId: string;
+    username: string;
+    createdAt: string | number;
+}
+export interface RoomFriendRequests {
+    sent: RoomFriendRequest[];
+    received: RoomFriendRequest[];
+}
+export interface RoomDmParticipant {
+    userId: string;
+    username: string;
+}
+export interface RoomDmConversation {
+    conversationId: string;
+    participant: RoomDmParticipant;
+    unreadCount: number;
+    lastMessage?: RoomDmMessage;
+    updatedAt?: string | number;
+}
+export interface RoomDmMessage {
+    id?: string;
+    _id?: string;
+    messageId?: string;
+    conversationId?: string;
+    senderId?: string;
+    userId?: string;
+    senderUsername?: string;
+    username?: string;
+    content: string;
+    type?: string;
+    timestamp?: string | number;
+    createdAt?: string | number;
+    /** Sealed DM: content is '' and the opaque envelope rides here. */
+    secret?: RoomLedgerSecretPayload | null;
+    metadata?: Record<string, unknown>;
+}
+export interface RoomDmHistory {
+    conversationId: string;
+    participant: RoomDmParticipant;
+    messages: RoomDmMessage[];
+    hasMore: boolean;
+    cursor?: number;
+}
+export interface RoomDmUnreadConversation extends RoomDmHistory {
+    unreadCount: number;
+}
+export interface RoomDmSendResult {
+    conversationId: string;
+    participant: RoomDmParticipant;
+    message: RoomDmMessage;
+}
+export interface RoomReplyInboxItem {
+    id?: string;
+    roomId: string;
+    replySeq: number;
+    parentSeq: number;
+    senderId?: string;
+    senderHandle: string;
+    parentPreview: string;
+    replyPreview: string;
+    readAt?: string | number | null;
+    createdAt?: string | number;
+    updatedAt?: string | number;
+}
+export interface RoomRepliesResult {
+    replies: RoomReplyInboxItem[];
+    unreadCount: number;
+}
+export interface RoomRepliesReadResult {
+    markedRead: number;
+}
+/** A living markdown doc scoped to a space (head state; content on demand). */
+export interface RoomDoc {
+    docId: string;
+    spaceId: string;
+    path: string;
+    title: string;
+    headRev: number;
+    headSha: string;
+    headNote: string;
+    headAuthorId: string;
+    headAuthorHandle: string;
+    headIsAgent: boolean;
+    headAt: string;
+    status: "active" | "archived";
+    aclMode: "space" | "owner";
+    restrictedToRoomId: string | null;
+    discussionRoomId: string | null;
+    createdByUserId: string;
+    createdByHandle: string;
+    sizeBytes: number;
+    spaceDocSeq: number;
+    createdAt?: string;
+    updatedAt?: string;
+    content?: string;
+}
+export interface RoomDocProvenance {
+    roomId?: string | undefined;
+    seqFrom?: number | undefined;
+    seqTo?: number | undefined;
+}
+/**
+ * Which surface issued a doc write: the rooms GUI editor, an agent doc verb,
+ * the local disk mirror (library sync), or the TUI/CLI flows. Self-declared
+ * attribution for the history view (same trust model as `asAgent`), never
+ * enforcement.
+ */
+export type RoomDocRevisionSource = "gui" | "agent" | "mirror" | "cli";
+/** Optional attribution rider accepted by every doc write. */
+export interface RoomDocAttribution {
+    /** Phase 1 agent credential id (`agcr_*`) when an agent authored the write. */
+    credentialId?: string | undefined;
+    /** Groups every revision one agent run produced. */
+    runId?: string | undefined;
+    /** Surface that issued the write. */
+    source?: RoomDocRevisionSource | undefined;
+}
+export interface RoomDocRevision {
+    docId: string;
+    rev: number;
+    op: string;
+    authorUserId: string;
+    authorHandle: string;
+    isAgent: boolean;
+    baseRev: number;
+    sha: string;
+    sizeBytes: number;
+    note: string;
+    noteSource: "human" | "agent" | "auto";
+    /** Attribution rider (null on pre-attribution revisions and older servers). */
+    credentialId?: string | null;
+    runId?: string | null;
+    source?: RoomDocRevisionSource | null;
+    provenance: RoomDocProvenance | null;
+    pathAfter: string | null;
+    revertOf: number | null;
+    recoveryPlanId?: string | null;
+    restorePoint?: string | null;
+    statusAfter?: "active" | "archived" | null;
+    at: string;
+    content?: string;
+    diff?: string;
+    diffOmitted?: boolean;
+}
+export type RoomSpaceRestoreActionKind = "content" | "archive" | "restore" | "content_and_status" | "archive_created_after";
+export interface RoomSpaceRestoreAction {
+    docId: string;
+    path: string;
+    kind: RoomSpaceRestoreActionKind;
+    currentRev: number;
+    targetRev: number | null;
+    currentStatus: "active" | "archived";
+    targetStatus: "active" | "archived";
+    currentAuthorUserId: string;
+    currentAuthorHandle: string;
+    currentAt: string;
+    targetAt: string | null;
+}
+export interface RoomSpaceRestoreSummary {
+    totalDocs: number;
+    totalActions: number;
+    contentRestores: number;
+    archives: number;
+    restores: number;
+    pathConflicts: number;
+    unchanged: number;
+}
+export interface RoomSpaceRestorePlan {
+    planId: string;
+    spaceId: string;
+    restoreAt: string;
+    baseCursor: number;
+    reason: string;
+    requestedByHandle: string;
+    status: "ready" | "applying" | "applied" | "failed" | "stale";
+    scope: "content_and_lifecycle";
+    scopeNote: string;
+    actions: RoomSpaceRestoreAction[];
+    summary: RoomSpaceRestoreSummary;
+    appliedCount: number;
+    expiresAt: string;
+    appliedAt: string | null;
+    resultingCursor: number | null;
+    error: string | null;
+}
+export interface RoomSpaceRestoreReceipt {
+    planId: string;
+    spaceId: string;
+    restoreAt: string;
+    reason: string;
+    status: "applied";
+    appliedActions: number;
+    resultingCursor: number;
+    appliedAt: string;
+    summary: RoomSpaceRestoreSummary;
+}
+/** Resumable per-space change feed page. `latestSeq` is the space's current
+ *  head cursor: `cursor === latestSeq` means the caller is fully in sync. */
+export interface RoomDocChanges {
+    changes: RoomDoc[];
+    cursor: number;
+    latestSeq: number;
+}
+export interface RoomDocConflictHead {
+    rev: number;
+    sha: string;
+    content: string;
+    note: string;
+    authorHandle: string;
+    isAgent: boolean;
+    at: string;
+}
+export interface RoomDocWriteResult {
+    doc: RoomDoc;
+    rev: number;
+    unchanged: boolean;
+}
+/** One diverging chunk from a three-way merge (line arrays, no separators). */
+export interface RoomDocMergeRegion {
+    base: string[];
+    mine: string[];
+    theirs: string[];
+}
+/**
+ * Outcome of a selective run revert. A merge conflict is OUTCOME data, not
+ * an error: nothing was written, and the payload carries the three full
+ * contents (base = the run's final content, mine = the current head,
+ * theirs = the pre-run content) plus the diverging regions so the reconcile
+ * surface can mediate. `headRev` is the fence a mediated resolution
+ * publishes against.
+ */
+export type RoomDocRunRevertResult = {
+    status: "reverted";
+    doc: RoomDoc;
+    rev: number;
+    unchanged: boolean;
+} | {
+    status: "conflict";
+    headRev: number;
+    runId: string;
+    base: string;
+    mine: string;
+    theirs: string;
+    regions: RoomDocMergeRegion[];
+};
+/**
+ * An editing-presence lease: the HINT that a user currently holds a dirty
+ * working copy of a doc on some device. Renewed by heartbeat, dropped on
+ * publish/discard, TTL-expired otherwise. Never a lock, never content;
+ * `isAgent` lets UIs class agent editors per the phase 3 presence rules.
+ */
+export interface RoomDocEditingLease {
+    docId: string;
+    spaceId: string;
+    userId: string;
+    handle: string;
+    isAgent: boolean;
+    expiresAt: string;
+}

package/dist/social-types.js

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

package/dist/suggestion-attribution.d.ts

@@ -0,0 +1,10 @@
+import type { RoomSuggestion } from "./social-types.js";
+export interface RoomSuggestionAttribution {
+    suggestionId: string;
+    hook: string;
+}
+export declare const ROOM_SUGGESTION_ATTRIBUTION_TTL_MS: number;
+export declare function rememberRoomSuggestionAttribution(suggestion: Pick<RoomSuggestion, "room" | "suggestionId">, hook: string, now?: number): void;
+export declare function rememberRoomSuggestionAttributions(suggestions: readonly Pick<RoomSuggestion, "room" | "suggestionId">[], hook: string, now?: number): void;
+export declare function consumeRoomSuggestionAttribution(room: string, now?: number): RoomSuggestionAttribution | undefined;
+export declare function resetRoomSuggestionAttributionForTest(): void;

package/dist/suggestion-attribution.js

@@ -0,0 +1,56 @@
+export const ROOM_SUGGESTION_ATTRIBUTION_TTL_MS = 15 * 60 * 1000;
+const MAX_ROOM_SUGGESTION_ATTRIBUTIONS = 100;
+const roomSuggestionAttributions = new Map();
+export function rememberRoomSuggestionAttribution(suggestion, hook, now = Date.now()) {
+    const room = normalizeRoomKey(suggestion.room);
+    const suggestionId = suggestion.suggestionId.trim();
+    const normalizedHook = hook.trim();
+    if (!room || !suggestionId || !normalizedHook)
+        return;
+    pruneExpiredRoomSuggestionAttributions(now);
+    while (roomSuggestionAttributions.size >= MAX_ROOM_SUGGESTION_ATTRIBUTIONS &&
+        !roomSuggestionAttributions.has(room)) {
+        const oldest = roomSuggestionAttributions.keys().next().value;
+        if (!oldest)
+            break;
+        roomSuggestionAttributions.delete(oldest);
+    }
+    roomSuggestionAttributions.set(room, {
+        suggestionId,
+        hook: normalizedHook,
+        expiresAt: now + ROOM_SUGGESTION_ATTRIBUTION_TTL_MS,
+    });
+}
+export function rememberRoomSuggestionAttributions(suggestions, hook, now = Date.now()) {
+    for (const suggestion of suggestions) {
+        rememberRoomSuggestionAttribution(suggestion, hook, now);
+    }
+}
+export function consumeRoomSuggestionAttribution(room, now = Date.now()) {
+    const roomKey = normalizeRoomKey(room);
+    if (!roomKey)
+        return undefined;
+    const attribution = roomSuggestionAttributions.get(roomKey);
+    if (!attribution)
+        return undefined;
+    roomSuggestionAttributions.delete(roomKey);
+    if (attribution.expiresAt <= now)
+        return undefined;
+    return {
+        suggestionId: attribution.suggestionId,
+        hook: attribution.hook,
+    };
+}
+export function resetRoomSuggestionAttributionForTest() {
+    roomSuggestionAttributions.clear();
+}
+function pruneExpiredRoomSuggestionAttributions(now) {
+    for (const [room, attribution] of roomSuggestionAttributions) {
+        if (attribution.expiresAt <= now) {
+            roomSuggestionAttributions.delete(room);
+        }
+    }
+}
+function normalizeRoomKey(room) {
+    return room.trim().replace(/^#/, "").toLowerCase();
+}

package/dist/topic-uri.d.ts

@@ -0,0 +1,26 @@
+/**
+ * om://topic URIs: permanent links into a channel's topics.
+ *
+ * The id is registry-backed and never changes, so a captured link
+ * (`om://topic/<topicId>`) keeps resolving after the topic is renamed or
+ * merged into another topic. Clients that understand the scheme render it as
+ * a pill and can annotate it with the topic's live name from a local cache;
+ * clients that don't still show a usable, resolvable reference.
+ */
+export interface TopicUriRef {
+    topicId: string;
+}
+export declare function makeTopicUri(topicId: string): string;
+export declare function parseTopicUris(text: string): TopicUriRef[];
+export interface TopicUriRenderContext {
+    /** Resolve a topicId to its live name, when known. */
+    lookup?: ((topicId: string) => string | undefined) | undefined;
+}
+export declare function setTopicUriLookup(lookup: TopicUriRenderContext["lookup"]): void;
+export declare function decorateTopicUrisLive(text: string): string;
+/**
+ * Replace om://topic URIs with a rendered pill: the topic's live name when a
+ * cache lookup resolves it, otherwise a compact id reference that is still
+ * visibly a topic link.
+ */
+export declare function decorateTopicUris(text: string, context?: TopicUriRenderContext): string;

package/dist/topic-uri.js

@@ -0,0 +1,40 @@
+import pc from "picocolors";
+const TOPIC_URI_RE = /om:\/\/topic\/([A-Za-z0-9_-]{6,64})/g;
+export function makeTopicUri(topicId) {
+    return `om://topic/${topicId}`;
+}
+export function parseTopicUris(text) {
+    const refs = [];
+    for (const match of text.matchAll(TOPIC_URI_RE)) {
+        const topicId = match[1];
+        if (!topicId)
+            continue;
+        refs.push({ topicId });
+    }
+    return refs;
+}
+/**
+ * Process-wide lookup used by the tape renderers, mirroring
+ * `setDocUriLookup` in ./doc-uri. Renderers work unregistered too: pills
+ * just lose the name annotation and fall back to a truncated id.
+ */
+let activeLookup;
+export function setTopicUriLookup(lookup) {
+    activeLookup = lookup;
+}
+export function decorateTopicUrisLive(text) {
+    if (!text.includes("om://topic/"))
+        return text;
+    return decorateTopicUris(text, { lookup: activeLookup });
+}
+/**
+ * Replace om://topic URIs with a rendered pill: the topic's live name when a
+ * cache lookup resolves it, otherwise a compact id reference that is still
+ * visibly a topic link.
+ */
+export function decorateTopicUris(text, context = {}) {
+    return text.replace(TOPIC_URI_RE, (_raw, topicId) => {
+        const name = context.lookup?.(topicId);
+        return name ? pc.cyan(`⌗ ${name}`) : pc.cyan(`⌗ topic:${topicId.slice(0, 8)}`);
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export type { RoomAccessMode, RoomAttachment, RoomAuditEntry, RoomAuditLogPayload, RoomAuditLogRequestPayload, RoomAuthSuccessPayload, RoomBackfillPayload, RoomClientMessage, RoomCreatedPayload, RoomCreatePayload, RoomDmHistoryPayload, RoomDmHistoryResultPayload, RoomDmInboxUpdatedPayload, RoomDmMessage, RoomDmMessagePayload, RoomDmOpenedPayload, RoomDmOpenPayload, RoomDmParticipant, RoomDmReadPayload, RoomDmSendPayload, RoomEntryUpdatedPayload, RoomErrorPayload, RoomFriendPresence, RoomInvitedPayload, RoomInvitePayload, RoomLedgerEntry, RoomMember, RoomMemberRemovedPayload, RoomMemberRoleChangedPayload, RoomMemberTier, RoomMessagePayload, RoomMeta, RoomModerateMemberPayload, RoomMutedPayload, RoomPinsPayload, RoomPresenceDeltaPayload, RoomPresencePayload, RoomReactorsPayload, RoomReadStatePayload, RoomRemoveMemberPayload, RoomReportedPayload, RoomReportPayload, RoomResyncPayload, RoomRole, RoomRoleChangePayload, RoomSearchPayload, RoomSearchResultsPayload, RoomSearchScope, RoomServerMessage, RoomServerMessageOf, RoomSetReadOnlyPayload, RoomSpace, RoomSpaceJoinedPayload, RoomSpacesPayload, RoomThreadPayload, RoomTopic, RoomTopicAttention, RoomTopicBucketState, RoomTopicCreatePayload, RoomTopicListPayload, RoomTopicMergePayload, RoomTopicMovePayload, RoomTopicRenamePayload, RoomTopicResolvePayload, RoomTopicResultPayload, RoomTopicSetAttentionPayload, RoomTopicsPolicy, RoomTopicsResultPayload, RoomTopicUpdatedPayload, RoomTypingPayload, RoomUserStatus, RoomWhoPayload, } from "./shared/rooms-protocol.js";
+export { applyRoomPresenceDelta, isSystemRoomLedgerEntryType, ROOM_PRESENCE_SAMPLE_LIMIT, RoomClientMessageType, RoomLedgerEntryType, RoomServerMessageType, SUPPORTED_ROOM_PROTOCOL_VERSION, } from "./shared/rooms-protocol.js";

package/dist/types.js

@@ -0,0 +1 @@
+export { applyRoomPresenceDelta, isSystemRoomLedgerEntryType, ROOM_PRESENCE_SAMPLE_LIMIT, RoomClientMessageType, RoomLedgerEntryType, RoomServerMessageType, SUPPORTED_ROOM_PROTOCOL_VERSION, } from "./shared/rooms-protocol.js";

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.5.0";
+export declare const RUNNER_VERSION = "0.5.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+export const VERSION = "0.5.0";
+export const RUNNER_VERSION = "0.5.0";

package/dist/ws-client.d.ts

@@ -0,0 +1,115 @@
+import { type RoomAuthSuccessPayload, type RoomClientMessage, type RoomErrorPayload, type RoomServerMessage, type RoomServerMessageOf, RoomServerMessageType } from "./types.js";
+export declare class RoomProtocolError extends Error {
+    readonly name = "RoomProtocolError";
+    readonly code: string;
+    readonly details?: unknown;
+    readonly requestId?: string;
+    constructor(payload: RoomErrorPayload);
+}
+export declare class RoomTransportError extends Error {
+    readonly name = "RoomTransportError";
+}
+export type RoomWebSocketCtor = new (url: string) => WebSocket;
+export interface RoomWsClientOptions {
+    url: string;
+    apiKey: string;
+    /** Refreshes a locally managed credential after an authentication refusal. */
+    refreshAuthToken?: () => Promise<string>;
+    webSocketCtor?: RoomWebSocketCtor;
+    timeoutMs?: number;
+    /** Enable bounded exponential-backoff reconnection on an unexpected drop. */
+    reconnect?: boolean;
+    /** Base backoff in ms (default 500). */
+    reconnectBaseMs?: number;
+    /** Max backoff in ms (default 15_000). */
+    reconnectMaxMs?: number;
+    /** Flat 0..N ms herd jitter added to every reconnect delay (default 5_000).
+     *  A relay restart drops every client at once; the exponential backoff's
+     *  first window is only ~250-500ms, so without this the whole fleet
+     *  re-AUTHENTICATEs in the same instant. */
+    reconnectHerdJitterMs?: number;
+    /** Give up after this many consecutive failures (default: never; live sessions reconnect indefinitely). */
+    reconnectMaxAttempts?: number;
+    /** Sidekick identity assertion: this session presents itself as the named
+     *  operator-owned agent (AUTHENTICATE carries isAgent plus the display
+     *  username, additive fields old relays ignore). Ghost and plain user
+     *  sessions omit it entirely, keeping their first frame byte-shaped like
+     *  today's. Display only; safety keys on the daemon credential. */
+    agentIdentity?: {
+        name: string;
+    };
+    onProtocolMismatch?: (info: {
+        supported: number;
+        server: number;
+    }) => void;
+}
+type RoomListener = (msg: RoomServerMessage) => void;
+/** Notified when the socket drops and when it comes back after a reconnect. */
+export type RoomConnectionListener = (state: "reconnecting" | "reconnected" | "failed", detail?: {
+    attempt?: number;
+    error?: string;
+}) => void;
+export declare class RoomWsClient {
+    private readonly url;
+    private apiKey;
+    private readonly agentIdentity;
+    private readonly webSocketCtor;
+    private readonly timeoutMs;
+    private ws;
+    private auth;
+    private serverProtocolVersionValue;
+    private listeners;
+    private connectionListeners;
+    private pending;
+    private connected;
+    private readonly reconnectEnabled;
+    private readonly reconnectBaseMs;
+    private readonly reconnectMaxMs;
+    private readonly reconnectHerdJitterMs;
+    private readonly reconnectMaxAttempts;
+    private readonly refreshAuthToken;
+    private readonly onProtocolMismatch;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private closedByClient;
+    private authRefreshRequested;
+    private authRefreshInFlight;
+    /** True after a successful re-mint whose refreshed attempt hasn't authed yet.
+     *  Caps the mint-succeeds-but-server-rejects cycle (config skew) at ONE
+     *  refreshed attempt per episode — without it, openSocket → fail → re-mint →
+     *  openSocket recurses in a hot loop with no backoff. Reset on AUTH_SUCCESS.
+     *  A FAILED re-mint does not set it: that path already backs off through
+     *  maybeReconnect, so transient auth-service outages keep retrying. */
+    private authRefreshAttempted;
+    constructor(options: RoomWsClientOptions);
+    /** Subscribe to connection-state transitions (reconnecting/reconnected/failed). */
+    onConnectionChange(listener: RoomConnectionListener): () => void;
+    private emitConnectionState;
+    connect(): Promise<RoomAuthSuccessPayload>;
+    private openSocket;
+    private maybeReconnect;
+    send(msg: RoomClientMessage): void;
+    waitFor<T extends RoomServerMessageType>(type: T, predicate?: (msg: RoomServerMessageOf<T>) => boolean, timeoutMs?: number, requestId?: string): Promise<RoomServerMessageOf<T>>;
+    waitForAny<T extends RoomServerMessageType>(types: readonly T[], predicate?: (msg: Extract<RoomServerMessage, {
+        type: T;
+    }>) => boolean, timeoutMs?: number, requestId?: string): Promise<Extract<RoomServerMessage, {
+        type: T;
+    }>>;
+    onMessage(listener: RoomListener): () => void;
+    close(): void;
+    private readonly waiterHandledErrors;
+    serverProtocolVersion(): number | null;
+    isGuest(): boolean;
+    private record;
+    private handleAuthSuccess;
+    private retryGuestAuthentication;
+    private resolvePending;
+    private rejectAll;
+    private rejectByRequestId;
+    private rejectOldest;
+    /** Was this ERROR frame already delivered to a waiting request's caller? */
+    errorHandledByWaiter(msg: RoomServerMessage): boolean;
+}
+/** Returns false for an invalid server value so a typo cannot lock out every client. */
+export declare function isRoomClientBuildBelowMinimum(clientBuild: string, minimumBuild: string): boolean;
+export {};