@synnaxlabs/client 0.56.1 → 0.57.0

package/src/channel/external.ts

@@ -9,6 +9,5 @@
 
 export * from "@/channel/client";
 export * from "@/channel/payload";
-export * from "@/channel/retriever";
 export * from "@/channel/types.gen";
 export * from "@/channel/writer";

package/src/channel/payload.ts

@@ -19,21 +19,32 @@ import {
   type Payload,
   payloadZ,
 } from "@/channel/types.gen";
-import { ontology } from "@/ontology";
+import { idToString } from "@/ontology/payload";
+import {
+  analyzeParams as baseAnalyzeParams,
+  type ParamAnalysisResult,
+} from "@/util/retrieve";
 
+/** One or many channels, named by key or by name. */
 export type PrimitiveParams = Key | Name | Key[] | Name[];
 
+/** Zod schema for {@link Params}, resolving every form to a key array. */
 export const paramsZ = z.union([
   zod.toArray(keyZ),
   zod.toArray(nameZ),
   zod.toArray(payloadZ).transform((p) => p.map((c) => c.key)),
 ]);
+/** Anything that names one or many channels. */
 export type Params = PrimitiveParams | Payload | Payload[];
 
 const CHAR_REGEX = /[a-zA-Z0-9_]/;
 
 const VALID_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
+/**
+ * Rewrites a channel name into a valid identifier, replacing every other character with
+ * an underscore and prefixing a leading digit.
+ */
 export const escapeInvalidName = (name: string, changeEmptyToUnderscore = false) => {
   if (name === "") return changeEmptyToUnderscore ? "_" : "";
   if (name.match(VALID_NAME_PATTERN)) return name;
@@ -47,5 +58,21 @@ export const escapeInvalidName = (name: string, changeEmptyToUnderscore = false)
   return result;
 };
 
-export const statusKey = (channel: Key): string =>
-  ontology.idToString(ontologyID(channel));
+/** @returns the key of the status that reports on the given channel. */
+export const statusKey = (channel: Key): string => idToString(ontologyID(channel));
+
+/**
+ * Resolves channel params into a normalized array, reporting whether the caller named
+ * one channel or many, and whether by key or by name.
+ */
+export const analyzeParams = (
+  channels: Params,
+): ParamAnalysisResult<Key | Name, { number: "keys"; string: "names" }> => {
+  if (Array.isArray(channels) && channels.length > 0 && typeof channels[0] === "object")
+    channels = (channels as Payload[]).map((c) => c.key);
+  else if (typeof channels === "object" && "key" in channels) channels = [channels.key];
+  return baseAnalyzeParams(channels as PrimitiveParams, {
+    number: "keys",
+    string: "names",
+  });
+};

package/src/channel/types.gen.ts

@@ -9,11 +9,12 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { control, status, telem, TimeSpan, zod } from "@synnaxlabs/x";
+import { control, telem, TimeSpan, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { cluster } from "@/cluster";
+import { node } from "@/node";
 import { ontology } from "@/ontology";
+import { status } from "@/status";
 
 export const keyZ = z.uint32().or(
   z
@@ -32,18 +33,21 @@ export type OperationType = z.infer<typeof operationTypeZ>;
 
 /**
  * Operation defines an aggregation operation applied to channel data. Operations
- * calculate min, max, or average values over a time duration or triggered
+ * calculate min, max, average, or derivative values over a time duration or triggered
  * by a reset channel.
  */
 export const operationZ = z.object({
-  /** type is the aggregation operation type: min, max, avg, or none. */
+  /** type is the aggregation operation type: min, max, avg, derivative, or none. */
   type: operationTypeZ,
   /**
-   * resetChannel is the channel key that triggers reset of the aggregation. If 0,
-   * duration-based reset is used.
+   * resetChannel is the key of a channel that resets the aggregation when it receives a
+   * sample. If 0, no reset channel is used.
    */
   resetChannel: keyZ.default(0),
-  /** duration is the time window for aggregation when reset_channel is 0. */
+  /**
+   * duration is the interval at which the aggregation resets. If 0, the aggregation is
+   * not reset on a timer.
+   */
   duration: telem.timeSpanZ.default(TimeSpan.ZERO),
 });
 export interface Operation extends z.infer<typeof operationZ> {}
@@ -55,82 +59,67 @@ export const statusZ = status.statusZ();
 export type Status = z.infer<typeof statusZ>;
 
 /**
- * Payload is a logical collection of samples emitted by or representing values
- * from a single source. Channels are the fundamental unit of telemetry
- * storage and streaming in Synnax.
+ * Payload is a logical collection of samples emitted by or representing values from a
+ * single source. Channels are the fundamental unit of telemetry storage and streaming
+ * in Synnax.
  */
 export const payloadZ = z.object({
   /**
-   * key is the unique identifier for this channel, automatically assigned
-   * by Synnax.
+   * key is the unique identifier for this channel, automatically assigned by Synnax.
    */
-  key: keyZ,
+  key: keyZ.default(0),
   /** name is the human-readable channel name. */
   name: nameZ,
   /**
-   * leaseholder is the cluster node that holds the lease for this channel. Mostly
-   * for internal use.
+   * leaseholder is the node that holds the lease for this channel. Mostly for internal
+   * use.
    */
-  leaseholder: cluster.nodeKeyZ,
+  leaseholder: node.keyZ.default(0),
   /**
-   * dataType is the data type of samples stored in this channel (e.g., Float64,
-   * Int32, TimeStamp).
+   * dataType is the data type of samples stored in this channel (e.g., float64, int32,
+   * timestamp).
    */
   dataType: telem.dataTypeZ,
   /**
-   * isIndex is true if this is an index channel. Index channels must have int64
-   * values (TIMESTAMP data type) written in ascending order, and are
-   * most commonly unix nanosecond timestamps.
+   * isIndex is true if this is an index channel. Index channels must have int64 values
+   * (TIMESTAMP data type) written in ascending order, and are most commonly Unix
+   * nanosecond timestamps.
    */
-  isIndex: z.boolean(),
+  isIndex: z.boolean().default(false),
   /**
-   * index is the channel used to index this channel's values, associating
-   * each value with a timestamp.
+   * index is the channel used to index this channel's values, associating each value
+   * with a timestamp.
    */
-  index: keyZ,
+  index: keyZ.default(0),
   /** alias is an optional alternate name for the channel within a specific context. */
   alias: z.string().optional(),
   /**
-   * virtual is true if this channel does not store data in the database but can
-   * still be used for streaming purposes.
+   * virtual is true if this channel does not store data in the database but can still
+   * be used for streaming purposes.
    */
   virtual: z.boolean().default(false),
   /** internal is true if this is a system channel hidden from normal user queries. */
   internal: z.boolean().default(false),
   /**
-   * expression is an Arc expression for calculated channels. If set, the channel
-   * is automatically configured as virtual.
+   * expression is an Arc expression for calculated channels. If set, the channel is
+   * automatically configured as virtual.
    */
   expression: z.string().default(""),
   /**
-   * operations contains optional aggregation operations (min, max, avg) applied to
-   * channel data over time or triggered by a reset channel.
+   * operations contains optional aggregation operations (min, max, avg, derivative)
+   * applied to channel data over time or triggered by a reset channel.
    */
-  operations: zod.nullToUndefined(operationZ.array()),
+  operations: operationZ.array().default(() => []),
   /**
    * concurrency sets the policy for concurrent writes to the channel's data. Only
    * virtual channels can have a policy of shared concurrency.
    */
-  concurrency: control.concurrencyZ.default(control.Concurrency.exclusive).optional(),
+  concurrency: control.concurrencyZ.default(control.Concurrency.exclusive),
   /** status is the current operational status of the channel. */
   status: statusZ.optional(),
 });
 export interface Payload extends z.infer<typeof payloadZ> {}
-
-export const newZ = payloadZ
-  .omit({ leaseholder: true })
-  .partial({
-    key: true,
-    index: true,
-    isIndex: true,
-    internal: true,
-    virtual: true,
-    expression: true,
-  })
-  .extend({
-    leaseholder: zod.uint12.optional(),
-  });
-export interface New extends z.input<typeof newZ> {}
+export interface New extends z.input<typeof payloadZ> {}
 
 export const ontologyID = ontology.createIDFactory<Key>("channel");
 export const TYPE_ONTOLOGY_ID = ontologyID(0);

package/src/channel/writer.ts

@@ -11,18 +11,16 @@ import { type UnaryClient } from "@synnaxlabs/freighter";
 import { type DataType } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { type CacheRetriever } from "@/channel/retriever";
 import {
   type Key,
   keyZ,
   nameZ,
   type New,
-  newZ,
   type Payload,
   payloadZ,
 } from "@/channel/types.gen";
 
-const createReqZ = z.object({ channels: newZ.array() });
+const createReqZ = z.object({ channels: payloadZ.array() });
 const createResZ = z.object({ channels: payloadZ.array() });
 
 const deleteReqZ = z.object({
@@ -39,11 +37,9 @@ export interface RenameProps extends z.input<typeof renameReqZ> {}
 
 export class Writer {
   private readonly client: UnaryClient;
-  private readonly cache: CacheRetriever;
 
-  constructor(client: UnaryClient, cache: CacheRetriever) {
+  constructor(client: UnaryClient) {
     this.client = client;
-    this.cache = cache;
   }
 
   async create(channels: New[]): Promise<Payload[]> {
@@ -58,19 +54,14 @@ export class Writer {
       createReqZ,
       createResZ,
     );
-    this.cache.set(created);
     return created;
   }
 
   async delete(props: DeleteProps): Promise<void> {
-    const keys = keyZ.array().parse(props.keys ?? []);
     await this.client.send("/channel/delete", props, deleteReqZ, deleteResZ);
-    if (keys.length > 0) this.cache.delete(keys);
-    if (props.names != null) this.cache.delete(props.names);
   }
 
   async rename(keys: Key[], names: string[]): Promise<void> {
     await this.client.send("/channel/rename", { keys, names }, renameReqZ, renameResZ);
-    this.cache.rename(keys, names);
   }
 }

package/src/client.ts

@@ -7,7 +7,16 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { breaker, TimeSpan, TimeStamp, URL, zod } from "@synnaxlabs/x";
+import {
+  array,
+  breaker,
+  type CrudeTimeSpan,
+  TimeSpan,
+  TimeStamp,
+  url,
+  uuid,
+  zod,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { access } from "@/access";
@@ -20,14 +29,16 @@ import { device } from "@/device";
 import { errorsMiddleware } from "@/errors";
 import { framer } from "@/framer";
 import { group } from "@/group";
+import { imex } from "@/imex";
 import { label } from "@/label";
 import { lineplot } from "@/lineplot";
 import { log } from "@/log";
 import { ontology } from "@/ontology";
+import { panel } from "@/panel";
+import { project } from "@/project";
+import { query } from "@/query";
 import { rack } from "@/rack";
 import { ranger } from "@/ranger";
-import { alias } from "@/ranger/alias";
-import { kv } from "@/ranger/kv";
 import { schematic } from "@/schematic";
 import { status } from "@/status";
 import { table } from "@/table";
@@ -35,7 +46,6 @@ import { task } from "@/task";
 import { Transport } from "@/transport";
 import { user } from "@/user";
 import { view } from "@/view";
-import { workspace } from "@/workspace";
 
 export const synnaxParamsZ = z.object({
   host: z.string({ error: "Host is required" }).min(1, "Host is required"),
@@ -49,6 +59,16 @@ export const synnaxParamsZ = z.object({
   secure: z.boolean().default(false),
   name: z.string().optional(),
   retry: breaker.breakerConfigZ.optional(),
+  cache: z.boolean().default(true),
+  /**
+   * Receives cache errors that have no caller to throw to (listener fan-out, streamer
+   * frame handling, background reconciliation). Defaults to console logging.
+   */
+  // output is unknown, not void: strict void validation would make a
+  // caller's `(e) => list.push(e)` throw at error-report time
+  onInternalError: z
+    .function({ input: z.tuple([z.instanceof(Error)]), output: z.unknown() })
+    .optional(),
 });
 
 export interface SynnaxParams extends z.input<typeof synnaxParamsZ> {}
@@ -56,13 +76,13 @@ export interface ParsedSynnaxParams extends z.infer<typeof synnaxParamsZ> {}
 
 /**
  * Client to perform operations against a Synnax cluster.
- *
  * @property channel - Channel client for creating and retrieving channels.
  * @property data - Data client for reading and writing telemetry.
- * @property connectivity - Client for retrieving connectivity information.
+ * @property connection - The connection state machine.
  * @property ontology - Client for querying the cluster's ontology.
  */
 export default class Synnax extends framer.Client {
+  readonly key: string;
   readonly createdAt: TimeStamp;
   readonly params: ParsedSynnaxParams;
   readonly ranges: ranger.Client;
@@ -70,9 +90,9 @@ export default class Synnax extends framer.Client {
   readonly auth: auth.Client;
   readonly users: user.Client;
   readonly access: access.Client;
-  readonly connectivity: connection.Checker;
+  readonly connection: connection.Handle;
   readonly ontology: ontology.Client;
-  readonly workspaces: workspace.Client;
+  readonly projects: project.Client;
   readonly labels: label.Client;
   readonly statuses: status.Client;
   readonly tasks: task.Client;
@@ -83,31 +103,31 @@ export default class Synnax extends framer.Client {
   readonly views: view.Client;
   readonly schematics: schematic.Client;
   readonly lineplots: lineplot.Client;
+  readonly panels: panel.Client;
   readonly logs: log.Client;
   readonly tables: table.Client;
   readonly groups: group.Client;
-  static readonly connectivity = connection.Checker;
+  readonly imex: imex.Client;
+  private readonly cache: query.Cache;
   private readonly transport: Transport;
+  private readonly conn: connection.Client;
 
-  /**
-   * The version of the client.
-   */
+  /** The version of the client. */
   readonly clientVersion: string = __VERSION__;
 
   /**
    * @param props.host - Hostname of a node in the cluster.
    * @param props.port - Port of the node in the cluster.
-   * @param props.username - Username for authentication. Not required if the
-   * cluster is insecure.
-   * @param props.password - Password for authentication. Not required if the
-   * cluster is insecure.
-   * @param props.connectivityPollFrequency - Frequency at which to poll the
-   * cluster for connectivity information. Defaults to 30 seconds.
-   * @param props.secure - Whether to connect to the cluster using TLS. The cluster
-   * must be configured to support TLS. Defaults to false.
-   *
-   * A Synnax client must be closed when it is no longer needed. This will stop
-   * the client from polling the cluster for connectivity information.
+   * @param props.username - Username for authentication. Not required if the cluster is
+   * insecure.
+   * @param props.password - Password for authentication. Not required if the cluster is
+   * insecure.
+   * @param props.connectivityPollFrequency - Heartbeat cadence while the connection is
+   * healthy. Defaults to 30 seconds.
+   * @param props.secure - Whether to connect to the cluster using TLS. The cluster must
+   * be configured to support TLS. Defaults to false. A Synnax client must be closed
+   * when it is no longer needed. This stops the connection machine and closes the
+   * change stream.
    */
   constructor(params: SynnaxParams) {
     const parsedParams = zod.parse(synnaxParamsZ, params);
@@ -119,88 +139,192 @@ export default class Synnax extends framer.Client {
       connectivityPollFrequency,
       clockSkewThreshold,
       secure,
-      retry: breaker,
+      retry,
     } = parsedParams;
     const transport = new Transport(
-      new URL({ host, port: Number(port) }),
-      breaker,
+      new url.URL({ host, port: Number(port) }),
+      retry,
       secure,
     );
     transport.use(errorsMiddleware);
-    const chRetriever = new channel.CacheRetriever(
-      new channel.ClusterRetriever(transport.unary),
+    // The arrow reads this.channels only when called, after construction completes.
+    const retrieveChannels: framer.ChannelRetriever = async (toRetrieve) => {
+      const result = await this.channels.retrieve(
+        array.toArray(toRetrieve) as channel.Key[] | channel.Name[],
+      );
+      return result.map((ch) => ch.payload);
+    };
+    super({ stream: transport.stream, unary: transport.unary, retrieveChannels });
+    const cache = new query.Cache({
+      openStreamer: parsedParams.cache
+        ? async (config) => await this.openStreamer(config)
+        : null,
+      breaker: retry,
+      onStreamLive: () => this.conn.notify({ type: "stream.live" }),
+      onStreamDrop: (error) => this.conn.notify({ type: "stream.drop", error }),
+      onStreamDenied: (error) => this.conn.notify({ type: "stream.denied", error }),
+      onError: parsedParams.onInternalError,
+    });
+    this.cache = cache;
+    this.conn = new connection.Client({
+      unary: transport.unaryNoRetry,
+      address: `${host}:${Number(port)}`,
+      name: parsedParams.name,
+      clockSkewThreshold: new TimeSpan(clockSkewThreshold).abs(),
+      requiresStream: parsedParams.cache,
+      retry,
+      heartbeatInterval: connectivityPollFrequency,
+      stream: {
+        reset: async () => await cache.reset(),
+        ensure: async () => await cache.ensureStreaming(),
+      },
+      onInternalError: parsedParams.onInternalError,
+    });
+    this.connection = this.conn;
+    cache.onEpoch((epoch) => this.conn.notify({ type: "epoch.advanced", epoch }));
+    transport.unary.use(this.conn.middleware());
+    // The auth client fails fast: login retries belong to the request that triggered
+    // them (the breaker-wrapped unary or the check loop), never stacked beneath it.
+    this.auth = new auth.Client(
+      transport.unaryNoRetry,
+      { username, password },
+      {
+        onSuccess: () => this.conn.notify({ type: "auth.success" }),
+        onFailure: (error) => this.conn.notify({ type: "auth.failure", error }),
+      },
     );
-    super(transport.stream, transport.unary, chRetriever);
-    this.auth = new auth.Client(transport.unary, { username, password });
     transport.use(this.auth.middleware());
-    const chCreator = new channel.Writer(transport.unary, chRetriever);
+    const chCreator = new channel.Writer(transport.unary);
+    this.key = uuid.create();
     this.createdAt = TimeStamp.now();
     this.params = parsedParams;
     this.transport = transport;
-    this.channels = new channel.Client(this, chRetriever, transport.unary, chCreator);
-    this.connectivity = new connection.Checker(
-      transport.unary,
-      connectivityPollFrequency,
-      this.clientVersion,
-      parsedParams.name,
-      clockSkewThreshold,
-    );
-    this.control = new control.Client(this);
-    this.ontology = new ontology.Client(this.transport.unary);
-    const rangeWriter = new ranger.Writer(this.transport.unary);
-    this.labels = new label.Client(this.transport.unary);
-    this.statuses = new status.Client(this.transport.unary);
-    this.ranges = new ranger.Client(
-      this,
-      rangeWriter,
-      this.transport.unary,
-      chRetriever,
-      this.labels,
-      this.ontology,
-      (key: ranger.Key) => new alias.Client(key, this.transport.unary),
-      (key: ranger.Key) => new kv.Client(key, this.transport.unary),
-    );
-    this.access = new access.Client(this.transport.unary);
-    this.users = new user.Client(this.transport.unary);
-    this.workspaces = new workspace.Client(this.transport.unary);
-    this.tasks = new task.Client(
-      this.transport.unary,
-      this,
-      this.ontology,
-      this.ranges,
-    );
-    this.racks = new rack.Client(this.transport.unary, this.tasks);
-    this.devices = new device.Client(this.transport.unary);
-    this.arcs = new arc.Client(this.transport.unary, this.transport.stream);
-    this.views = new view.Client(this.transport.unary);
-    this.schematics = new schematic.Client(this.transport.unary);
-    this.lineplots = new lineplot.Client(this.transport.unary);
-    this.logs = new log.Client(this.transport.unary);
-    this.tables = new table.Client(this.transport.unary);
-    this.groups = new group.Client(this.transport.unary);
+    const unary = this.transport.unary;
+    this.ontology = new ontology.Client({ unary, cache });
+    this.labels = new label.Client({ unary, cache, ontology: this.ontology });
+    this.statuses = new status.Client({
+      unary,
+      cache,
+      ontology: this.ontology,
+      labels: this.labels,
+    });
+    this.ranges = new ranger.Client({
+      framer: this,
+      unary,
+      channels: retrieveChannels,
+      labels: this.labels,
+      ontology: this.ontology,
+      cache,
+    });
+    this.channels = new channel.Client({
+      framer: this,
+      unary,
+      writer: chCreator,
+      statuses: this.statuses,
+      ranges: this.ranges,
+      cache,
+      ontology: this.ontology,
+    });
+    this.control = new control.Client({ unary, cache });
+    this.access = new access.Client({ unary, cache, ontology: this.ontology });
+    this.users = new user.Client({ unary, cache, ontology: this.ontology });
+    this.projects = new project.Client({
+      unary,
+      file: this.transport.file,
+      cache,
+      ontology: this.ontology,
+    });
+    this.tasks = new task.Client({
+      unary,
+      framer: this,
+      ontology: this.ontology,
+      ranges: this.ranges,
+      cache,
+      statusStore: this.statuses.store,
+    });
+    this.racks = new rack.Client({
+      unary,
+      tasks: this.tasks,
+      cache,
+      statusStore: this.statuses.store,
+      ontology: this.ontology,
+    });
+    this.devices = new device.Client({
+      unary,
+      cache,
+      statusStore: this.statuses.store,
+      ontology: this.ontology,
+    });
+    this.arcs = new arc.Client({
+      unary,
+      stream: this.transport.stream,
+      ontology: this.ontology,
+      tasks: this.tasks,
+      cache,
+      statusStore: this.statuses.store,
+    });
+    this.views = new view.Client({ unary, cache, ontology: this.ontology });
+    this.groups = new group.Client({
+      unary,
+      ontology: this.ontology,
+      cache,
+    });
+    this.schematics = new schematic.Client({
+      unary,
+      file: this.transport.file,
+      ontology: this.ontology,
+      cache,
+      groupStore: this.groups.store,
+    });
+    this.lineplots = new lineplot.Client({ unary, cache, ontology: this.ontology });
+    this.panels = new panel.Client({
+      unary,
+      ontology: this.ontology,
+      cache,
+    });
+    this.logs = new log.Client({ unary, cache, ontology: this.ontology });
+    this.tables = new table.Client({ unary, cache, ontology: this.ontology });
+    this.imex = new imex.Client({ file: this.transport.file });
+  }
+
+  /**
+   * Awaits the connection becoming usable: success, or warning when the cluster refuses
+   * live updates. Idempotent: resolves immediately when already connected.
+   * @throws {AuthError} on a definitive credential rejection.
+   * @throws {DisconnectedError} when the cluster cannot be reached after the configured
+   * retry budget, or when the client is closed while waiting.
+   * @throws {Error} if the timeout elapses first.
+   */
+  async connect({ timeout }: ConnectOptions = {}): Promise<connection.Status> {
+    return await this.conn.connect(timeout);
   }
 
-  get key(): string {
-    return this.createdAt.valueOf().toString();
+  /** Supplies new credentials after an auth failure and resumes connecting. */
+  reauthenticate(credentials: auth.Credentials): void {
+    this.auth.setCredentials(credentials);
+    this.conn.notify({ type: "credentials.replaced" });
   }
 
-  close(): void {
-    this.connectivity.stop();
+  /**
+   * Closes the client, stopping the connection check loop and tearing down the
+   * query cache and its change stream. Resolves once both are closed.
+   * @throws {AggregateError} carrying every underlying close failure.
+   */
+  async close(): Promise<void> {
+    const results = await Promise.allSettled([this.conn.close(), this.cache.close()]);
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0)
+      throw new AggregateError(
+        failures.map((f) => f.reason),
+        "failed to close the client",
+      );
   }
 }
 
-export interface CheckConnectionParams extends Pick<
-  SynnaxParams,
-  "host" | "port" | "secure" | "retry" | "name"
-> {}
-
-export const checkConnection = async (params: CheckConnectionParams) =>
-  await newConnectionChecker(params).check();
-
-export const newConnectionChecker = (params: CheckConnectionParams) => {
-  const { host, port, secure, name, retry } = params;
-  const retryConfig = zod.parse(breaker.breakerConfigZ.optional(), retry);
-  const url = new URL({ host, port: Number(port) });
-  const transport = new Transport(url, retryConfig, secure);
-  return new connection.Checker(transport.unary, undefined, __VERSION__, name);
-};
+export interface ConnectOptions {
+  /**
+   * Maximum time to wait before rejecting. Without it, connect rejects when
+   * the connection escalates to error(unreachable) after its retry budget.
+   */
+  timeout?: CrudeTimeSpan;
+}