@synnaxlabs/client 0.57.2 → 0.58.0

package/src/ranger/client.ts

@@ -288,6 +288,21 @@ const retrieveMultiParamsZ = retrieveRequestZ
 
 const retrieveResZ = z.object({ ranges: payloadZ.array().default(() => []) });
 
+/** Request addressing a page of a range's children, in relationship-key order. */
+export type ChildrenRequest = {
+  key: Key;
+  limit?: number;
+  offset?: number;
+};
+
+/** Params addressing a range's children. A bare key addresses all of them. */
+export type ChildrenParams = Key | ChildrenRequest;
+
+const CHILDREN_SERVER_FIELDS = ["limit", "offset"] as const;
+
+const normalizeChildren = (params: ChildrenParams): ChildrenRequest =>
+  typeof params === "string" ? { key: params } : params;
+
 /** The base flags applied to every composed range fetch. */
 const BASE_REQUEST: Partial<RetrieveRequest> = {
   includeLabels: true,
@@ -386,7 +401,7 @@ export class Client extends query.Retriever<
   /** The range alias table; injected into sibling clients at wiring. */
   readonly aliases: query.Table<string, alias.Alias>;
   /** Cached queries for the children of a range, keyed by the parent's key. */
-  readonly children: query.Retrieves<Key, Range[]>;
+  readonly children: query.Retrieves<ChildrenParams, Range[]>;
   /**
    * Cached queries for the closest range parent of a resource, keyed by the
    * child's ontology ID.
@@ -429,7 +444,7 @@ export class Client extends query.Retriever<
       table: composed,
       fetch: async (query) => [(await this.fetchSingle(query)).key],
       compose: ([record]) => record,
-      keyOf: (query) => (keyZ.safeParse(query).success ? query : null),
+      keyOf: (query) => (z.validate(keyZ, query) ? query : null),
       matches: (r, query) => r.key === query || r.name === query,
       single: true,
     });
@@ -453,17 +468,27 @@ export class Client extends query.Retriever<
     this.store = ranges;
     this.kvPairs = kvPairs;
     this.aliases = aliases;
-    this.children = cache.queries<Key, Range[], Key, Range>({
+    const children = cache.queries<ChildrenRequest, Range[], Key, Range>({
       name: "child ranges",
       table: composed,
       fetch: async (query) => (await this.fetchChildren(query)).map((r) => r.key),
       compose: (records) => records,
       matches: (r, query) => {
         const parent = this.cfg.ontology.cache.parentID(ontologyID(r.key));
-        return parent != null && ontology.idsEqual(parent, ontologyID(query));
+        return parent != null && ontology.idsEqual(parent, ontologyID(query.key));
       },
-      watch: [watchRelationships<Key>(this.cfg.ontology.cache.relationships)],
+      serverFields: CHILDREN_SERVER_FIELDS,
+      watch: [
+        watchRelationships<ChildrenRequest>(this.cfg.ontology.cache.relationships),
+      ],
     });
+    this.children = {
+      retrieve: async (params, options) =>
+        await children.retrieve(normalizeChildren(params), options),
+      onChange: (params, handler) =>
+        children.onChange(normalizeChildren(params), handler),
+      getCached: (params) => children.getCached(normalizeChildren(params)),
+    };
     this.parent = cache.queries<ontology.ID, Range | null, Key, Range>({
       name: "parent range",
       table: composed,
@@ -551,9 +576,9 @@ export class Client extends query.Retriever<
   }
 
   async retrieve(params: Key | Name): Promise<Range>;
-  async retrieve(params: Key[] | Name[]): Promise<Range[]>;
-  async retrieve(params: CrudeTimeRange): Promise<Range[]>;
-  async retrieve(params: RetrieveRequest): Promise<Range[]>;
+  async retrieve(
+    params: Key[] | Name[] | CrudeTimeRange | RetrieveRequest,
+  ): Promise<Range[]>;
   async retrieve(params: RetrieveParams): Promise<Range | Range[]> {
     // The branches narrow params onto different base overloads.
     if (typeof params === "string") return await super.retrieve(params);
@@ -669,8 +694,12 @@ export class Client extends query.Retriever<
   private async fetchSingle(query: Key | Name): Promise<Range> {
     const cached = this.store.get(query);
     if (cached != null) return this.composeOne(cached);
-    const req = keyZ.safeParse(query).success ? { keys: [query] } : { names: [query] };
-    const ranges = await this.execRetrieve({ ...BASE_REQUEST, ...req });
+    if (z.validate(keyZ, query)) {
+      const ranges = await this.store.retrieve([query]);
+      checkForMultipleOrNoResults("Range", query, ranges, true);
+      return this.composeOne(ranges[0]);
+    }
+    const ranges = await this.execRetrieve({ ...BASE_REQUEST, names: [query] });
     checkForMultipleOrNoResults("Range", query, ranges, true);
     this.writeThrough(ranges[0]);
     return ranges[0];
@@ -721,10 +750,12 @@ export class Client extends query.Retriever<
     return true;
   }
 
-  private async fetchChildren(query: Key): Promise<Range[]> {
+  private async fetchChildren(query: ChildrenRequest): Promise<Range[]> {
     const resources = await this.cfg.ontology.children.retrieve({
-      ids: ontologyID(query),
+      ids: ontologyID(query.key),
       types: ["range"],
+      limit: query.limit,
+      offset: query.offset,
     });
     if (resources.length === 0) return [];
     return await this.store.retrieve(resources.map(({ id: { key } }) => key));

package/src/schematic/actions.ts

@@ -23,6 +23,9 @@ import {
   setNodePosition,
 } from "@/schematic/actions.gen";
 
+// Must match the pluto groupBox symbol's config variant.
+const GROUP_BOX_VARIANT = "groupBox";
+
 const handlers: Handlers = {
   create: (state, payload) => {
     Object.assign(state, payload.schematic);
@@ -83,16 +86,24 @@ const handlers: Handlers = {
       oldConfigRaw != null ? actions.snapshotDraft(oldConfigRaw) : undefined;
     state.nodes.splice(idx, 1);
     delete state.configs[payload.key];
-    return {
-      inverse: [
-        setNode(
-          oldConfig != null
-            ? { node: oldNode, config: oldConfig }
-            : { node: oldNode, config: undefined },
-        ),
-      ],
-      targets: [payload.key],
-    };
+    const inverse: Action[] = [
+      setNode(
+        oldConfig != null
+          ? { node: oldNode, config: oldConfig }
+          : { node: oldNode, config: undefined },
+      ),
+    ];
+    const targets = [payload.key];
+    for (const [key, config] of Object.entries(state.configs)) {
+      if (config?.variant !== GROUP_BOX_VARIANT) continue;
+      const members = config.members;
+      if (!Array.isArray(members) || !members.includes(payload.key)) continue;
+      const oldMembers = actions.snapshotDraft(members);
+      config.members = members.filter((m) => m !== payload.key);
+      inverse.push(setConfig({ key, config: { members: oldMembers } }));
+      targets.push(key);
+    }
+    return { inverse, targets };
   },
   addEdge: (state, payload) => {
     if (state.edges.some((e) => e.key === payload.edge.key))

package/src/status/client.ts

@@ -319,9 +319,7 @@ export class Client extends query.Retriever<
   }
 
   private async fetchSingle(key: Key): Promise<Status> {
-    const cached = this.store.get(key);
-    if (cached != null) return cached;
-    const statuses = await this.fetchThrough({ keys: [key] });
+    const statuses = await this.store.retrieve([key]);
     checkForMultipleOrNoResults("Status", key, statuses, true);
     return statuses[0];
   }

package/src/status/status.ts

@@ -80,6 +80,96 @@ export const exceptionDetailsSchema = z
   })
   .and(record.unknownZ());
 
+// Bounds the clone check so it stays cheap even when errors are created in a tight
+// loop. An exhausted budget reports un-cloneable, which safely over-rebuilds.
+const CLONE_CHECK_BUDGET = 64;
+
+const isCloneableValue = (
+  v: unknown,
+  seen: Set<object>,
+  budget: { left: number },
+): boolean => {
+  if (--budget.left < 0) return false;
+  if (v == null) return true;
+  const t = typeof v;
+  if (t === "function" || t === "symbol") return false;
+  if (t !== "object") return true;
+  const o = v;
+  if (seen.has(o)) return true;
+  seen.add(o);
+  const values = (vals: unknown[]): boolean =>
+    vals.every((e) => isCloneableValue(e, seen, budget));
+  if (o instanceof Error)
+    return isCloneableValue(o.cause, seen, budget) && values(Object.values(o));
+  if (Array.isArray(o)) return values(o);
+  const proto = Object.getPrototypeOf(o);
+  if (proto === Object.prototype || proto === null) return values(Object.values(o));
+  if (o instanceof Date || o instanceof ArrayBuffer || ArrayBuffer.isView(o))
+    return true;
+  // Host objects (an Event, a DOM node) and exotic containers land here.
+  return false;
+};
+
+// Object.values can trip an enumerable getter that throws. Treat a throwing value
+// as not cloneable rather than throwing while already handling an error.
+const isCloneable = (v: unknown): boolean => {
+  try {
+    return isCloneableValue(v, new Set(), { left: CLONE_CHECK_BUDGET });
+  } catch {
+    return false;
+  }
+};
+
+// Returns a cloneable stand-in for an un-cloneable value.
+const cloneSafeValue = (v: unknown, depth: number): unknown => {
+  if (isCloneable(v)) return v;
+  if (v instanceof Error) return cloneSafeError(v, depth);
+  if (depth <= 0) return errors.fromUnknown(v).message;
+  try {
+    if (Array.isArray(v)) return v.map((e) => cloneSafeValue(e, depth - 1));
+    if (typeof v === "object" && v != null) {
+      const out: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(v))
+        if (typeof value !== "function" && typeof value !== "symbol")
+          out[key] = cloneSafeValue(value, depth - 1);
+      return out;
+    }
+  } catch {
+    // Tolerate throwing enumerable getters.
+  }
+  return errors.fromUnknown(v).message;
+};
+
+/**
+ * Returns err unchanged when it survives structured cloning. Otherwise rebuilds it
+ * with the same name, message, stack, and `type`, sanitizing un-cloneable fields and
+ * causes. Statuses cross the worker boundary, where an un-cloneable error kills the
+ * worker.
+ */
+const cloneSafeError = (err: Error, depth: number = 8): Error => {
+  if (isCloneable(err)) return err;
+  const safe = new Error(err.message);
+  safe.name = err.name;
+  safe.stack = err.stack;
+  const { type } = err as { type?: unknown };
+  if (typeof type === "string") (safe as { type?: string }).type = type;
+  try {
+    for (const [key, value] of Object.entries(err))
+      if (key !== "cause" && typeof value !== "function" && typeof value !== "symbol")
+        (safe as unknown as Record<string, unknown>)[key] = cloneSafeValue(
+          value,
+          depth - 1,
+        );
+  } catch {
+    // Tolerate throwing enumerable getters.
+  }
+  const { cause } = err;
+  if (cause !== undefined && depth > 0)
+    if (cause instanceof Error) safe.cause = cloneSafeError(cause, depth - 1);
+    else safe.cause = cloneSafeValue(cause, depth - 1);
+  return safe;
+};
+
 /** Flattens an error's cause chain into one readable line. */
 const causeChain = (err: Error): string | undefined => {
   const parts: string[] = [];
@@ -109,7 +199,7 @@ export const fromException = (
       message != null
         ? [err.message, detail].filter((part) => part != null).join(": ")
         : detail,
-    details: { stack: err.stack ?? "", error: err },
+    details: { stack: err.stack ?? "", error: cloneSafeError(err) },
   };
   // Probe the original (pre-coercion) value so a non-Error throwable with a custom
   // `toStatus()` method still contributes its status fields.
@@ -192,6 +282,20 @@ export const removeVariants = (
   return remove === variant ? undefined : variant;
 };
 
+/** Rank of each variant by severity, most severe lowest. */
+const SEVERITY: Record<Variant, number> = {
+  error: 0,
+  warning: 1,
+  loading: 2,
+  success: 3,
+  info: 4,
+  disabled: 5,
+};
+
+/** @returns true when a is more severe than b. */
+export const moreSevere = (a: Variant, b: Variant): boolean =>
+  SEVERITY[a] < SEVERITY[b];
+
 /** Options for {@link toString}. */
 export interface ToStringOptions {
   includeTimestamp?: boolean;

package/src/task/client.ts

@@ -91,6 +91,12 @@ const COMMAND_DEADLINE = TimeSpan.seconds(10);
 
 const STATUS_NAME = "Task Status";
 
+/**
+ * The task status schema without a details-data schema. Hoisted because statusZ()
+ * builds a fresh schema per call, which costs far more than the parse itself.
+ */
+export const defaultStatusZ = statusZ();
+
 const retrieveSnapshottedTo = async (taskKey: Key, ontologyClient: ontology.Client) => {
   const parents = await ontologyClient.parents.retrieve({ ids: ontologyID(taskKey) });
   if (parents.length === 0) return null;
@@ -415,10 +421,14 @@ export class Client extends query.Retriever<
   /** The task record table; injected into sibling clients at wiring. */
   readonly store: query.Table<Key, Omit<Task, "status">>;
   private readonly cfg: ClientConfig;
+  private readonly statusesByTask: query.LookupIndex<status.Key, status.Status>;
   private readonly commandDeadlines = new Map<Key, ReturnType<typeof setTimeout>>();
 
   constructor(cfg: ClientConfig) {
     const { cache, statusStore } = cfg;
+    const statusesByTask = statusStore.index(
+      new query.LookupIndex<status.Key, status.Status>(statusTaskKey),
+    );
     const store = cache.createTable<Key, Omit<Task, "status">>({
       name: "tasks",
       equal: (a, b) => deep.equal(a.payload, b.payload),
@@ -458,7 +468,9 @@ export class Client extends query.Retriever<
           commands.forEach((changed) => {
             if (!LOADING_COMMANDS.includes(changed.type)) return;
             const key = statusKey(changed.task);
-            if (statusStore.get(key) == null) return;
+            // Commands reach every client, so one for a task this client neither
+            // tracks nor holds a status for is dropped.
+            if (store.get(changed.task) == null && statusStore.get(key) == null) return;
             const optimistic = this.optimisticStatus(changed);
             statusStore.set(key, optimistic);
             if (optimistic.variant === "loading")
@@ -471,7 +483,7 @@ export class Client extends query.Retriever<
       source: store,
       compose: (record) => this.compose(record),
       equal: (a, b) => deep.equal(a.payload, b.payload),
-      watch: [query.deriveWatch(statusStore, (event) => affectedTaskKeys(event))],
+      watch: [query.deriveWatch(statusStore, (event) => affectedKeys(event))],
     });
     const single = cache.queries<SingleRequest, Task, Key, Task>({
       name: "task",
@@ -489,13 +501,14 @@ export class Client extends query.Retriever<
         schema: retrieveMultiParamsZ,
         fetch: async (req) => await this.fetchThrough(req),
         matches: (t, req) => requestFilter(req)(t),
-        watch: [query.watch(statusStore, (event) => affectedTaskKeys(event))],
+        watch: [query.watch(statusStore, (event) => affectedKeys(event))],
       },
       compose: (record) => this.compose(record),
       single: { schema: singleQueryZ, space: single },
     });
     this.cfg = cfg;
     this.store = store;
+    this.statusesByTask = statusesByTask;
   }
 
   async create(task: New): Promise<Task>;
@@ -587,7 +600,7 @@ export class Client extends query.Retriever<
   ): Promise<Task<S> | Task<S>[]> {
     const { schemas, ...params } =
       typeof rawParams === "string" ? { key: rawParams } : rawParams;
-    const isSingle = singleRetrieveParamsZ.safeParse(params).success;
+    const isSingle = z.validate(singleRetrieveParamsZ, params);
     // Schema-parametrized retrieves validate config/status for one caller;
     // their results are not shared through the cache.
     if (schemas != null) {
@@ -595,11 +608,8 @@ export class Client extends query.Retriever<
       checkForMultipleOrNoResults("Task", params, sugared, isSingle);
       return isSingle ? sugared[0] : sugared;
     }
-    if (isSingle)
-      return (await super.retrieve(params as RetrieveSingleParams)) as Task<S>;
-    return (await super.retrieve(
-      params as RetrieveMultipleParams,
-    )) as unknown as Task<S>[];
+    if (isSingle) return (await super.retrieve(params)) as Task<S>;
+    return (await super.retrieve(params)) as unknown as Task<S>[];
   }
 
   async copy(key: Key, name: string, snapshot: boolean): Promise<Task> {
@@ -719,20 +729,25 @@ export class Client extends query.Retriever<
     );
   }
 
-  // A task's status may live under the "task:<key>" row or under any status
-  // whose details reference the task; the freshest wins. Rows are parsed
-  // because the status table holds every domain's statuses generically.
+  // A task's status may live under the "task:<key>" row or under any status whose
+  // details reference the task; the freshest wins, ties going to the more severe. Rows
+  // are parsed because the status table holds every domain's statuses generically.
   private latestStatusOf(key: Key): Status | undefined {
-    const taskKey = statusKey(key);
-    const candidates = this.cfg.statusStore
-      .get((s) => s.key === taskKey || status.detailsOf(s)?.task === key)
-      .map((s) => statusZ().safeParse(s))
+    const direct = this.cfg.statusStore.get(statusKey(key));
+    const rows = this.statusesByTask.get(key);
+    // A task status names its task in details too, so the index usually holds it.
+    if (direct != null && !rows.includes(direct)) rows.push(direct);
+    const candidates = rows
+      .map((s) => defaultStatusZ.safeParse(s))
       .filter((p) => p.success)
       .map((p) => p.data);
     if (candidates.length === 0) return undefined;
-    return candidates.reduce((latest, s) =>
-      new TimeStamp(s.time).afterEq(new TimeStamp(latest.time)) ? s : latest,
-    );
+    return candidates.reduce((latest, s) => {
+      const time = new TimeStamp(s.time);
+      const latestTime = new TimeStamp(latest.time);
+      if (!time.equals(latestTime)) return time.after(latestTime) ? s : latest;
+      return status.moreSevere(s.variant, latest.variant) ? s : latest;
+    });
   }
 
   /** Writes a fetched task and its included status. */
@@ -759,6 +774,12 @@ export class Client extends query.Retriever<
     // no status or the status may not have synced. Only both count as a hit.
     if (cached != null && this.cfg.statusStore.has(statusKey(cached.key)))
       return this.compose(cached);
+    if (primitive.isNonZero(q.keys)) {
+      // The refresh covers a cached task whose status has not synced.
+      const tasks = await this.store.retrieve(q.keys, { refresh: true });
+      checkForMultipleOrNoResults("Task", q, tasks, true);
+      return this.compose(tasks[0]);
+    }
     const tasks = await this.execRetrieve({ ...q, includeStatus: true });
     checkForMultipleOrNoResults("Task", q, tasks, true);
     this.writeThrough(tasks[0]);
@@ -866,17 +887,28 @@ export class Client extends query.Retriever<
 /** @returns the key of the status that reports on the given task. */
 export const statusKey = (key: Key): string => ontology.idToString(ontologyID(key));
 
-const taskStatusZ = z.object({ details: z.object({ task: keyZ }) });
+/**
+ * @returns the key of the task the status reports on, or null when it names none.
+ * Guarded before the key parse: most statuses in the table belong to other domains,
+ * and a failed zod parse costs orders of magnitude more than the miss is worth.
+ */
+const statusTaskKey = (s: status.Status): Key | null => {
+  const task = status.detailsOf(s)?.task;
+  if (typeof task !== "string") return null;
+  return z.validate(keyZ, task) ? task : null;
+};
 
-// Task statuses may arrive under any status key; the referenced task lives in
-// the details, with the "task:<key>" status key as a fallback.
-const affectedTaskKeys = (
+/**
+ * @returns the keys of the tasks a status change affects, or null when none. A status
+ * names its task in `details.task`, with the "task:<key>" status key as a fallback.
+ */
+export const affectedKeys = (
   event: query.TableEvent<status.Key, status.Status>,
 ): Key[] | null => {
   const keys: Key[] = [];
   if (event.variant === "set") {
-    const parsed = taskStatusZ.safeParse(event.value);
-    if (parsed.success) keys.push(parsed.data.details.task);
+    const task = statusTaskKey(event.value);
+    if (task != null) keys.push(task);
   }
   const [type, key] = event.key.split(":");
   if (type === "task" && primitive.isNonZero(key) && !keys.includes(key))

package/src/testutil/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { TimeSpan } from "@synnaxlabs/x";
-import { afterAll } from "vitest";
+import { afterAll, vi } from "vitest";
 
 import Synnax, { type SynnaxParams } from "@/client";
 
@@ -50,3 +50,7 @@ export const createTestClient = (params?: Partial<SynnaxParams>): Synnax => {
   openClients.push(client);
   return client;
 };
+
+/** Spies on the client's unary send so specs can count requests on the wire. */
+export const spyOnSend = (client: Synnax, field: "transport" = "transport") =>
+  vi.spyOn(client[field].unary, "send");

package/src/testutil/proxy.ts

@@ -35,12 +35,27 @@ export interface SeverableProxy {
   port: number;
   /** Drops every live connection and refuses new ones, as if the cluster died. */
   sever: () => Promise<void>;
+  /**
+   * Silently kills every live WebSocket connection, modeling a half-open socket (NAT
+   * timeout, VPN drop, laptop sleep): the cluster side is destroyed while the client
+   * side is held open with its writes discarded, so no close or reset ever reaches the
+   * client. New connections still forward. Returns how many connections were
+   * blackholed.
+   */
+  blackholeStreams: () => number;
   /** Accepts connections again on the same port. */
   restore: () => Promise<void>;
   /** Shuts the proxy down for good. */
   close: () => Promise<void>;
 }
 
+interface ProxiedPair {
+  downstream: Socket;
+  upstream: Socket;
+  /** Whether a WebSocket upgrade was observed on this connection. */
+  ws: boolean;
+}
+
 /**
  * Creates a TCP proxy in front of the live test cluster so specs can simulate
  * cluster downtime without touching the cluster itself. Connect a client to
@@ -50,7 +65,10 @@ export const createSeverableProxy = async (
   target: SeverableProxyTarget = {},
 ): Promise<SeverableProxy> => {
   const { host, port } = { ...DEFAULT_TARGET, ...target };
-  const sockets = new Set<Socket>();
+  const pairs = new Set<ProxiedPair>();
+  // Client-side sockets of blackholed connections: held open, silent, until the proxy
+  // is severed or closed.
+  const zombies = new Set<Socket>();
   let severed = false;
   const server = createServer((downstream) => {
     // A connection the kernel accepted before the sever is still delivered after it,
@@ -60,10 +78,16 @@ export const createSeverableProxy = async (
       return;
     }
     const upstream = connect(port, host);
-    sockets.add(downstream).add(upstream);
+    const pair: ProxiedPair = { downstream, upstream, ws: false };
+    pairs.add(pair);
+    // The upgrade can arrive on any request of a pooled keep-alive connection, not just
+    // the first, so every chunk is sniffed until one is seen.
+    downstream.on("data", (chunk: Buffer) => {
+      if (!pair.ws && /upgrade:\s*websocket/i.test(chunk.toString("latin1")))
+        pair.ws = true;
+    });
     const destroy = (): void => {
-      sockets.delete(downstream);
-      sockets.delete(upstream);
+      pairs.delete(pair);
       downstream.destroy();
       upstream.destroy();
     };
@@ -90,13 +114,42 @@ export const createSeverableProxy = async (
   const sever = async (): Promise<void> => {
     severed = true;
     const closed = new Promise<void>((resolve) => server.close(() => resolve()));
-    sockets.forEach((socket) => socket.destroy());
-    sockets.clear();
+    pairs.forEach(({ downstream, upstream }) => {
+      downstream.destroy();
+      upstream.destroy();
+    });
+    pairs.clear();
+    zombies.forEach((socket) => socket.destroy());
+    zombies.clear();
     await closed;
   };
+  const blackholeStreams = (): number => {
+    let count = 0;
+    for (const pair of [...pairs]) {
+      if (!pair.ws) continue;
+      count += 1;
+      const { downstream, upstream } = pair;
+      downstream.unpipe(upstream);
+      upstream.unpipe(downstream);
+      for (const socket of [downstream, upstream]) {
+        socket.removeAllListeners("close");
+        socket.removeAllListeners("error");
+        socket.on("error", () => {});
+      }
+      // Discard anything the client still writes so backpressure cannot close the
+      // socket on the proxy's behalf.
+      downstream.on("data", () => {});
+      downstream.resume();
+      upstream.destroy();
+      pairs.delete(pair);
+      zombies.add(downstream);
+    }
+    return count;
+  };
   return {
     port: boundPort,
     sever,
+    blackholeStreams,
     restore: async () => {
       severed = false;
       await listen(boundPort);

package/src/user/client.ts

@@ -207,8 +207,6 @@ export class Client extends query.Retriever<
     });
   }
 
-  async delete(key: Key, opts?: query.WriteOptions): Promise<void>;
-  async delete(keys: Key[], opts?: query.WriteOptions): Promise<void>;
   async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
     const keysArr = array.toArray(keys);
     const drop = () => [