@beeuni/sdk 0.1.0

package/dist/react/use-reminders.d.ts

@@ -0,0 +1,501 @@
+import { type SessionReminderRef } from '../core/rest/projects-client/index.js';
+export declare function useProjectReminders(projectId: string | null | undefined): {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: {
+        reminders: import("../index.js").ProjectReminder[];
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: {
+        reminders: import("../index.js").ProjectReminder[];
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        sessionId: string;
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, {
+        sessionId: string;
+        reminderId: string;
+    }, unknown>;
+    updateMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+        enabled: boolean;
+    }, unknown>;
+    removeMany: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminderBatchResult, Error, {
+        reminders: readonly SessionReminderRef[];
+    }, unknown>;
+    data: {
+        reminders: import("../index.js").ProjectReminder[];
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").ProjectReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};
+export declare function useSessionReminders(projectId: string | null | undefined, sessionId: string | null | undefined): {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: {
+        reminders: import("../index.js").SessionReminder[];
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: {
+        reminders: import("../index.js").SessionReminder[];
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+} | {
+    update: import("@tanstack/react-query").UseMutationResult<import("../index.js").SessionReminder, Error, {
+        reminderId: string;
+        enabled: boolean;
+    }, unknown>;
+    remove: import("@tanstack/react-query").UseMutationResult<{
+        ok: boolean;
+    }, Error, string, unknown>;
+    data: {
+        reminders: import("../index.js").SessionReminder[];
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        reminders: import("../index.js").SessionReminder[];
+    }, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+};

package/dist/react/use-reminders.js

@@ -0,0 +1,51 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { deleteSessionReminder, deleteSessionReminders, listProjectReminders, listSessionReminders, updateSessionReminder, updateSessionReminders, } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useProjectReminders(projectId) {
+    const queryClient = useQueryClient();
+    const query = useQuery({
+        queryKey: qk.project.reminders(projectId ?? ''),
+        queryFn: () => listProjectReminders(projectId),
+        enabled: !!projectId,
+        ...contract('inventory'),
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey: qk.project.reminders(projectId ?? '') });
+    const update = useMutation({
+        mutationFn: (args) => updateSessionReminder(projectId, args.sessionId, args.reminderId, { enabled: args.enabled }),
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: (args) => deleteSessionReminder(projectId, args.sessionId, args.reminderId),
+        onSuccess: invalidate,
+    });
+    const updateMany = useMutation({
+        mutationFn: (args) => updateSessionReminders(projectId, args.reminders, { enabled: args.enabled }),
+        onSettled: invalidate,
+    });
+    const removeMany = useMutation({
+        mutationFn: (args) => deleteSessionReminders(projectId, args.reminders),
+        onSettled: invalidate,
+    });
+    return { ...query, update, remove, updateMany, removeMany };
+}
+export function useSessionReminders(projectId, sessionId) {
+    const queryClient = useQueryClient();
+    const query = useQuery({
+        queryKey: qk.project.sessionReminders(projectId ?? '', sessionId ?? ''),
+        queryFn: () => listSessionReminders(projectId, sessionId),
+        enabled: !!projectId && !!sessionId,
+        ...contract('inventory'),
+    });
+    const invalidate = () => queryClient.invalidateQueries({ queryKey: qk.project.reminders(projectId ?? '') });
+    const update = useMutation({
+        mutationFn: (args) => updateSessionReminder(projectId, sessionId, args.reminderId, { enabled: args.enabled }),
+        onSuccess: invalidate,
+    });
+    const remove = useMutation({
+        mutationFn: (reminderId) => deleteSessionReminder(projectId, sessionId, reminderId),
+        onSuccess: invalidate,
+    });
+    return { ...query, update, remove };
+}

package/dist/react/use-runtime-boot-stalled.d.ts

@@ -0,0 +1,2 @@
+export declare const RUNTIME_BOOT_STALL_MS = 45000;
+export declare function useRuntimeBootStalled(thresholdMs?: number): boolean;

package/dist/react/use-runtime-boot-stalled.js

@@ -0,0 +1,18 @@
+'use client';
+import { useEffect, useState } from 'react';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+import { START_INCONCLUSIVE_GIVE_UP_MS } from './use-session.js';
+export const RUNTIME_BOOT_STALL_MS = START_INCONCLUSIVE_GIVE_UP_MS;
+export function useRuntimeBootStalled(thresholdMs = RUNTIME_BOOT_STALL_MS) {
+    const bootingSinceAt = useSandboxConnectionStore((s) => s.bootingSinceAt);
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        if (bootingSinceAt === null)
+            return;
+        const interval = setInterval(() => setNow(Date.now()), 1_000);
+        return () => clearInterval(interval);
+    }, [bootingSinceAt]);
+    if (bootingSinceAt === null)
+        return false;
+    return now - bootingSinceAt >= thresholdMs;
+}

package/dist/react/use-runtime-phase.d.ts

@@ -0,0 +1,2 @@
+export type RuntimePhase = 'connecting' | 'booting' | 'ready' | 'unreachable';
+export declare function useRuntimePhase(): RuntimePhase;

package/dist/react/use-runtime-phase.js

@@ -0,0 +1,13 @@
+'use client';
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+export function useRuntimePhase() {
+    const status = useSandboxConnectionStore((s) => s.status);
+    const healthy = useSandboxConnectionStore((s) => s.healthy);
+    if (status === 'unreachable')
+        return 'unreachable';
+    if (healthy === true)
+        return 'ready';
+    if (status === 'connected')
+        return 'booting';
+    return 'connecting';
+}

package/dist/react/use-runtime-reconnect.d.ts

@@ -0,0 +1,52 @@
+import { type ProxyHop, type SessionHealthResponse } from '../core/session/index.js';
+import { type SandboxConnectionStatus } from '../browser/stores/sandbox-connection-store.js';
+export declare const FAIL_THRESHOLD_FIRST = 5;
+export declare const FAIL_THRESHOLD_RECONNECT = 2;
+export declare const POLL_CONNECTED = 30000;
+export declare const POLL_FAILING = 150;
+export declare const POLL_UNREACHABLE = 5000;
+export declare const POLL_RECHECK = 1000;
+export declare const POLL_PARKED = 15000;
+export declare const CHECK_TIMEOUT = 20000;
+export declare const RUNTIME_EVIDENCE_FRESH_MS = 15000;
+export declare function shouldIgnoreProbeFailure(lastRuntimeEvidenceAt: number | null, now: number): boolean;
+export declare function shouldCountProbeFailure(input: {
+    hop: ProxyHop | null;
+    lastRuntimeEvidenceAt: number | null;
+    nowMs: number;
+}): boolean;
+export declare function runtimeErrorFromHealth(health: SessionHealthResponse | null): string | null;
+export declare function isImmediateOfflineStatus(status: number): boolean;
+export declare function isImmediateOfflineSignal(status: number, body: string): boolean;
+export type ProbeOutcome = {
+    kind: 'auth-error';
+} | {
+    kind: 'booting';
+    health: SessionHealthResponse | null;
+} | {
+    kind: 'failure';
+    immediateOffline: boolean;
+    hop: ProxyHop | null;
+    upstreamStatus: number | null;
+} | {
+    kind: 'healthy';
+    health: SessionHealthResponse | null;
+};
+export interface ProbeResultLike {
+    status: number;
+    ok: boolean;
+    health: SessionHealthResponse | null;
+    body: string;
+    hop?: ProxyHop | null;
+    upstreamStatus?: number | null;
+}
+export declare function classifyProbeResult(result: ProbeResultLike): ProbeOutcome;
+export declare function computeFailureStatus(failCount: number, wasConnected: boolean, immediateOffline: boolean, failingForMs?: number): SandboxConnectionStatus | null;
+export declare function shouldHoldHealthy(input: {
+    healthy: boolean | null;
+    notReadySinceMs: number;
+    nowMs: number;
+    lastRuntimeEvidenceAt: number | null;
+}): boolean;
+export declare function nextPollDelay(status: SandboxConnectionStatus, healthy: boolean | null, parked?: boolean, failing?: boolean): number;
+export declare function useRuntimeReconnect(): void;