@larc-iu/plaid-client 0.2.0-alpha.3 → 0.2.0-alpha.30

package/src/documentLock.js

@@ -0,0 +1,384 @@
+import { isUnknownOutcome, retryUnknown } from "./http.js";
+import { uuidv4 } from "./ids.js";
+
+/**
+ * Keeping a document lock alive for as long as a `locked()` block runs.
+ *
+ * plaid-core expires a document lock about a minute after it was taken, and the
+ * holder's own writes are what renew it (`plaid.sql.operation` calls
+ * `refresh-locks!` on every write it accepts). That is the right rule for an
+ * editor, which writes as the person types. It is the wrong one for a service:
+ * a parser loads a model, reads the document, spends minutes in inference and
+ * only then writes, so for most of its run it holds nothing. The lock lapses in
+ * silence, a person's edit lands between the read the work was planned from and
+ * the write about to go out, and the write clobbers it.
+ *
+ * A `locked()` block therefore renews on a timer of its own. The renewal is an
+ * acquire that names the holder's `lockId`: the server refreshes the lock that
+ * id holds, and refuses one somebody else holds (the same user included).
+ *
+ * The beat is unconditional rather than "only when no write has gone out
+ * recently". Two extra requests a minute is the whole cost. A write the server
+ * took that moved the locked document's version renewed the lock as well, and
+ * the request layer tells the keeper (`writesStarted`, `writesLanded` in
+ * http.js), so renewals that fail with something other than a 423 while the
+ * run's writes land do not end the run as a lost lock.
+ *
+ * A renewal that fails means the block is no longer holding what it asked for,
+ * so it stops the run: the loss is recorded on the client and every later write
+ * throws `DocumentLockLost`. The guard sits in the request layer because the
+ * callers are services, and a check they have to remember to call is a check
+ * that is missing somewhere.
+ */
+
+/**
+ * The lock a `documents.locked()` block was holding is no longer held.
+ *
+ * Thrown by the keep-alive when it cannot renew the lock, and then by the
+ * request layer on every write this client attempts, so work that has been
+ * running for minutes stops rather than writing over an edit that may have
+ * landed while the lock was gone.
+ */
+export class DocumentLockLost extends Error {
+  /**
+   * @param {string} message
+   * @param {string} documentId
+   * @param {unknown} [cause]
+   */
+  constructor(message, documentId, cause) {
+    super(message);
+    /** @type {"DocumentLockLost"} */
+    this.name = "DocumentLockLost";
+    /** @type {string} */
+    this.documentId = documentId;
+    /** @type {unknown} */
+    this.cause = cause;
+  }
+}
+
+/**
+ * How long a freshly taken lock lasts, from the server's own answer.
+ *
+ * `expiresAt` is the epoch-millisecond moment the lock endpoints return, on
+ * the server's clock, so it is read against the server's clock too
+ * (`client.serverNow()`): this machine's clock being off cannot stretch or
+ * shrink the window. It is how a window an operator has retuned
+ * (`:plaid.server.locks/config :expiration-ms`) reaches the keeper.
+ *
+ * An answer that cannot be a window (none, already over, past an hour) is
+ * core's default, 60 s.
+ *
+ * @param {number} expiresAt
+ * @param {number} serverNowMs
+ * @returns {number}
+ */
+export function lockTtlMs(expiresAt, serverNowMs) {
+  const ttl = expiresAt - serverNowMs;
+  // No answer at all, or one past an hour or already over: this machine's
+  // clock stood in for the server's (a page that cannot read its Date
+  // header) and is far off. Core's default window is the better guess.
+  return Number.isFinite(ttl) && ttl > 0 && ttl <= MAX_TTL_MS ? ttl : DEFAULT_TTL_MS;
+}
+
+// Core's default lock window, and the longest one believed.
+const DEFAULT_TTL_MS = 60000;
+const MAX_TTL_MS = 3600000;
+
+/**
+ * Renews one document's lock until the block holding it exits.
+ *
+ * `refresh` is called with the document id and must reject on failure.
+ * `onLost` is called once, with the `DocumentLockLost`, when the lock can no
+ * longer be assumed.
+ *
+ * `clock` and `sleep` exist so the whole policy can be run on a fake clock:
+ * `sleep(delayMs)` resolves to true once the block has exited.
+ */
+export class LockKeeper {
+  constructor(
+    refresh,
+    documentId,
+    ttlMs,
+    { onLost = null, clock = Date.now, sleep = null } = {},
+  ) {
+    this._refresh = refresh;
+    this._documentId = documentId;
+    this._ttlMs = ttlMs;
+    this._onLost = onLost;
+    this._clock = clock;
+    this._sleep = sleep || ((ms) => this._defaultSleep(ms));
+    this._stopped = false;
+    this._wake = null;
+    this._running = null;
+    // When the window this keeper last saw renewed runs out, on its clock.
+    // Moved by a renewal (run) and by an accepted write (noteWrite).
+    this._deadline = clock() + ttlMs;
+    /**
+     * The `DocumentLockLost` this keeper raised, or null.
+     * @type {DocumentLockLost | null}
+     */
+    this.lost = null;
+  }
+
+  get documentId() {
+    return this._documentId;
+  }
+
+  /** This keeper's clock, which a write's send time is read on. */
+  now() {
+    return this._clock();
+  }
+
+  /**
+   * A write of the locked document, sent at `sentAt`, was taken. The server
+   * renews a live lock on every write its holder makes to the document, from
+   * when it took the write, which is no earlier than `sentAt`. It counts only
+   * when its answer came back before the window this keeper counts ran out:
+   * the server then still held the lock when it took the write.
+   * @param {number} sentAt
+   */
+  noteWrite(sentAt) {
+    if (this._clock() < this._deadline) {
+      this._deadline = Math.max(this._deadline, sentAt + this._ttlMs);
+    }
+  }
+
+  /**
+   * Time between renewals: half the window, so a renewal that fails has a
+   * second chance before the lock it is renewing expires.
+   */
+  get intervalMs() {
+    return Math.max(1000, this._ttlMs / 2);
+  }
+
+  /**
+   * Time before retrying a renewal that failed. A blip should not end a run
+   * that the server still considers the holder of.
+   */
+  get retryMs() {
+    return Math.max(500, this._ttlMs / 10);
+  }
+
+  _defaultSleep(ms) {
+    if (this._stopped) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this._wake = null;
+        resolve(this._stopped);
+      }, ms);
+      // Never hold a Node process open on the beat alone.
+      if (timer && typeof timer.unref === "function") timer.unref();
+      this._wake = () => {
+        clearTimeout(timer);
+        this._wake = null;
+        resolve(true);
+      };
+    });
+  }
+
+  /** The beat. Resolves when the block exits or the lock is lost. */
+  async run() {
+    let delay = this.intervalMs;
+    while (!(await this._sleep(delay))) {
+      // The window is counted from when the renewal was sent, since the
+      // server starts it on receipt, not when its answer gets back.
+      const sent = this._clock();
+      try {
+        await this._refresh(this._documentId);
+      } catch (error) {
+        // 423 is definitive: somebody else holds the document now, or ours
+        // expired or was dropped, and the server never takes it back.
+        // Anything else may be a blip, and is only fatal once the lock we are
+        // renewing has actually run out.
+        if (error?.status === 423 || this._clock() >= this._deadline) {
+          this._fail(error);
+          return;
+        }
+        delay = this.retryMs;
+        continue;
+      }
+      this._deadline = Math.max(this._deadline, sent + this._ttlMs);
+      delay = this.intervalMs;
+    }
+  }
+
+  start() {
+    this._running = this.run();
+    // Nothing awaits the beat: a failure inside it is reported through onLost,
+    // not through this promise.
+    this._running.catch(() => {});
+    return this._running;
+  }
+
+  stop() {
+    this._stopped = true;
+    if (this._wake) this._wake();
+  }
+
+  _fail(error) {
+    this.lost = new DocumentLockLost(
+      `The lock on document ${this._documentId} lapsed: it could not be renewed.`,
+      this._documentId,
+      error,
+    );
+    if (this._onLost) this._onLost(this.lost);
+  }
+}
+
+/**
+ * What a `client.documents.locked(id, (lock) => ...)` block gets.
+ *
+ * The block does not have to consult it: a lost lock stops the next write on
+ * its own. Read `lock.lost` (or call `lock.raiseIfLost()`) to give up earlier,
+ * between steps of work that has not written anything yet.
+ */
+export class DocumentLock {
+  /**
+   * @param {string} documentId
+   * @param {LockKeeper | null} keeper
+   * @param {string | null} [lockId]
+   */
+  constructor(documentId, keeper, lockId = null) {
+    /** @type {string} */
+    this.documentId = documentId;
+    /**
+     * The holder id the acquire answered with.
+     * @type {string | null}
+     */
+    this.lockId = lockId;
+    this._keeper = keeper;
+  }
+
+  /**
+   * The `DocumentLockLost` if the lock lapsed, else null.
+   * @returns {DocumentLockLost | null}
+   */
+  get lost() {
+    return this._keeper ? this._keeper.lost : null;
+  }
+
+  /** Throw if the lock lapsed. Call it between steps that have not written. */
+  raiseIfLost() {
+    if (this.lost) throw this.lost;
+  }
+}
+
+/**
+ * The pause before sending again an acquire whose outcome is unknown, which
+ * grows by this much each time (three sends in all).
+ */
+export const LOCK_ACQUIRE_RETRY_MS = 500;
+
+function mintLockId() {
+  return uuidv4();
+}
+
+/**
+ * The acquire of a `locked()` block, under the holder id it minted.
+ *
+ * An acquire whose outcome is unknown (no answer, a timeout, a 502 or a 504)
+ * may have taken the lock. It is sent again under the same id as any write is
+ * (`retryUnknown`), which the server answers 200 while that holder has it.
+ * When every send is unknown (or the network went), the lock it may hold is
+ * released on the way out, so it does not stand in everyone's way until it
+ * expires.
+ */
+async function takeLock(client, documentId, lockId, retryMs) {
+  try {
+    return await retryUnknown(
+      () => client.documents.acquireLock(documentId, undefined, lockId),
+      { delaysMs: [retryMs, 2 * retryMs] },
+    );
+  } catch (error) {
+    if (error?.status === 423) {
+      // The error body is raw JSON off the wire, so it is still kebab-cased.
+      const body = error.responseData || {};
+      const holder = body["user-id"] || "another user";
+      const readable = new Error(
+        `This document is being edited by ${holder}. Try again once they're done.`,
+      );
+      readable.status = 423;
+      readable.statusText = error.statusText;
+      readable.url = error.url;
+      readable.method = error.method;
+      readable.responseData = error.responseData;
+      readable.cause = error;
+      throw readable;
+    }
+    if (isUnknownOutcome(error)) {
+      try {
+        await client.documents.releaseLock(documentId, lockId);
+      } catch {
+        /* the lock expires on its own */
+      }
+    }
+    throw error;
+  }
+}
+
+/**
+ * Hold `documentId`'s server-enforced lock for the length of `fn`.
+ * `client.documents.locked` is the entry point; see its doc comment.
+ *
+ * @param {object} client
+ * @param {string} documentId
+ * @param {(lock: DocumentLock) => any} fn
+ * @param {{ keepAlive?: boolean, acquireRetryMs?: number }} [options]
+ */
+export async function withDocumentLock(
+  client,
+  documentId,
+  fn,
+  { keepAlive = true, acquireRetryMs = LOCK_ACQUIRE_RETRY_MS } = {},
+) {
+  const minted = mintLockId();
+  const info = await takeLock(client, documentId, minted, acquireRetryMs);
+
+  const lockId = info?.lockId ?? minted;
+  let keeper = null;
+  if (keepAlive) {
+    const ttlMs = lockTtlMs(info.expiresAt, client.serverNow().getTime());
+    client.documentLockLost = null;
+    keeper = new LockKeeper(
+      (id) => client.documents.renewLock(id, lockId),
+      documentId,
+      ttlMs,
+      {
+        onLost: (lost) => {
+          client.documentLockLost = lost;
+        },
+      },
+    );
+    client.lockKeepers?.set(documentId, keeper);
+    keeper.start();
+  }
+
+  let result;
+  let threw = false;
+  try {
+    result = await fn(new DocumentLock(documentId, keeper, lockId));
+  } catch (error) {
+    threw = true;
+    throw error;
+  } finally {
+    if (keeper) {
+      keeper.stop();
+      if (client.lockKeepers?.get(documentId) === keeper)
+        client.lockKeepers.delete(documentId);
+    }
+    const lost = keeper ? keeper.lost : null;
+    client.documentLockLost = null;
+    // Best-effort release: the server TTL reclaims a stranded lock, and we must
+    // not let a release failure mask the real error from the body.
+    try {
+      await client.documents.releaseLock(documentId, lockId);
+    } catch {
+      /* the lock expires on its own */
+    }
+    // A block that ran to the end without the lock it asked for did not do what
+    // it says it did. Only throw when nothing else is already propagating, so
+    // the real failure is never masked.
+    if (lost && !threw) throw lost;
+  }
+  return result;
+}

package/src/entryForms.d.ts

@@ -0,0 +1,63 @@
+/**
+ * A form written the way FieldWorks writes a morph standing alone: "-ar" for
+ * a suffix, "ka-" for a prefix, "=ni" for an enclitic, unchanged for a stem or
+ * for a type outside the table or none.
+ *
+ * @template {string | null | undefined} F
+ * @param {string | null | undefined} morphType
+ * @param {F} form
+ * @returns {F | string}
+ */
+export function decorateWithAffixMarkers<F extends string | null | undefined>(morphType: string | null | undefined, form: F): F | string;
+/**
+ * A morph form as FieldWorks writes it, read back: the inverse of
+ * decorateWithAffixMarkers. A morph of a known type loses exactly that type's
+ * markers ("-ar" of a suffix is "ar"), and a form without them is kept as
+ * written. A morph with no type, or a type outside MORPH_TYPES, takes the type
+ * its markers name ("ni=" is a proclitic), and keeps its form whole when they
+ * name none. The type comes back lower-cased, or null.
+ *
+ * @param {string | null | undefined} morphType
+ * @param {string | null | undefined} form
+ * @returns {{ form: string | null | undefined, morphType: string | null }}
+ */
+export function readAffixMarkers(morphType: string | null | undefined, form: string | null | undefined): {
+    form: string | null | undefined;
+    morphType: string | null;
+};
+/**
+ * The form and morph type an entry stores, from the form and type a person,
+ * a file or a model gave. A form carrying its type's markers loses them
+ * ("-s" of a suffix is "s"). A form carrying "-" or "=" markers that name a
+ * type loses them. When a type in MORPH_TYPES came with the form, that type
+ * is kept ("theŋjən-" given as a bound stem is the bound stem "theŋjən"), and
+ * only when none came do the markers set it ("-s" with no type is the suffix
+ * "s"). Any other form, a free-text one with whitespace inside its markers
+ * among them, is kept as written with the type it came with, which is
+ * returned as given ("*kwa" with no type stays "*kwa", a reconstructed form).
+ *
+ * @template {string | null | undefined} T
+ * @param {T} morphType
+ * @param {string | null | undefined} form
+ * @returns {{ form: string | null | undefined, morphType: T | string }}
+ */
+export function entryForm<T extends string | null | undefined>(morphType: T, form: string | null | undefined): {
+    form: string | null | undefined;
+    morphType: T | string;
+};
+/**
+ * How a lexicon entry's form is stored: without affix or clitic markers. An
+ * entry's marker is drawn from its morph type ("-s" is a suffix "s", "ni=" a
+ * proclitic "ni"), so every writer of an entry form, in every app and in the
+ * Python client (plaid_client.workflows.igt.entry_forms), passes the form and
+ * type it was given through `entryForm` and stores what comes back.
+ *
+ * The morph types are FieldWorks' MoMorphType inventory, which LIFT and
+ * .flextext need verbatim. The markers are each type's Prefix and Postfix as
+ * FieldWorks spells a morph standing alone, read off the factory objects of
+ * real .fwbackup files (identical in Lezgi, Sena, Arabic, Onim and Lamkang).
+ * The seven types left out of the table (stem, root, circumfix, clitic,
+ * particle, phrase, discontiguous phrase) have no marker in that data.
+ */
+/** FieldWorks' morph types, the values a stored morph type may take. */
+export const MORPH_TYPES: readonly string[];

package/src/entryForms.js

@@ -0,0 +1,152 @@
+/**
+ * How a lexicon entry's form is stored: without affix or clitic markers. An
+ * entry's marker is drawn from its morph type ("-s" is a suffix "s", "ni=" a
+ * proclitic "ni"), so every writer of an entry form, in every app and in the
+ * Python client (plaid_client.workflows.igt.entry_forms), passes the form and
+ * type it was given through `entryForm` and stores what comes back.
+ *
+ * The morph types are FieldWorks' MoMorphType inventory, which LIFT and
+ * .flextext need verbatim. The markers are each type's Prefix and Postfix as
+ * FieldWorks spells a morph standing alone, read off the factory objects of
+ * real .fwbackup files (identical in Lezgi, Sena, Arabic, Onim and Lamkang).
+ * The seven types left out of the table (stem, root, circumfix, clitic,
+ * particle, phrase, discontiguous phrase) have no marker in that data.
+ */
+
+/** FieldWorks' morph types, the values a stored morph type may take. */
+export const MORPH_TYPES = Object.freeze([
+  "stem",
+  "bound stem",
+  "root",
+  "bound root",
+  "prefix",
+  "suffix",
+  "infix",
+  "circumfix",
+  "simulfix",
+  "suprafix",
+  "infixing interfix",
+  "prefixing interfix",
+  "suffixing interfix",
+  "clitic",
+  "enclitic",
+  "proclitic",
+  "particle",
+  "phrase",
+  "discontiguous phrase",
+]);
+
+/** @type {Readonly<Record<string, readonly [string, string]>>} */
+const MORPH_TYPE_MARKERS = Object.freeze({
+  "bound root": ["*", ""],
+  "bound stem": ["*", ""],
+  enclitic: ["=", ""],
+  infix: ["-", "-"],
+  "infixing interfix": ["-", "-"],
+  prefix: ["", "-"],
+  "prefixing interfix": ["", "-"],
+  proclitic: ["", "="],
+  simulfix: ["=", "="],
+  suffix: ["-", ""],
+  "suffixing interfix": ["-", ""],
+  suprafix: ["~", "~"],
+});
+
+// The one plain type each pair of "-" and "=" markers names, keyed
+// "<before>,<after>". The interfixes share their markers with a plainer type,
+// so markers alone never name one, and "*" and "~" are left out because both
+// also occur in forms as themselves (a reconstructed "*kwa").
+/** @type {Readonly<Record<string, string>>} */
+const TYPE_BY_MARKERS = Object.freeze({
+  "-,": "suffix",
+  ",-": "prefix",
+  "-,-": "infix",
+  "=,": "enclitic",
+  ",=": "proclitic",
+  "=,=": "simulfix",
+});
+
+/**
+ * A form written the way FieldWorks writes a morph standing alone: "-ar" for
+ * a suffix, "ka-" for a prefix, "=ni" for an enclitic, unchanged for a stem or
+ * for a type outside the table or none.
+ *
+ * @template {string | null | undefined} F
+ * @param {string | null | undefined} morphType
+ * @param {F} form
+ * @returns {F | string}
+ */
+export function decorateWithAffixMarkers(morphType, form) {
+  if (form == null || form === "") return form;
+  const marks = MORPH_TYPE_MARKERS[String(morphType ?? "").toLowerCase()];
+  return marks ? `${marks[0]}${form}${marks[1]}` : form;
+}
+
+/** @param {string} form @param {string} type */
+const strips = (form, type) => {
+  const [before, after] = MORPH_TYPE_MARKERS[type] ?? ["", ""];
+  return before + after !== "" &&
+    form.length > before.length + after.length &&
+    form.startsWith(before) &&
+    form.endsWith(after)
+    ? form.slice(before.length, form.length - after.length)
+    : null;
+};
+
+// A form whose bare middle holds whitespace is free text ("-du, du-"), so its
+// markers name no type and stay. WHITESPACE spells out JS's \s, so the
+// Python client's copy matches it character for character.
+const WHITESPACE = /[\t\n\v\f\r \u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]/u;
+/** @param {string} form */
+const markedType = (form) => {
+  const m = /^([-=]?)(.+?)([-=]?)$/su.exec(form);
+  const type = m && !WHITESPACE.test(m[2]) && TYPE_BY_MARKERS[`${m[1]},${m[3]}`];
+  return type && m ? { form: m[2], morphType: type } : null;
+};
+
+/**
+ * A morph form as FieldWorks writes it, read back: the inverse of
+ * decorateWithAffixMarkers. A morph of a known type loses exactly that type's
+ * markers ("-ar" of a suffix is "ar"), and a form without them is kept as
+ * written. A morph with no type, or a type outside MORPH_TYPES, takes the type
+ * its markers name ("ni=" is a proclitic), and keeps its form whole when they
+ * name none. The type comes back lower-cased, or null.
+ *
+ * @param {string | null | undefined} morphType
+ * @param {string | null | undefined} form
+ * @returns {{ form: string | null | undefined, morphType: string | null }}
+ */
+export function readAffixMarkers(morphType, form) {
+  const named = String(morphType ?? "").toLowerCase();
+  const known = MORPH_TYPES.includes(named) ? named : null;
+  if (form == null || form === "") return { form, morphType: known };
+  if (known) return { form: strips(form, known) ?? form, morphType: known };
+  return markedType(form) ?? { form, morphType: null };
+}
+
+/**
+ * The form and morph type an entry stores, from the form and type a person,
+ * a file or a model gave. A form carrying its type's markers loses them
+ * ("-s" of a suffix is "s"). A form carrying "-" or "=" markers that name a
+ * type loses them. When a type in MORPH_TYPES came with the form, that type
+ * is kept ("theŋjən-" given as a bound stem is the bound stem "theŋjən"), and
+ * only when none came do the markers set it ("-s" with no type is the suffix
+ * "s"). Any other form, a free-text one with whitespace inside its markers
+ * among them, is kept as written with the type it came with, which is
+ * returned as given ("*kwa" with no type stays "*kwa", a reconstructed form).
+ *
+ * @template {string | null | undefined} T
+ * @param {T} morphType
+ * @param {string | null | undefined} form
+ * @returns {{ form: string | null | undefined, morphType: T | string }}
+ */
+export function entryForm(morphType, form) {
+  if (typeof form !== "string" || form === "") return { form, morphType };
+  const own = typeof morphType === "string" ? morphType.toLowerCase() : "";
+  const given = MORPH_TYPES.includes(own);
+  const bare = given ? strips(form, own) : null;
+  if (bare != null) return { form: bare, morphType };
+  const marked = markedType(form);
+  if (!marked) return { form, morphType };
+  return given ? { form: marked.form, morphType } : marked;
+}

package/src/events.d.ts

@@ -0,0 +1,60 @@
+/** The page's recorder for `client`'s server. */
+export function recorderFor(client: any): any;
+/** Forget every recorder (tests). */
+export function resetEventRecorders(): void;
+/** Every event type the server accepts. */
+export const EVENT_TYPES: readonly string[];
+export const FLUSH_INTERVAL_MS: 10000;
+export const FLUSH_AT: 50;
+export const FLAG_TTL_MS: 10000;
+export const FLAG_OFF_TTL_MS: 60000;
+export class EventRecorder {
+    /**
+     * @param {object} [opts]
+     * @param {function} [opts.now] - Clock, for tests
+     * @param {object} [opts.window] - Where `pagehide` fires (default globalThis)
+     */
+    constructor({ now, window }?: {
+        now?: Function;
+        window?: object;
+    });
+    client: any;
+    buffer: any[];
+    timer: number;
+    now: Function;
+    flags: Map<any, any>;
+    seen: Set<any>;
+    _onPageHide: () => void;
+    window: any;
+    /** Tell the recorder a project's switch, e.g. right after changing it. */
+    setEnabled(projectId: any, on: any): void;
+    /**
+     * Record one event. Returns true when it was buffered, false when it was
+     * not (switch off, a repeat "shown", an unknown type, no project).
+     * @param {any} client
+     * @param {string} type
+     * @param {{projectId?: string, documentId?: string, targetId?: string, data?: Record<string, any>}} [fields]
+     * @returns {boolean}
+     */
+    record(client: any, type: string, { projectId, documentId, targetId, data }?: {
+        projectId?: string;
+        documentId?: string;
+        targetId?: string;
+        data?: Record<string, any>;
+    }): boolean;
+    /**
+     * Send what is buffered for every project whose switch is known to be on,
+     * drop what is buffered for one known to be off, and keep the rest until
+     * the switch is known. With `keepalive` (the page is going away) nothing is
+     * kept.
+     */
+    flush({ keepalive }?: {
+        keepalive?: boolean;
+    }): void;
+    /** Stop listening for `pagehide` and forget everything (tests). */
+    close(): void;
+    _schedule(): void;
+    _drop(projectId: any): void;
+    _flag(projectId: any): any;
+    _send(projectId: any, events: any, keepalive: any): void;
+}