@rebasepro/client 0.17.3 → 0.18.1

package/src/like-pattern-redos.test.ts

@@ -1,61 +0,0 @@
-import { matchesOperator } from "./offline-query";
-
-/**
- * A `like` pattern is user input, and it becomes a regular expression.
- *
- * `%` translates to `[\s\S]*`, so `%%%%X` becomes four adjacent unbounded
- * quantifiers followed by a literal. On a subject that does not match, the
- * engine has to try every way of splitting the subject between them — which is
- * exponential. Twelve `%` against a forty-character value took **100 seconds**
- * on this machine before answering `false`.
- *
- * The pattern arrives over HTTP: `?title=like.%25%25%25…` is a public filter
- * operator, listed in the operator table. On the offline evaluator that freezes
- * the tab; the same translation in the Mongo driver hands the expression to the
- * database, where it occupies a server thread instead.
- *
- * Consecutive `%` mean exactly what one `%` means, so collapsing a run is
- * semantics-preserving and removes the ambiguity the backtracking feeds on.
- */
-const HOSTILE = "%".repeat(14) + "X";
-const SUBJECT = "a".repeat(48);
-
-describe("like patterns cannot be made to backtrack", () => {
-    it("answers a hostile pattern promptly", () => {
-        const started = Date.now();
-        const result = matchesOperator(SUBJECT, "like", HOSTILE);
-        const elapsed = Date.now() - started;
-
-        expect(result).toBe(false);
-        expect(elapsed).toBeLessThan(1000);
-    });
-
-    it("answers the case-insensitive form promptly too", () => {
-        const started = Date.now();
-        matchesOperator(SUBJECT, "ilike", HOSTILE);
-
-        expect(Date.now() - started).toBeLessThan(1000);
-    });
-
-    it("still means what LIKE means", () => {
-        expect(matchesOperator("post-1", "like", "post-%")).toBe(true);
-        expect(matchesOperator("post-1", "like", "%1")).toBe(true);
-        expect(matchesOperator("post-1", "like", "%st-%")).toBe(true);
-        expect(matchesOperator("post-1", "like", "other-%")).toBe(false);
-        // A run of wildcards is the same query as one wildcard.
-        expect(matchesOperator("post-1", "like", "post%%%%1")).toBe(true);
-        expect(matchesOperator("abc", "like", "a_c")).toBe(true);
-        expect(matchesOperator("abbc", "like", "a_c")).toBe(false);
-        // `_` is fixed-width, so a run of them still counts.
-        expect(matchesOperator("abc", "like", "a__")).toBe(true);
-        expect(matchesOperator("ab", "like", "a__")).toBe(false);
-    });
-
-    it("keeps an escaped percent literal", () => {
-        expect(matchesOperator("50%", "like", "50\\%")).toBe(true);
-        expect(matchesOperator("500", "like", "50\\%")).toBe(false);
-        // An escaped percent next to a wildcard is still a literal.
-        expect(matchesOperator("50%off", "like", "50\\%%")).toBe(true);
-        expect(matchesOperator("50off", "like", "50\\%%")).toBe(false);
-    });
-});

package/src/offline-codec.ts

@@ -1,79 +0,0 @@
-import { EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
-import { rebaseReviver } from "./reviver";
-
-/**
- * Lossless round-tripping of rows through the offline store.
- *
- * Both persistence backends move values by structured clone, which keeps
- * `Date` but flattens every class instance to a plain object. For
- * `EntityReference`/`EntityRelation` that is harmless — they carry their own
- * `__type` discriminator, so the JSON reviver can rebuild them — but
- * `GeoPoint` and `Vector` do not, and would come back out of the cache as
- * anonymous `{ latitude, longitude }` / `{ value }` bags. A row read from the
- * cache must be indistinguishable from the same row read from the network, so
- * those two are tagged on the way in and revived on the way out.
- *
- * Type tests here are structural rather than `instanceof`, because a structured
- * clone can arrive from another realm — an iframe, a worker, or the polyfill
- * the tests run against — where the constructor identity differs but the value
- * is the real thing. Only *plain* objects are walked; anything else is passed
- * through whole, so a class instance is never quietly reduced to `{}`.
- */
-
-function isDate(value: unknown): value is Date {
-    return Object.prototype.toString.call(value) === "[object Date]";
-}
-
-/** An object literal — not a Date, RegExp, Map, or any class instance. */
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-    const proto = Object.getPrototypeOf(value) as { constructor?: { name?: string } } | null;
-    if (proto === null || proto === Object.prototype) return true;
-    // A literal cloned out of another realm has a different `Object.prototype`
-    // but is still, in every way that matters here, a plain object.
-    return proto.constructor?.name === "Object";
-}
-
-function dehydrateValue(value: unknown): unknown {
-    if (value === null || value === undefined) return value;
-    if (value instanceof GeoPoint) {
-        return { __type: "GeoPoint", latitude: value.latitude, longitude: value.longitude };
-    }
-    if (value instanceof Vector) return { __type: "Vector", value: [...value.value] };
-    // EntityReference/EntityRelation already serialize themselves via `__type`
-    // own properties, so a structured clone is enough for the reviver below.
-    if (value instanceof EntityReference || value instanceof EntityRelation) return value;
-    if (Array.isArray(value)) return value.map(dehydrateValue);
-    if (isPlainObject(value)) {
-        const out: Record<string, unknown> = {};
-        for (const [key, inner] of Object.entries(value)) out[key] = dehydrateValue(inner);
-        return out;
-    }
-    return value;
-}
-
-function hydrateValue(value: unknown): unknown {
-    if (value === null || value === undefined || isDate(value)) return value;
-    if (Array.isArray(value)) return value.map(hydrateValue);
-    if (typeof value === "object") {
-        const revived = rebaseReviver("", value);
-        // The reviver recognised it — hand back the class instance untouched
-        // rather than walking into its (now private) internals.
-        if (revived !== value) return revived;
-        if (!isPlainObject(value)) return value;
-        const out: Record<string, unknown> = {};
-        for (const [key, inner] of Object.entries(value)) out[key] = hydrateValue(inner);
-        return out;
-    }
-    return value;
-}
-
-/** Prepare a row for the store. */
-export function dehydrateRow<T extends Record<string, unknown>>(row: T): Record<string, unknown> {
-    return dehydrateValue(row) as Record<string, unknown>;
-}
-
-/** Restore a row read back from the store. */
-export function hydrateRow<T extends Record<string, unknown>>(row: Record<string, unknown>): T {
-    return hydrateValue(row) as T;
-}

package/src/offline-connectivity.test.ts

@@ -1,191 +0,0 @@
-import {
-    ConnectivityMonitor,
-    isDuplicateKeyError,
-    isNetworkError,
-    isRetryableError
-} from "./offline-connectivity";
-import { RebaseApiError } from "./transport";
-
-/**
- * The monitor decides whether a request is worth sending at all, so getting it
- * wrong is either an app that hangs on every read during an outage, or one that
- * never notices the network came back.
- */
-describe("network error classification", () => {
-    it("recognises a request that never reached the server", () => {
-        expect(isNetworkError(new TypeError("Failed to fetch"))).toBe(true);
-        expect(isNetworkError(new TypeError("fetch failed"))).toBe(true);
-        expect(isNetworkError(Object.assign(new Error("aborted"), { name: "AbortError" }))).toBe(true);
-        expect(isNetworkError(Object.assign(new Error("timed out"), { name: "TimeoutError" }))).toBe(true);
-        expect(isNetworkError(new RebaseApiError("no response", { status: 0 }))).toBe(true);
-    });
-
-    it("does not mistake a server's answer for a dead network", () => {
-        expect(isNetworkError(new RebaseApiError("nope", { status: 403 }))).toBe(false);
-        expect(isNetworkError(new RebaseApiError("boom", { status: 500 }))).toBe(false);
-        // A programming error must propagate, not be swallowed as "offline".
-        expect(isNetworkError(new RangeError("bug"))).toBe(false);
-    });
-
-    it("retries what will pass and gives up on what will not", () => {
-        expect(isRetryableError(new TypeError("Failed to fetch"))).toBe(true);
-        expect(isRetryableError(new RebaseApiError("busy", { status: 429 }))).toBe(true);
-        expect(isRetryableError(new RebaseApiError("down", { status: 503 }))).toBe(true);
-        expect(isRetryableError(new RebaseApiError("gateway", { status: 502 }))).toBe(true);
-
-        expect(isRetryableError(new RebaseApiError("invalid", { status: 400 }))).toBe(false);
-        expect(isRetryableError(new RebaseApiError("denied", { status: 403 }))).toBe(false);
-        expect(isRetryableError(new RebaseApiError("gone", { status: 404 }))).toBe(false);
-        // A 500 is far more often a bug the same payload will hit again than a
-        // blip, and retrying it forever jams every write queued behind it.
-        expect(isRetryableError(new RebaseApiError("boom", { status: 500 }))).toBe(false);
-    });
-
-    it("retries a write the server is still answering, and only that 409", () => {
-        // The server's own message says to retry — "its result will be
-        // replayed" — and a key whose claim outlived the process that took it
-        // is refused until the lease expires. Giving up instead rolls back a
-        // write that retrying would have completed.
-        expect(isRetryableError(new RebaseApiError("in progress", {
-            status: 409, code: "IDEMPOTENCY_KEY_IN_PROGRESS"
-        }))).toBe(true);
-        // Every other 409 is a real conflict and stays fatal.
-        expect(isRetryableError(new RebaseApiError("row exists", { status: 409, code: "23505" }))).toBe(false);
-        expect(isRetryableError(new RebaseApiError("conflict", { status: 409 }))).toBe(false);
-        expect(isRetryableError(new RebaseApiError("reused", {
-            status: 422, code: "IDEMPOTENCY_KEY_REUSED"
-        }))).toBe(false);
-    });
-
-    it("does not read an unanswered write as a row that is already there", () => {
-        // The status alone cannot decide it. Read as a duplicate, the queue
-        // went looking for a row that was never written, found nothing,
-        // concluded there was nothing left to do and deleted the write.
-        expect(isDuplicateKeyError(new RebaseApiError("in progress", {
-            status: 409, code: "IDEMPOTENCY_KEY_IN_PROGRESS"
-        }))).toBe(false);
-
-        expect(isDuplicateKeyError(new RebaseApiError("dup", { status: 400, code: "23505" }))).toBe(true);
-        expect(isDuplicateKeyError(new RebaseApiError("conflict", { status: 409 }))).toBe(true);
-        expect(isDuplicateKeyError(new RebaseApiError("gone", { status: 404 }))).toBe(false);
-    });
-});
-
-describe("ConnectivityMonitor", () => {
-    function createMonitor(overrides: Partial<ConstructorParameters<typeof ConnectivityMonitor>[0]> = {}) {
-        let now = 1_000_000;
-        const timers: { fn: () => void; at: number }[] = [];
-        const monitor = new ConnectivityMonitor({
-            initialBackoffMs: 100,
-            maxBackoffMs: 800,
-            now: () => now,
-            setTimer: ((fn: () => void, ms: number) => {
-                timers.push({ fn, at: now + ms });
-                return timers.length as unknown as ReturnType<typeof setTimeout>;
-            }) as never,
-            clearTimer: (() => undefined) as never,
-            ...overrides
-        });
-        const advance = (ms: number) => {
-            now += ms;
-            for (const timer of timers.splice(0)) {
-                if (timer.at <= now) timer.fn();
-                else timers.push(timer);
-            }
-        };
-        return { monitor, advance, at: () => now };
-    }
-
-    it("starts willing to try", () => {
-        const { monitor } = createMonitor();
-        expect(monitor.isOnline()).toBe(true);
-        expect(monitor.shouldAttempt()).toBe(true);
-    });
-
-    it("stops attempting after a failure, until the backoff window opens", () => {
-        const { monitor, advance } = createMonitor();
-        monitor.markFailure();
-
-        expect(monitor.isOnline()).toBe(false);
-        // This is the whole point: the second read during an outage costs
-        // nothing instead of another timeout.
-        expect(monitor.shouldAttempt()).toBe(false);
-
-        advance(200);
-        expect(monitor.shouldAttempt()).toBe(true);
-    });
-
-    it("doubles the delay on repeated failures and caps it", () => {
-        const { monitor, advance } = createMonitor();
-        monitor.markFailure();
-        const first = monitor.msUntilRetry();
-        advance(first);
-
-        monitor.markFailure();
-        const second = monitor.msUntilRetry();
-        expect(second).toBeGreaterThan(first);
-
-        for (let i = 0; i < 10; i++) {
-            advance(monitor.msUntilRetry());
-            monitor.markFailure();
-        }
-        // 800 plus the 20% jitter ceiling.
-        expect(monitor.msUntilRetry()).toBeLessThanOrEqual(800 * 1.2);
-    });
-
-    it("resets the backoff once a request gets through", () => {
-        const { monitor, advance } = createMonitor();
-        monitor.markFailure();
-        advance(monitor.msUntilRetry());
-        monitor.markFailure();
-        monitor.markSuccess();
-
-        expect(monitor.isOnline()).toBe(true);
-        expect(monitor.shouldAttempt()).toBe(true);
-        monitor.markFailure();
-        // Back to the initial delay, not to where the doubling had reached.
-        expect(monitor.msUntilRetry()).toBeLessThanOrEqual(100 * 1.2);
-    });
-
-    it("fires the retry hook when the window opens", () => {
-        const { monitor, advance } = createMonitor();
-        let retries = 0;
-        monitor.onRetryDue = () => { retries++; };
-
-        monitor.markFailure();
-        expect(retries).toBe(0);
-        advance(200);
-        expect(retries).toBe(1);
-    });
-
-    it("backs off without claiming the connection is gone", () => {
-        const { monitor } = createMonitor();
-        // A 429 means the server answered — the app is demonstrably online and
-        // an "offline" badge would be a lie.
-        monitor.deferRetry();
-        expect(monitor.isOnline()).toBe(true);
-        expect(monitor.shouldAttempt()).toBe(true);
-    });
-
-    it("notifies listeners on each transition, and only on transitions", () => {
-        const { monitor } = createMonitor();
-        const seen: boolean[] = [];
-        monitor.onChange((online) => seen.push(online));
-
-        monitor.markFailure();
-        monitor.markFailure();
-        monitor.markSuccess();
-        monitor.markSuccess();
-
-        expect(seen).toEqual([false, true]);
-    });
-
-    it("keeps attempting when backoff suppression is off", () => {
-        // Without a retry timer nothing would ever reopen the window, so
-        // suppressing attempts would strand the client offline forever.
-        const { monitor } = createMonitor({ respectBackoff: false });
-        monitor.markFailure();
-        expect(monitor.isOnline()).toBe(false);
-        expect(monitor.shouldAttempt()).toBe(true);
-    });
-});

package/src/offline-connectivity.ts

@@ -1,255 +0,0 @@
-import { RebaseApiError } from "./transport";
-
-/**
- * Whether the network is worth trying, and when to try again after it wasn't.
- *
- * `navigator.onLine` is necessary but not sufficient: it reports the state of
- * the network interface, so it stays `true` behind a captive portal, on a
- * connection that resolves DNS but reaches nothing, and while the API itself
- * is down. This tracks what actually happened to requests as well, so the
- * first failure is the only one an app pays for — everything after it inside
- * the backoff window skips the doomed round trip and answers from the local
- * store immediately, which is the difference between an app that freezes when
- * the wifi drops and one that does not.
- */
-
-/** The request never reached the server, so nothing was decided by it. */
-export function isNetworkError(error: unknown): boolean {
-    if (error instanceof RebaseApiError) {
-        // A 0 status is what a transport reports when it has no response at all.
-        return error.status === 0;
-    }
-    // fetch rejects with TypeError on network failure in every runtime we
-    // support (browsers: "Failed to fetch"/"Load failed"; undici: "fetch
-    // failed").
-    if (error instanceof TypeError) return true;
-    const name = (error as { name?: string } | undefined)?.name;
-    // AbortError covers both an explicit abort and a fetch timeout; the others
-    // are what Node and Safari surface for a dropped connection.
-    return name === "AbortError" || name === "TimeoutError" || name === "NetworkError";
-}
-
-/**
- * Statuses that mean "not now" rather than "not ever": a queued write that
- * gets one of these is worth replaying, while a 400 or a 403 never will be.
- * 500 is deliberately absent — an unhandled server error is far more often a
- * bug the same payload will hit again than a blip, and retrying it forever
- * jams every write behind it.
- */
-const RETRYABLE_STATUSES = new Set([408, 425, 429, 502, 503, 504]);
-
-/**
- * The server holds this key for a request it has not answered yet.
- *
- * It is a 409 like a duplicate row is a 409, and nothing but the code separates
- * them — one means "your write is already there", the other means "your write
- * may not have happened at all, ask again".
- */
-const IDEMPOTENCY_IN_PROGRESS = "IDEMPOTENCY_KEY_IN_PROGRESS";
-
-/**
- * Is the server still answering an earlier attempt of this same write?
- *
- * The only correct response is to ask again — which is exactly what the
- * server's own message says, and exactly what this SDK used not to do.
- */
-export function isIdempotencyInProgressError(error: unknown): boolean {
-    return error instanceof RebaseApiError
-        && error.status === 409
-        && error.code === IDEMPOTENCY_IN_PROGRESS;
-}
-
-/** Is this failure worth another attempt later? */
-export function isRetryableError(error: unknown): boolean {
-    if (isNetworkError(error)) return true;
-    if (!(error instanceof RebaseApiError)) return false;
-    // The one 409 that resolves on its own. A key whose claim outlived the
-    // request that took it — the process was killed between the write and the
-    // answer — is refused until the claim's lease expires, and giving up on it
-    // means dropping a write that retrying would have completed.
-    if (isIdempotencyInProgressError(error)) return true;
-    return error.status !== undefined && RETRYABLE_STATUSES.has(error.status);
-}
-
-/**
- * Did this write fail because the row is already there?
- *
- * Matched on the SQLSTATE the server passes through (`23505`, unique_violation)
- * and on 409, never on the message — a duplicate-key message names the
- * constraint and the values, so it is neither stable nor safe to parse.
- *
- * The queue uses this to recognise its own earlier attempt. A create whose
- * response was lost is replayed, and for a row carrying an id the SDK generated
- * the server can only be rejecting it because the first attempt actually landed.
- *
- * Which is why the status alone cannot decide it: `IDEMPOTENCY_KEY_IN_PROGRESS`
- * is a 409 that means the opposite — the row may not exist at all. Read as a
- * duplicate, the queue looked for a row that was never written, found nothing,
- * concluded there was nothing left to do and deleted the write from the queue.
- */
-export function isDuplicateKeyError(error: unknown): boolean {
-    if (!(error instanceof RebaseApiError)) return false;
-    if (error.code === "23505") return true;
-    return error.status === 409 && !isIdempotencyInProgressError(error);
-}
-
-export interface ConnectivityOptions {
-    /** First retry delay after a failure. Defaults to 1 000 ms. */
-    initialBackoffMs?: number;
-    /** Ceiling for the doubling retry delay. Defaults to 60 000 ms. */
-    maxBackoffMs?: number;
-    /**
-     * Let a known-failed connection suppress further attempts until the
-     * backoff window opens. On by default — it is what makes a read or write
-     * during an outage instant instead of a timeout. Turn it off when nothing
-     * will ever wake the client up again (no retry timer, no `online` event),
-     * where suppressing attempts would mean never recovering.
-     */
-    respectBackoff?: boolean;
-    /** Injected for tests. */
-    now?: () => number;
-    /** Injected for tests; must return a handle `clearTimeout` accepts. */
-    setTimer?: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
-    clearTimer?: (handle: ReturnType<typeof setTimeout>) => void;
-}
-
-export class ConnectivityMonitor {
-    private state: "online" | "offline" = "online";
-    private backoffMs: number;
-    private readonly initialBackoffMs: number;
-    private readonly maxBackoffMs: number;
-    private retryAt = 0;
-    private timer?: ReturnType<typeof setTimeout>;
-    private listeners = new Set<(online: boolean) => void>();
-    private readonly respectBackoff: boolean;
-    private readonly now: () => number;
-    private readonly setTimer: (fn: () => void, ms: number) => ReturnType<typeof setTimeout>;
-    private readonly clearTimer: (handle: ReturnType<typeof setTimeout>) => void;
-    /** Called when the backoff window expires, to drive an automatic retry. */
-    onRetryDue?: () => void;
-
-    private readonly handleOnline = () => {
-        // The OS says the interface is back. Trust it enough to try
-        // immediately rather than sitting out the rest of the backoff — and to
-        // say so, or a client with nothing queued would have no request whose
-        // success could ever flip the badge back to "online".
-        this.retryAt = 0;
-        this.backoffMs = this.initialBackoffMs;
-        this.clearPendingTimer();
-        this.setState("online");
-        this.onRetryDue?.();
-    };
-    private readonly handleOffline = () => {
-        this.setState("offline");
-    };
-
-    constructor(options: ConnectivityOptions = {}) {
-        this.initialBackoffMs = options.initialBackoffMs ?? 1_000;
-        this.maxBackoffMs = Math.max(this.initialBackoffMs, options.maxBackoffMs ?? 60_000);
-        this.backoffMs = this.initialBackoffMs;
-        this.respectBackoff = options.respectBackoff ?? true;
-        this.now = options.now ?? (() => Date.now());
-        this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
-        this.clearTimer = options.clearTimer ?? ((handle) => clearTimeout(handle));
-
-        if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
-            window.addEventListener("online", this.handleOnline);
-            window.addEventListener("offline", this.handleOffline);
-        }
-        if (typeof navigator !== "undefined" && navigator.onLine === false) {
-            this.state = "offline";
-        }
-    }
-
-    /** What the app should be told: are we connected? */
-    isOnline(): boolean {
-        if (typeof navigator !== "undefined" && navigator.onLine === false) return false;
-        return this.state === "online";
-    }
-
-    /**
-     * Should this request even be sent? False means "answer from the local
-     * store instead" — the request would only burn a timeout to reach the same
-     * conclusion the last one already did.
-     */
-    shouldAttempt(): boolean {
-        if (typeof navigator !== "undefined" && navigator.onLine === false) return false;
-        if (this.state === "online" || !this.respectBackoff) return true;
-        // Exactly one request is let through when the window opens; it is the
-        // probe whose outcome decides whether we are back.
-        return this.now() >= this.retryAt;
-    }
-
-    /** A request reached the server. */
-    markSuccess(): void {
-        this.backoffMs = this.initialBackoffMs;
-        this.retryAt = 0;
-        this.clearPendingTimer();
-        this.setState("online");
-    }
-
-    /** A request did not reach the server: we are offline until proven otherwise. */
-    markFailure(): void {
-        this.deferRetry();
-        this.setState("offline");
-    }
-
-    /**
-     * Back off and try again later without claiming the connection is gone.
-     * This is what a 429 or a 503 deserves — the server answered, so the app
-     * is demonstrably online; it just should not hammer.
-     */
-    deferRetry(): void {
-        const jitter = 0.8 + Math.random() * 0.4;
-        this.retryAt = this.now() + this.backoffMs * jitter;
-        const delay = Math.max(0, this.retryAt - this.now());
-        this.backoffMs = Math.min(this.maxBackoffMs, this.backoffMs * 2);
-        this.scheduleRetry(delay);
-    }
-
-    /** Milliseconds until the next attempt is allowed; 0 when one is allowed now. */
-    msUntilRetry(): number {
-        if (this.state === "online") return 0;
-        return Math.max(0, this.retryAt - this.now());
-    }
-
-    onChange(listener: (online: boolean) => void): () => void {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-
-    dispose(): void {
-        if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
-            window.removeEventListener("online", this.handleOnline);
-            window.removeEventListener("offline", this.handleOffline);
-        }
-        this.clearPendingTimer();
-        this.listeners.clear();
-        this.onRetryDue = undefined;
-    }
-
-    private scheduleRetry(delay: number): void {
-        this.clearPendingTimer();
-        if (!this.onRetryDue) return;
-        this.timer = this.setTimer(() => {
-            this.timer = undefined;
-            this.onRetryDue?.();
-        }, delay);
-        // A retry timer must never be the reason a Node script refuses to exit.
-        (this.timer as unknown as { unref?: () => void }).unref?.();
-    }
-
-    private clearPendingTimer(): void {
-        if (this.timer !== undefined) {
-            this.clearTimer(this.timer);
-            this.timer = undefined;
-        }
-    }
-
-    private setState(next: "online" | "offline"): void {
-        if (this.state === next) return;
-        this.state = next;
-        const online = this.isOnline();
-        for (const listener of this.listeners) listener(online);
-    }
-}