@buoy-gg/network 7.0.78 → 7.0.80

package/lib/typescript/index.web.d.ts

@@ -18,6 +18,10 @@ export { networkListener, startNetworkListener, stopNetworkListener, addNetworkL
 export type { NetworkingEvent, NetworkingEventListener, } from "./network/utils/networkListener";
 export { networkEventStore } from "./network/utils/networkEventStore";
 export { networkSavedStore, flagsForEventId, } from "./network/utils/networkSavedStore";
+export { socketStore } from "./network/sockets/socketStore";
+export { socketsSyncAdapter, querySockets } from "./network/sockets/socketsSyncAdapter";
+export { onSocketMoment } from "./network/sockets/socketMoments";
+export type { SocketConnection, SocketFrame, SocketProblem, SocketsState } from "./network/sockets/types";
 export type { NetworkEvent, NetworkStats, NetworkFilter, NetworkTimings, } from "./network/types";
 export { useNetworkEvents, FREE_TIER_REQUEST_LIMIT } from "./network/hooks/useNetworkEvents";
 export { useNetworkEventList } from "./network/hooks/useNetworkEventList";
@@ -53,6 +57,7 @@ export { filterNetworkEvents, applyIgnoredPatterns, } from "./network/utils/filt
 export { splitPinned, type PinnedSplit } from "./network/utils/withPinnedFirst";
 export { extractOperationName } from "./network/utils/extractOperationName";
 export { generateCurl } from "./network/utils/generateCurl";
-export { NETWORK_CONDITIONS, getNetworkCondition, setNetworkCondition, subscribeNetworkConditions } from "./network/conditions/store";
-export type { NetworkConditionProfile, NetworkConditionStamp } from "./network/conditions/store";
+export { NETWORK_CONDITIONS, getNetworkCondition, setNetworkCondition, subscribeNetworkConditions, getNetworkConditions, setNetworkConditions, getNetworkConnection, getConditionsRevision, networkConditionsActive } from "./network/conditions/store";
+export type { NetworkConditionProfile, NetworkConditionStamp, NetworkConditionsState, NetworkConditionsChange, NetworkConnection } from "./network/conditions/store";
+export { chooseConditionsSnapshot } from "./network/conditions/remoteState";
 //# sourceMappingURL=index.web.d.ts.map

package/lib/typescript/netinfo.d.ts

@@ -0,0 +1,3 @@
+/** Call before app imports that read NetInfo. No native code is added. */
+export declare function installNetInfoConditions(): void;
+//# sourceMappingURL=netinfo.d.ts.map

package/lib/typescript/network/components/sockets/NetworkSocketsButton.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Header button for the Sockets screen, and the live "a socket is open" light.
+ *
+ * A self-subscribing leaf like the Overrides button, so socket traffic never
+ * re-renders the modal shell. It stays hidden until the app opens its first
+ * socket: most apps have none, and the header is already full. The ⋯ menu
+ * always has a Sockets item.
+ *
+ * Green = a socket is open. A red count = problems Buoy found. Amber = a
+ * trick is on (frozen, blocked, offline), because a socket Buoy is breaking
+ * looks exactly like a real bug.
+ */
+export declare function NetworkSocketsButton({ onPress, paused }: {
+    onPress: () => void;
+    paused: boolean;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=NetworkSocketsButton.d.ts.map

package/lib/typescript/network/components/sockets/NetworkSocketsScreen.d.ts

@@ -0,0 +1,19 @@
+import { type MutableRefObject } from "react";
+/**
+ * The Sockets screen of the Network tool: the list, one message, and Tricks.
+ *
+ * A router only (rule3/rule4): it holds which of the three is showing and
+ * renders all three as stable siblings that gate themselves. Back steps out of
+ * a message or Tricks before it leaves the screen, through the same
+ * `backHandlerRef` hand-off the Overrides screen uses.
+ */
+export declare function NetworkSocketsScreen({ visible, paused, isPro, onUpgradePress, backHandlerRef, onTitleChange, }: {
+    visible: boolean;
+    paused: boolean;
+    isPro: boolean;
+    onUpgradePress: () => void;
+    backHandlerRef?: MutableRefObject<(() => boolean) | null>;
+    /** The header's title for what's showing: "Sockets", "Message" or "Tricks". */
+    onTitleChange?: (title: string) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=NetworkSocketsScreen.d.ts.map

package/lib/typescript/network/components/sockets/SocketFrameView.d.ts

@@ -0,0 +1,9 @@
+import type { SocketFrame } from "../../sockets/types";
+export declare function SocketFrameView({ visible, frameId, isPro, onUpgradePress, onEdit, }: {
+    visible: boolean;
+    frameId: string | null;
+    isPro: boolean;
+    onUpgradePress: () => void;
+    onEdit: (frame: SocketFrame) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=SocketFrameView.d.ts.map

package/lib/typescript/network/components/sockets/SocketListView.d.ts

@@ -0,0 +1,9 @@
+import type { SocketFrame } from "../../sockets/types";
+export declare function SocketListView({ visible, paused, search, onOpenFrame, onOpenTricks, }: {
+    visible: boolean;
+    paused: boolean;
+    search: string;
+    onOpenFrame: (frame: SocketFrame) => void;
+    onOpenTricks: (socketId: string | null) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=SocketListView.d.ts.map

package/lib/typescript/network/components/sockets/SocketRows.d.ts

@@ -0,0 +1,19 @@
+import type { SocketRow } from "../../sockets/foldFrames";
+import type { SocketFrame } from "../../sockets/types";
+/**
+ * `onOpen`, not `onPress`: an agent's tap_element calls the first `onPress` it
+ * finds by name, and it must land on the touchable (which passes the frame),
+ * not on this component's prop with a touch event in place of the frame.
+ *
+ * A folded burst opens up on tap (`onExpand`) instead, one row per message.
+ */
+export declare function SocketMessageRow({ row, onOpen, onExpand, }: {
+    row: SocketRow;
+    onOpen: (frame: SocketFrame) => void;
+    onExpand: (foldKey: string) => void;
+}): import("react").JSX.Element;
+export declare function SocketLifecycleRow({ row, attempt }: {
+    row: SocketRow;
+    attempt?: number;
+}): import("react").JSX.Element;
+//# sourceMappingURL=SocketRows.d.ts.map

package/lib/typescript/network/components/sockets/SocketTricksView.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Socket tricks: make the socket misbehave on purpose, and watch the app's own
+ * code deal with it.
+ *
+ * - Push a message into the app as if the server sent it, or send one to the
+ *   server.
+ * - Drop it (1006, like lost signal), kick it out (1008, like a bad token),
+ *   freeze it (looks open, says nothing), or block every new socket.
+ *
+ * Everything here is fake, so the screen says what is on, and Reset turns it
+ * all off. Pro, like response overrides.
+ */
+export interface TricksDraft {
+    socketId: string | null;
+    data: string;
+}
+export declare function SocketTricksView({ visible, draft, isPro, onUpgradePress, }: {
+    visible: boolean;
+    draft: TricksDraft | null;
+    isPro: boolean;
+    onUpgradePress: () => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=SocketTricksView.d.ts.map

package/lib/typescript/network/conditions/NetworkConditionsControl.d.ts

@@ -1,12 +1,15 @@
-import { type NetworkConditionProfile } from "./store";
+import { type NetworkConditionProfile, type NetworkConditionsState, type NetworkConnection } from "./store";
 export interface RemoteNetworkConditions {
     /** Identity of the connected device session, used to ignore stale UI completions. */
     targetId?: string;
     profile: NetworkConditionProfile | null;
+    state?: NetworkConditionsState;
+    onConnectionChange?(connection: NetworkConnection): Promise<unknown>;
     available: boolean;
     onChange(profile: NetworkConditionProfile): Promise<unknown>;
 }
-export declare function NetworkConditionsControl({ remote }: {
+export declare function NetworkConditionsControl({ remote, compact }: {
     remote?: RemoteNetworkConditions;
+    compact?: boolean;
 }): import("react").JSX.Element;
 //# sourceMappingURL=NetworkConditionsControl.d.ts.map

package/lib/typescript/network/conditions/NetworkFloatingTool.d.ts

@@ -1,5 +1,5 @@
 import { type FloatingToolRenderContext } from "@buoy-gg/shared-ui";
-import type { RemoteNetworkConditions } from "./NetworkConditionsControl";
+import { type RemoteNetworkConditions } from "./NetworkConditionsControl";
 /** A live source keeps the desktop strip current after its launching panel closes. */
 export declare function createRemoteConditionsSource(): {
     getSnapshot: () => RemoteNetworkConditions | undefined;
@@ -8,9 +8,10 @@ export declare function createRemoteConditionsSource(): {
 };
 type RemoteSource = ReturnType<typeof createRemoteConditionsSource>;
 export declare function registerLocalNetworkFloatingTool(): () => void;
-export declare function openNetworkFloatingTool(source?: RemoteSource): void;
-export declare function NetworkFloatingTool({ id, revealToken, dismiss, source }: FloatingToolRenderContext & {
+export declare function openNetworkFloatingTool(source?: RemoteSource, showControls?: boolean): void;
+export declare function NetworkFloatingTool({ id, revealToken, dismiss, source, showControls }: FloatingToolRenderContext & {
     source?: RemoteSource;
+    showControls?: boolean;
 }): import("react").JSX.Element;
 export {};
 //# sourceMappingURL=NetworkFloatingTool.d.ts.map

package/lib/typescript/network/conditions/connectivity/netInfoFacade.d.ts

@@ -0,0 +1,3 @@
+/** Public reads also need masking when a custom reachability probe updates the cache. */
+export declare function wrapNetInfoApi(api: Record<string, any>): void;
+//# sourceMappingURL=netInfoFacade.d.ts.map

package/lib/typescript/network/conditions/connectivity/patchNetwork.d.ts

@@ -0,0 +1,24 @@
+import type { NetworkConnection } from "../profiles";
+export interface ConnectionState {
+    type?: string;
+    details?: unknown;
+    isConnected?: boolean | null;
+    isInternetReachable?: boolean | null;
+}
+export interface ConnectivityModule {
+    getCurrentState(requestedInterface?: string): Promise<ConnectionState>;
+    eventEmitter: {
+        addListener(event: string, listener: (state: ConnectionState) => void): {
+            remove(): void;
+        };
+        listenerCount?(event: string): number;
+    };
+}
+export declare function maskConnection(state: ConnectionState, mode: NetworkConnection, expo?: boolean): ConnectionState;
+/** Install before the library creates any state managers or app listeners. */
+export declare function patchConnectionState(native: ConnectivityModule, mode: () => NetworkConnection, subscribe: (listener: () => void) => () => void, options?: {
+    eventName?: string;
+    expo?: boolean;
+    receiver?: object;
+}): () => void;
+//# sourceMappingURL=patchNetwork.d.ts.map

package/lib/typescript/network/conditions/pacer.d.ts

@@ -0,0 +1,16 @@
+import type { UploadCap } from "./profiles";
+export declare const chunkSize: (rate: number) => number;
+export declare const utf8Length: (text: string) => number;
+/** Returns null when the native encoder owns a body whose byte size is unknown. */
+export declare function bodyByteLength(body: unknown): number | null;
+/** The upload is a pre-send simulation. No bytes are sent during these ticks. */
+export declare function paceByteCount(bytes: number, rate: number, signal?: AbortSignal | null, progress?: (loaded: number, total: number) => void): Promise<void>;
+export declare function uploadBodySize(input: RequestInfo | URL, init?: RequestInit): UploadCap;
+/** Inspect sizes only. Never read a stream, open a URI, or alter the body. */
+export declare function uploadSize(body: unknown): UploadCap;
+/** Carry timer overshoot forward, but never bank idle time between reads. */
+export declare function createBytePacer(rate: number): (bytes: number, signal?: AbortSignal | null) => Promise<void>;
+export declare function pacedStream(source: ReadableStream<Uint8Array>, rate: number, signal?: AbortSignal | null, observe?: (chunk: Uint8Array | null, error?: unknown) => void): ReadableStream<Uint8Array<ArrayBufferLike>>;
+/** Wrap body delivery without assuming RN's Response constructor accepts streams. */
+export declare function paceResponse(response: Response, rate: number, signal?: AbortSignal | null, observe?: (chunk: Uint8Array | null, error?: unknown) => void, noBody?: boolean): Response;
+//# sourceMappingURL=pacer.d.ts.map

package/lib/typescript/network/conditions/profiles.d.ts

@@ -0,0 +1,57 @@
+export declare const NETWORK_CONDITIONS: {
+    readonly normal: {
+        readonly label: "Normal";
+        readonly delayMs: 0;
+    };
+    readonly offline: {
+        readonly label: "Offline (requests)";
+        readonly delayMs: 0;
+    };
+    readonly slow: {
+        readonly label: "Slow (+500 ms)";
+        readonly delayMs: 500;
+    };
+    readonly verySlow: {
+        readonly label: "Very slow (+2000 ms)";
+        readonly delayMs: 2000;
+    };
+    readonly slow3g: {
+        readonly label: "Slow 3G";
+        readonly delayMs: 2000;
+        readonly downloadBytesPerSecond: 50000;
+        readonly uploadBytesPerSecond: 50000;
+    };
+    readonly slow4g: {
+        readonly label: "Slow 4G";
+        readonly delayMs: 562.5;
+        readonly downloadBytesPerSecond: 180000;
+        readonly uploadBytesPerSecond: 84375;
+    };
+    readonly fast4g: {
+        readonly label: "Fast 4G";
+        readonly delayMs: 165;
+        readonly downloadBytesPerSecond: 1012500;
+        readonly uploadBytesPerSecond: 168750;
+    };
+};
+export type NetworkConditionProfile = keyof typeof NETWORK_CONDITIONS;
+export type NetworkConnection = "auto" | "real" | "offline" | "wifi" | "cellular" | "noInternet";
+export declare const CONNECTIONS: NetworkConnection[];
+export interface NetworkConditionStamp {
+    readonly profile: NetworkConditionProfile;
+    readonly delayMs: number;
+    readonly downloadBytesPerSecond?: number;
+    readonly uploadBytesPerSecond?: number;
+    readonly uploadCap?: UploadCap;
+}
+export interface UploadCap {
+    readonly knownBytes: number;
+    readonly status: "applied" | "partial" | "not-applied";
+    readonly note?: string;
+}
+export declare const CONDITIONS_SCOPE: {
+    download: string;
+    upload: string;
+    transports: string;
+};
+//# sourceMappingURL=profiles.d.ts.map

package/lib/typescript/network/conditions/remoteState.d.ts

@@ -0,0 +1,4 @@
+import type { NetworkConditionsState } from "./store";
+/** A new runtime needs a fresh read; old snapshots cannot rearm its controls. */
+export declare function chooseConditionsSnapshot(confirmed: NetworkConditionsState | null, snapshot?: NetworkConditionsState): NetworkConditionsState | null;
+//# sourceMappingURL=remoteState.d.ts.map

package/lib/typescript/network/conditions/store.d.ts

@@ -1,26 +1,52 @@
-export declare const NETWORK_CONDITIONS: {
-    readonly normal: {
-        readonly label: "Normal";
-        readonly delayMs: 0;
-    };
-    readonly offline: {
-        readonly label: "Offline (requests)";
-        readonly delayMs: 0;
-    };
-    readonly slow: {
-        readonly label: "Slow (+500 ms)";
-        readonly delayMs: 500;
+import { type NetworkConditionProfile, type NetworkConnection, type NetworkConditionStamp } from "./profiles";
+export { NETWORK_CONDITIONS, CONDITIONS_SCOPE } from "./profiles";
+export type { NetworkConditionProfile, NetworkConnection, NetworkConditionStamp } from "./profiles";
+export interface ConnectionSupport {
+    supported: boolean;
+    reason?: string;
+}
+declare const connectionSupport: {
+    netInfo: ConnectionSupport;
+    expoNetwork: ConnectionSupport;
+};
+export declare const getNetworkConnection: () => NetworkConnection;
+export declare const getConditionsRevision: () => number;
+export declare const getEffectiveNetworkConnection: () => "real" | "offline" | "wifi" | "cellular" | "noInternet";
+export declare const networkConditionsActive: () => boolean;
+export declare function setConnectionSupport(key: keyof typeof connectionSupport, value: ConnectionSupport): void;
+export declare function getNetworkConditions(): {
+    version: 2;
+    runtimeId: string;
+    revision: number;
+    profile: "offline" | "normal" | "slow" | "verySlow" | "slow3g" | "slow4g" | "fast4g";
+    connection: NetworkConnection;
+    available: boolean;
+    active: boolean;
+    delayMs: number;
+    downloadBytesPerSecond: number | null;
+    uploadBytesPerSecond: number | null;
+    capabilities: {
+        fetch: string;
+        xhr: string;
+        upload: string;
+        webSocket: string;
+        nativeImages: boolean;
+        nativeModules: boolean;
+        netInfo: ConnectionSupport;
+        expoNetwork: ConnectionSupport;
     };
-    readonly verySlow: {
-        readonly label: "Very slow (+2000 ms)";
-        readonly delayMs: 2000;
+    scope: {
+        download: string;
+        upload: string;
+        transports: string;
     };
 };
-export type NetworkConditionProfile = keyof typeof NETWORK_CONDITIONS;
-export interface NetworkConditionStamp {
-    readonly profile: NetworkConditionProfile;
-    readonly delayMs: number;
+export type NetworkConditionsState = ReturnType<typeof getNetworkConditions>;
+export interface NetworkConditionsChange {
+    profile?: NetworkConditionProfile;
+    connection?: NetworkConnection;
 }
+export declare function setNetworkConditions(value?: unknown): NetworkConditionsState;
 export declare const networkConditionsRuntimeId: string;
 export declare const conditionsCanApply: () => boolean;
 export declare const getNetworkCondition: () => NetworkConditionProfile;

package/lib/typescript/network/conditions/xhr.d.ts

@@ -1,5 +1,5 @@
 import type { OverrideOutcome } from "../overrides/types";
 import type { NetworkConditionStamp } from "./store";
 /** Active simulation uses a send-to-completion deadline, including the wait. */
-export declare function runConditionXhr(target: XMLHttpRequest, url: string, condition: NetworkConditionStamp, outcome: OverrideOutcome | null, dispatch: () => void): void;
+export declare function runConditionXhr(target: XMLHttpRequest, url: string, condition: NetworkConditionStamp, outcome: OverrideOutcome | null, dispatch: () => void, body?: unknown): void;
 //# sourceMappingURL=xhr.d.ts.map

package/lib/typescript/network/hooks/useSocketsState.d.ts

@@ -0,0 +1,3 @@
+import type { SocketsState } from "../sockets/types";
+export declare function useSocketsState(paused?: boolean): SocketsState;
+//# sourceMappingURL=useSocketsState.d.ts.map

package/lib/typescript/network/overrides/engine.d.ts

@@ -3,6 +3,10 @@ export interface OverrideHooks {
     getRules: () => readonly OverrideRule[];
     /** The rule APPLIED to a request. */
     recordHit: (ruleId: string) => void;
+    /** Resolves once saved rules are loaded (a request at app start waits for it). */
+    ready?: () => Promise<void>;
+    /** True once saved rules are loaded, for callers that can't wait on a promise first. */
+    isReady?: () => boolean;
     /**
      * The rule MATCHED a request, whether or not it applied.
      *
@@ -12,6 +16,16 @@ export interface OverrideHooks {
     recordMatch: (ruleId: string) => void;
 }
 export declare function setOverrideHooks(next: OverrideHooks | null): void;
+/**
+ * Wait for saved rules before an async request decides. At app start the
+ * rules are still loading; a loaded bug case's sandbox would otherwise miss
+ * the app's first calls and let them reach real servers.
+ */
+export declare function overrideRulesReady(): Promise<void>;
+/** Whether saved rules are loaded yet. */
+export declare function overrideRulesLoaded(): boolean;
+/** Whether any rule reads the request body (a body match or a GraphQL operation). */
+export declare function overrideRulesNeedBody(): boolean;
 /**
  * Whether a rule stored right now could ever be applied to a request.
  *

package/lib/typescript/network/overrides/matchRule.d.ts

@@ -17,6 +17,9 @@ import type { OverrideRule } from "./types";
  */
 export declare function escapeRegex(pattern: string): string;
 export declare function compilePattern(pattern: string): RegExp;
+/** A GraphQL JSON body (one operation or a batch) that names `operation`. */
+/** JSON with object keys sorted at every level, so equal values give equal text. */
+export declare function canonicalJson(value: unknown): string;
 /** Does this rule apply to this request? Ignores `enabled` — callers check it. */
 export declare function ruleMatches(rule: OverrideRule, url: string, method: string, headers?: Record<string, string>, body?: string): boolean;
 //# sourceMappingURL=matchRule.d.ts.map

package/lib/typescript/network/overrides/overrideRulesStore.d.ts

@@ -111,6 +111,12 @@ declare class OverrideRulesStore {
      * needs no second check.
      */
     getRules(): readonly OverrideRule[];
+    /** Another tab loaded a bug case, and this tab hasn't got its block yet. */
+    private otherTabCase;
+    /** At page load, or another tab wrote or removed its loaded case. */
+    caseLockChanged(): void;
+    private sandboxCache;
+    private sandboxOnly;
     /**
      * The rule's real body, fetching it from the device when this surface only
      * has the stripped copy (see `OverrideRule.bodyOmitted`).
@@ -172,6 +178,7 @@ declare class OverrideRulesStore {
      * because a rule has to fire from app boot — with the Network tool closed and
      * nothing capturing. On the web `loadNow` has usually done it already.
      */
+    isLoaded(): boolean;
     ensureLoaded(): Promise<void>;
     /**
      * Web only: read the saved rules from localStorage right now.
@@ -216,7 +223,22 @@ declare class OverrideRulesStore {
      * morning") and not the failure mode it was built for.
      */
     noteHealthyLaunch(): void;
+    private persisted;
+    /**
+     * Writes go to disk one at a time, in order. Otherwise an older save still
+     * in flight could land after a newer one and put old rules back (a loaded
+     * case's block gone after a reload, Codex review round 10).
+     */
+    private writes;
     private persist;
+    /**
+     * Save the rules now and say whether they reached disk. A loaded bug case
+     * needs this: if its block rules only live in memory, a reload brings the
+     * case's state back with nothing blocking real calls (Codex review round 9).
+     * Waits for every earlier write, so none can land after it, and gives up
+     * (false) after SAVE_CHECK_MS.
+     */
+    saveChecked(): Promise<boolean>;
     private emit;
 }
 /** Singleton — one rule list per JS runtime. */

package/lib/typescript/network/overrides/types.d.ts

@@ -89,6 +89,39 @@ export interface OverrideRule {
      * asked first. A body that isn't text (FormData, a Blob) never matches.
      */
     bodyIncludes?: string;
+    /**
+     * Only GraphQL requests whose JSON body names this `operationName` (or a
+     * batch that holds it). Parsed, not matched as text, so spacing and key
+     * order in the body don't matter.
+     */
+    graphqlOperation?: string;
+    /**
+     * With graphqlOperation: only when that operation's `variables` equal this,
+     * written as JSON with its keys sorted (see canonicalJson). Parsed, so
+     * spacing and key order don't matter. Missing variables count as {}.
+     */
+    graphqlVariables?: string;
+    /**
+     * Only requests whose body is JSON equal to this, written with its keys
+     * sorted (see canonicalJson). Parsed, so spacing and key order don't matter.
+     * For REST calls that share one URL but differ by body, like
+     * `POST /search {"q":"fries"}` and `{"q":"pie"}`: a bug case's replay gives
+     * each body its own answer.
+     */
+    bodyJson?: string;
+    /**
+     * With `graphqlOperation`: only a single operation, never a batch (an
+     * array body). A bug case recorded the call alone, so its answer is one
+     * result, and a batch would get the wrong shape back.
+     */
+    graphqlSingle?: boolean;
+    /**
+     * Part of a loaded bug case's sandbox (bug links). Such a rule keeps
+     * applying while Buoy's account access is off, because the case's data is
+     * in the app either way and must not reach a real server, and it is never
+     * auto-paused at launch. Release builds still never apply any rule.
+     */
+    sandbox?: boolean;
     kind: OverrideRuleKind;
     /** `respond` only. Clamped to [STATUS_MIN, STATUS_MAX]. Defaults to 200. */
     status?: number;

package/lib/typescript/network/sockets/findProblems.d.ts

@@ -0,0 +1,31 @@
+import type { SocketConnection, SocketFrame, SocketProblem } from "./types";
+/**
+ * The problems the Sockets screen turns red, and the MCP reports. Pure: the
+ * same frames give the same answer on the phone, on Desktop and in a test.
+ *
+ * Every rule here needs PROOF in the frames, because a false alarm teaches
+ * people to ignore the red. That is why "no reply" only fires for a message
+ * type that has been answered before: Haiven puts a `requestId` on typing
+ * messages too, and the server never answers those.
+ */
+/** A request with no reply after this long is flagged. Haiven's own timeout. */
+export declare const REPLY_TIMEOUT_MS = 10000;
+/** More than this many opens to one URL inside STORM_WINDOW_MS is a storm. */
+export declare const STORM_OPENS = 3;
+export declare const STORM_WINDOW_MS = 15000;
+/** This many sockets in a row to one URL that never opened: the app can't connect. */
+export declare const CANT_CONNECT_TRIES = 3;
+/** This many sign-in failures to one URL inside AUTH_WINDOW_MS is a loop. */
+export declare const AUTH_FAILURES = 3;
+export declare const AUTH_WINDOW_MS = 120000;
+/** A socket open this long without a sign-in failure signed in: it ends a run of failures. */
+export declare const SIGNED_IN_MS = 30000;
+/**
+ * The message types that have been answered at least once, per socket URL.
+ * Built from the frames, so it survives nothing and needs no setup.
+ */
+export declare function answeredTypes(frames: SocketFrame[], connections: Map<string, SocketConnection>): Map<string, Set<string>>;
+export declare function findProblems(frames: SocketFrame[], connectionList: SocketConnection[], now: number, 
+/** Types answered before this capture's frames were cut (kept by the store). */
+knownAnswered?: Map<string, Set<string>>): SocketProblem[];
+//# sourceMappingURL=findProblems.d.ts.map

package/lib/typescript/network/sockets/foldFrames.d.ts

@@ -0,0 +1,50 @@
+import type { SocketFrame, SocketProblem, SocketsState } from "./types";
+/**
+ * What the Sockets list shows, from the store's frames. Pure.
+ *
+ * Two kinds of noise fold away so a chat socket reads like a conversation:
+ * heartbeats (counted on the socket card instead) and a burst of the same
+ * message (`chat.typing` ×18 becomes one row; a tap shows each one).
+ */
+/** Same-type messages closer together than this fold into one row... */
+export declare const BURST_GAP_MS = 1500;
+/** ...when there are at least this many. Two chats a second apart are a conversation. */
+export declare const FOLD_MIN = 3;
+export interface SocketRow {
+    /** The newest frame of the row. Tapping the row opens it. */
+    frame: SocketFrame;
+    /** How many frames the row stands for (1 unless it's a burst). */
+    count: number;
+    /** A burst's oldest frame id. It stays the same as the burst grows, so it names the burst for `expanded`. */
+    foldKey?: string;
+    /** The first problem any of its frames is part of. */
+    problem?: SocketProblem;
+}
+export type SocketListFilter = {
+    kind: "all";
+} | {
+    kind: "problems";
+} | {
+    kind: "direction";
+    direction: "in" | "out";
+} | {
+    kind: "type";
+    prefix: string;
+};
+export interface FoldOptions {
+    socketId?: string | null;
+    filter?: SocketListFilter;
+    showPings?: boolean;
+    search?: string;
+    /** Bursts (by `foldKey`) shown one row per message. */
+    expanded?: ReadonlySet<string>;
+}
+export declare function foldFrames(state: Pick<SocketsState, "frames" | "problems">, opts?: FoldOptions): SocketRow[];
+/**
+ * A chip's prefix matches its family: `auth.` matches `auth.success` and the
+ * bare `auth` too, so one chip covers both.
+ */
+export declare function matchesPrefix(type: string | undefined, prefix: string): boolean;
+/** The busiest message names, for the filter chips: `chat.*`, `presence.*`. */
+export declare function topTypePrefixes(frames: SocketFrame[], max?: number): string[];
+//# sourceMappingURL=foldFrames.d.ts.map

package/lib/typescript/network/sockets/format.d.ts

@@ -0,0 +1,19 @@
+import type { SocketConnection, SocketFrame } from "./types";
+/** `10:14:52` */
+export declare function clockTime(ms: number): string;
+/** `42ms`, `3.2s`, `2m 14s`, `1h 3m` */
+export declare function shortDuration(ms: number): string;
+/** `wss://api.x/v0/ws` → `api.x/v0/ws` */
+export declare function shortUrl(url: string): string;
+/**
+ * `Closed 1006 · lost connection`. A 1006 on a socket that never opened was
+ * refused or turned away, so it says `couldn't connect` instead.
+ */
+export declare function closeLabel(code: number | undefined, neverOpened?: boolean): string;
+/** The connection card's status line, e.g. `Open 2m 14s`. */
+export declare function connectionStatus(conn: SocketConnection, now: number): string;
+/** A one-line preview of a message for a row. */
+export declare function previewText(frame: SocketFrame): string;
+/** Pretty JSON for the detail view, or the text as it came. */
+export declare function prettyData(frame: SocketFrame): string;
+//# sourceMappingURL=format.d.ts.map

package/lib/typescript/network/sockets/readMessage.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Turn one raw socket message into what the list shows: its name, the id that
+ * ties it to a reply, whether it's a heartbeat, and its text with secrets
+ * hidden. Pure, so the rules can be argued with in a unit test.
+ *
+ * Secrets are hidden BEFORE the message is stored, because the store feeds the
+ * Desktop mirror and the MCP: a token that reaches the store has already left.
+ */
+/** Longest message text kept. Longer ones are cut and marked `truncated`. */
+export declare const MAX_FRAME_CHARS: number;
+export declare const HIDDEN = "[hidden]";
+/**
+ * Longer messages are not parsed: parsing, hiding and printing 5 MB on every
+ * message would stall the app. Their first MAX_FRAME_CHARS are scrubbed as text.
+ */
+export declare const MAX_PARSE_CHARS: number;
+export interface ReadMessage {
+    data: string;
+    size: number;
+    binary?: boolean;
+    truncated?: boolean;
+    json?: boolean;
+    type?: string;
+    correlationId?: string;
+    ping?: boolean;
+    /** Carries a field only replies have (see REPLY_KEYS). */
+    replyShaped?: boolean;
+}
+/** Hide every value under a secret key, and any JWT anywhere. */
+export declare function hideSecrets(value: unknown, depth?: number): unknown;
+/**
+ * Text that couldn't be parsed, with secrets hidden as well as text allows:
+ * every JWT, and the value after any secret-looking key (`"token":"x"`, `pass=x`).
+ */
+export declare function scrubText(text: string, depth?: number): string;
+/** A URL with secret query values hidden: `wss://x/ws?token=[hidden]`. */
+export declare function hideUrlSecrets(rawUrl: string): string;
+/** `/v0/ws` part of a URL: what makes two sockets "the same socket". */
+export declare function socketKey(url: string): string;
+export declare function readMessage(raw: unknown): ReadMessage;
+//# sourceMappingURL=readMessage.d.ts.map