@synnaxlabs/client 0.23.1 → 0.25.0

package/dist/workspace/lineplot/payload.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
 import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
 
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;

package/dist/workspace/lineplot/retriever.d.ts

@@ -1,5 +1,5 @@
-import { LinePlot, Params } from './payload';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { LinePlot, Params } from './payload';
 
 export declare class Retriever {
     private readonly ENDPOINT;

package/dist/workspace/lineplot/writer.d.ts

@@ -1,7 +1,7 @@
-import { Key, LinePlot, Params } from './payload';
-import { z } from 'zod';
-import { UnknownRecord } from '@synnaxlabs/x/record';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
+import { Key, LinePlot, Params } from './payload';
 
 export declare const newLinePlotZ: z.ZodEffects<z.ZodObject<{
     name: z.ZodString;

package/dist/workspace/payload.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
 import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
 
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;

package/dist/workspace/retriever.d.ts

@@ -1,5 +1,5 @@
-import { Params, Workspace } from './payload';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { Params, Workspace } from './payload';
 
 export declare class Retriever {
     private static readonly ENDPOINT;

package/dist/workspace/schematic/client.d.ts

@@ -1,7 +1,7 @@
-import { NewSchematic } from './writer';
-import { Key, Params, Schematic } from './payload';
-import { UnknownRecord } from '@synnaxlabs/x/record';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { UnknownRecord } from '@synnaxlabs/x/record';
+import { Key, Params, Schematic } from './payload';
+import { NewSchematic } from './writer';
 
 export declare class Client {
     private readonly writer;

package/dist/workspace/schematic/payload.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
 import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
 
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;

package/dist/workspace/schematic/retriever.d.ts

@@ -1,5 +1,5 @@
-import { Params, Schematic } from './payload';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { Params, Schematic } from './payload';
 
 export declare class Retriever {
     private readonly ENDPOINT;

package/dist/workspace/schematic/writer.d.ts

@@ -1,7 +1,7 @@
-import { Key, Params, Schematic } from './payload';
-import { z } from 'zod';
-import { UnknownRecord } from '@synnaxlabs/x/record';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
+import { Key, Params, Schematic } from './payload';
 
 export declare const newSchematicZ: z.ZodEffects<z.ZodObject<{
     name: z.ZodString;

package/dist/workspace/writer.d.ts

@@ -1,7 +1,7 @@
-import { Workspace } from './payload';
-import { z } from 'zod';
-import { UnknownRecord } from '@synnaxlabs/x/record';
 import { UnaryClient } from '@synnaxlabs/freighter';
+import { UnknownRecord } from '@synnaxlabs/x/record';
+import { z } from 'zod';
+import { Workspace } from './payload';
 
 declare const newWorkspaceZ: z.ZodEffects<z.ZodObject<{
     name: z.ZodString;

package/examples/node/basicReadWrite.js

@@ -30,7 +30,7 @@ const timeChannel = await client.channels.create({
 });
 
 // Create a channel that will be used to store our data.
-const indexChannel = await client.channels.create({
+const dataChannel = await client.channels.create({
     name: "basic_read_write_data",
     isIndex: false,
     dataType: DataType.FLOAT32,
@@ -54,14 +54,14 @@ const data = Float32Array.from({ length: N_SAMPLES }, (_, i) => Math.sin(i / 100
 // otherwise writing the data will fail. Notice how we align the writes with the 'start'
 // timestamp.
 await timeChannel.write(start, time);
-await indexChannel.write(start, data);
+await dataChannel.write(start, data);
 
 // Define the time range to read the data back from
 const tr = new TimeRange(start, start.add(TimeSpan.milliseconds(N_SAMPLES)));
 
 // Read the data back. The order doesn't matter here.
 const readTime = await timeChannel.read(tr);
-const readData = await indexChannel.read(tr);
+const readData = await dataChannel.read(tr);
 
 // Print out some information.
 console.log({
@@ -73,4 +73,4 @@ console.log({
 });
 
 // Make sure to close the client when you're done.
-client.close();
+client.close();

package/examples/node/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@synnaxlabs/client": "^0.20.0"
+        "@synnaxlabs/client": "^0.21.0"
       }
     },
     "node_modules/@grpc/grpc-js": {
@@ -3653,12 +3653,12 @@
       }
     },
     "node_modules/@synnaxlabs/client": {
-      "version": "0.20.0",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.20.0.tgz",
-      "integrity": "sha512-L4Qve63NTNmqdFiDlDy/rgM1yzAxkyaw6hf+SrsGLSb/u871Hwp/yUoUhYRpY1JjhvjL2N7YPXpr5Y+n8/y5iQ==",
+      "version": "0.21.0",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/client/-/client-0.21.0.tgz",
+      "integrity": "sha512-WZ5TQ7TaSZgE2AVQSVdj/4XX5mEIEr5fGLzrfI6kSi1vqm8l1Jo9nmpr/81AN8PLz1THMCd5lkz20qmSGtcx8g==",
       "dependencies": {
         "@synnaxlabs/freighter": "0.9.4",
-        "@synnaxlabs/x": "0.16.0",
+        "@synnaxlabs/x": "0.16.1",
         "async-mutex": "^0.4.1",
         "zod": "3.22.4"
       }
@@ -3692,9 +3692,9 @@
       }
     },
     "node_modules/@synnaxlabs/x": {
-      "version": "0.16.0",
-      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.16.0.tgz",
-      "integrity": "sha512-7sJKLZfPR0I9Bpgfe3UYqiGoFhxQ7FgmsEXBwXggThbUdzEl8JsydSQfR6e4GC0OKZZVrGZc0gTdDeSdYQHCKw==",
+      "version": "0.16.1",
+      "resolved": "https://registry.npmjs.org/@synnaxlabs/x/-/x-0.16.1.tgz",
+      "integrity": "sha512-vIqspjkkOregeriSQotu56NQPuX8xLV/7usudYILS3tKLzOCQQ2nR2r3lkVLseSMeiNxw3nLeY+roH3KxK13pA==",
       "dependencies": {
         "async-mutex": "^0.4.1",
         "js-convert-case": "^4.2.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.23.1",
+  "version": "0.25.0",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -17,20 +17,19 @@
   ],
   "dependencies": {
     "async-mutex": "^0.5.0",
-    "nanoid": "^3.0.0",
     "zod": "3.23.8",
-    "@synnaxlabs/x": "0.23.0",
-    "@synnaxlabs/freighter": "0.23.0"
+    "@synnaxlabs/freighter": "0.25.0",
+    "@synnaxlabs/x": "0.25.0"
   },
   "devDependencies": {
-    "@types/node": "^20.12.7",
-    "@vitest/coverage-v8": "^1.5.0",
-    "eslint": "^9.0.0",
-    "typescript": "^5.4.5",
-    "vite": "5.2.11",
-    "vitest": "^1.5.0",
-    "@synnaxlabs/vite-plugin": "0.0.1",
+    "@types/node": "^20.14.9",
+    "@vitest/coverage-v8": "^1.6.0",
+    "eslint": "^9.6.0",
+    "typescript": "^5.5.3",
+    "vite": "5.3.3",
+    "vitest": "^1.6.0",
     "@synnaxlabs/tsconfig": "0.0.2",
+    "@synnaxlabs/vite-plugin": "0.0.1",
     "eslint-config-synnaxlabs": "0.0.1"
   },
   "peerDependencies": {

package/src/auth/auth.ts

@@ -73,7 +73,7 @@ export class Client {
       }
       reqCtx.params.Authorization = `Bearer ${this.token}`;
       const [resCtx, err] = await next(reqCtx);
-      if (err instanceof InvalidTokenError && this.retryCount < MAX_RETRIES) {
+      if (InvalidTokenError.matches(err) && this.retryCount < MAX_RETRIES) {
         this.authenticated = false;
         this.authenticating = undefined;
         this.retryCount += 1;

package/src/channel/channel.spec.ts

@@ -246,14 +246,15 @@ describe("Channel", () => {
           dataType: DataType.FLOAT32,
         },
       ]);
+      // Retrieve channels here to ensure we check for cache invalidation
+      const initial = await client.channels.retrieve(channels.map((c) => c.key));
+      expect(initial[0].name).toEqual("test1");
+      expect(initial[1].name).toEqual("test2");
       await client.channels.rename(
-        [channels[0].key, channels[1].key],
+        channels.map((c) => c.key),
         ["test3", "test4"],
       );
-      const renamed = await client.channels.retrieve([
-        channels[0].key,
-        channels[1].key,
-      ]);
+      const renamed = await client.channels.retrieve(channels.map((c) => c.key));
       expect(renamed[0].name).toEqual("test3");
       expect(renamed[1].name).toEqual("test4");
     });

package/src/channel/client.ts

@@ -7,7 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type UnaryClient } from "@synnaxlabs/freighter";
+import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
 import {
   type CrudeDensity,
@@ -19,6 +19,7 @@ import {
   type TypedArray,
 } from "@synnaxlabs/x/telem";
 import { toArray } from "@synnaxlabs/x/toArray";
+import { z } from "zod";
 
 import {
   type Key,
@@ -39,6 +40,8 @@ import {
 import { type Writer } from "@/channel/writer";
 import { ValidationError } from "@/errors";
 import { type framer } from "@/framer";
+import { ontology } from "@/ontology";
+import { group } from "@/ontology/group";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 interface CreateOptions {
@@ -150,6 +153,13 @@ export class Channel {
     });
   }
 
+  /***
+   * @returns the ontology ID of the channel
+   */
+  get ontologyID(): ontology.ID {
+    return new ontology.ID({ type: "channel", key: this.key.toString() });
+  }
+
   /**
    * Reads telemetry from the channel between the two timestamps.
    *
@@ -172,6 +182,14 @@ export class Channel {
   }
 }
 
+const RETRIEVE_GROUP_ENDPOINT = "/channel/retrieve-group";
+
+const retrieveGroupReqZ = z.object({});
+
+const retrieveGroupResZ = z.object({
+  group: group.groupZ,
+});
+
 /**
  * The core client class for executing channel operations against a Synnax
  * cluster. This class should not be instantiated directly, and instead should be used
@@ -382,4 +400,15 @@ export class Client implements AsyncTermSearcher<string, Key, Channel> {
     const { frameClient } = this;
     return payloads.map((p) => new Channel({ ...p, frameClient }));
   }
+
+  async retrieveGroup(): Promise<group.Group> {
+    const res = await sendRequired(
+      this.client,
+      RETRIEVE_GROUP_ENDPOINT,
+      {},
+      retrieveGroupReqZ,
+      retrieveGroupResZ,
+    );
+    return new group.Group(res.group.name, res.group.key);
+  }
 }

package/src/channel/retriever.ts

@@ -103,7 +103,7 @@ export class ClusterRetriever implements Retriever {
 
 export class CacheRetriever implements Retriever {
   private readonly cache: Map<number, Payload>;
-  private readonly namesToKeys: Map<string, number>;
+  private readonly namesToKeys: Map<string, Set<number>>;
   private readonly wrapped: Retriever;
 
   constructor(wrapped: Retriever) {
@@ -128,27 +128,77 @@ export class CacheRetriever implements Retriever {
     const results: Payload[] = [];
     const toFetch: KeysOrNames = [];
     normalized.forEach((keyOrName) => {
-      const c = this.getFromCache(keyOrName);
-      if (c != null) results.push(c);
+      const c = this.get(keyOrName);
+      if (c != null) results.push(...c);
       else toFetch.push(keyOrName as never);
     });
     if (toFetch.length === 0) return results;
     const fetched = await this.wrapped.retrieve(toFetch, options);
-    this.updateCache(fetched);
+    this.set(fetched);
     return results.concat(fetched);
   }
 
-  private updateCache(channels: Payload[]): void {
+  delete(channels: Params): void {
+    const { variant, normalized } = analyzeChannelParams(channels);
+    if (variant === "names")
+      (normalized as string[]).forEach((name) => {
+        const keys = this.namesToKeys.get(name);
+        if (keys == null) return;
+        keys.forEach((k) => this.cache.delete(k));
+        this.namesToKeys.delete(name);
+      });
+    else
+      (normalized as number[]).forEach((key) => {
+        const channel = this.cache.get(key);
+        if (channel == null) return;
+        this.cache.delete(key);
+        this.namesToKeys.delete(channel.name);
+      });
+  }
+
+  rename(keys: Key[], names: string[]): void {
+    keys.forEach((key, i) => {
+      const name = names[i];
+      const ch = this.cache.get(key);
+      if (ch == null) return;
+      this.cache.delete(key);
+      const keys = this.namesToKeys.get(ch.name);
+      if (keys != null) {
+        keys.delete(key);
+        if (keys.size === 0) this.namesToKeys.delete(ch.name);
+      }
+      ch.name = name;
+      this.cache.set(key, ch);
+      const newKeys = this.namesToKeys.get(name);
+      if (newKeys == null) this.namesToKeys.set(name, new Set([key]));
+      else newKeys.add(key);
+    });
+  }
+
+  set(channels: Payload[]): void {
     channels.forEach((channel) => {
       this.cache.set(channel.key, channel);
-      this.namesToKeys.set(channel.name, channel.key);
+      const keys = this.namesToKeys.get(channel.name);
+      if (keys == null) this.namesToKeys.set(channel.name, new Set([channel.key]));
+      else keys.add(channel.key);
     });
   }
 
-  private getFromCache(channel: KeyOrName): Payload | undefined {
-    const key = typeof channel === "number" ? channel : this.namesToKeys.get(channel);
-    if (key == null) return undefined;
-    return this.cache.get(key);
+  private get(channel: KeyOrName): Payload[] | undefined {
+    if (typeof channel === "number") {
+      const ch = this.cache.get(channel);
+      if (ch == null) return undefined;
+      return [ch];
+    }
+    const keys = this.namesToKeys.get(channel);
+    if (keys == null) return undefined;
+    const channels: Payload[] = [];
+    keys.forEach((key) => {
+      const ch = this.cache.get(key);
+      if (ch != null) channels.push(ch);
+    });
+    if (channels.length === 0) return undefined;
+    return channels;
   }
 }
 

package/src/channel/writer.ts

@@ -18,6 +18,7 @@ import {
   type Payload,
   payload,
 } from "@/channel/payload";
+import { CacheRetriever } from "@/channel/retriever";
 
 const createReqZ = z.object({ channels: newPayload.array() });
 const createResZ = z.object({ channels: payload.array() });
@@ -43,21 +44,20 @@ export type RenameProps = z.input<typeof renameReqZ>;
 
 export class Writer {
   private readonly client: UnaryClient;
+  private readonly cache: CacheRetriever;
 
-  constructor(client: UnaryClient) {
+  constructor(client: UnaryClient, cache: CacheRetriever) {
     this.client = client;
+    this.cache = cache;
   }
 
   async create(channels: NewPayload[]): Promise<Payload[]> {
-    return (
-      await sendRequired<typeof createReqZ, typeof createResZ>(
-        this.client,
-        CREATE_ENDPOINT,
-        { channels },
-        createReqZ,
-        createResZ,
-      )
-    ).channels;
+    const { channels: created } = await sendRequired<
+      typeof createReqZ,
+      typeof createResZ
+    >(this.client, CREATE_ENDPOINT, { channels }, createReqZ, createResZ);
+    this.cache.set(created);
+    return created;
   }
 
   async delete(props: DeleteProps): Promise<void> {
@@ -68,6 +68,8 @@ export class Writer {
       deleteReqZ,
       deleteResZ,
     );
+    if (props.keys != null) this.cache.delete(props.keys);
+    if (props.names != null) this.cache.delete(props.names);
   }
 
   async rename(keys: Key[], names: string[]): Promise<void> {
@@ -78,5 +80,6 @@ export class Writer {
       renameReqZ,
       renameResZ,
     );
+    this.cache.rename(keys, names);
   }
 }

package/src/client.ts

@@ -83,7 +83,7 @@ export default class Synnax extends framer.Client {
    * @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 5 seconds.
+   * 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.
    *
@@ -106,7 +106,7 @@ export default class Synnax extends framer.Client {
     const chRetriever = new channel.CacheRetriever(
       new channel.ClusterRetriever(transport.unary),
     );
-    const chCreator = new channel.Writer(transport.unary);
+    const chCreator = new channel.Writer(transport.unary, chRetriever);
     super(transport.stream, transport.unary, chRetriever);
     this.createdAt = TimeStamp.now();
     this.props = props;

package/src/errors.spec.ts

@@ -0,0 +1,39 @@
+import { MatchableErrorType } from "@synnaxlabs/freighter/src/errors";
+import { describe, expect, test } from "vitest";
+
+import {
+  AuthError,
+  ContiguityError,
+  ControlError,
+  FieldError,
+  InvalidTokenError,
+  MultipleFoundError,
+  NotFoundError,
+  QueryError,
+  RouteError,
+  UnauthorizedError,
+  UnexpectedError,
+  ValidationError,
+} from "@/errors";
+
+describe("error", () => {
+  describe("type matching", () => {
+    const ERRORS: [string, Error, MatchableErrorType][] = [
+      [ValidationError.TYPE, new ValidationError(), ValidationError],
+      [FieldError.TYPE, new FieldError("field", "message"), FieldError],
+      [AuthError.TYPE, new AuthError(), AuthError],
+      [InvalidTokenError.TYPE, new InvalidTokenError(), InvalidTokenError],
+      [UnexpectedError.TYPE, new UnexpectedError("message"), UnexpectedError],
+      [QueryError.TYPE, new QueryError("message"), QueryError],
+      [NotFoundError.TYPE, new NotFoundError("message"), NotFoundError],
+      [MultipleFoundError.TYPE, new MultipleFoundError("message"), MultipleFoundError],
+      [RouteError.TYPE, new RouteError("message", ""), RouteError],
+      [ControlError.TYPE, new ControlError("message"), ControlError],
+      [UnauthorizedError.TYPE, new UnauthorizedError("message"), UnauthorizedError],
+      [ContiguityError.TYPE, new ContiguityError("message"), ContiguityError],
+    ];
+    ERRORS.forEach(([typeName, error, type]) =>
+      test(`matches ${typeName}`, () => expect(type.matches(error)).toBeTruthy()),
+    );
+  });
+});

package/src/errors.ts

@@ -8,6 +8,8 @@
 // included in the file licenses/APL.txt.
 
 import {
+  BaseTypedError,
+  errorMatcher,
   type ErrorPayload,
   type Middleware,
   registerError,
@@ -24,12 +26,16 @@ export interface Field {
 /**
  * Raised when a validation error occurs.
  */
-export class ValidationError extends Error {
+export class ValidationError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "validation";
+  type = ValidationError.TYPE;
+  static readonly matches = errorMatcher(ValidationError.TYPE);
 }
 
 export class FieldError extends ValidationError {
   static readonly TYPE = ValidationError.TYPE + ".field";
+  type = FieldError.TYPE;
+  static readonly matches = errorMatcher(FieldError.TYPE);
   readonly field: string;
   readonly message: string;
 
@@ -43,8 +49,10 @@ export class FieldError extends ValidationError {
 /**
  * AuthError is raised when an authentication error occurs.
  */
-export class AuthError extends Error {
+export class AuthError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "auth";
+  type = AuthError.TYPE;
+  static readonly matches = errorMatcher(AuthError.TYPE);
 }
 
 /**
@@ -52,13 +60,17 @@ export class AuthError extends Error {
  */
 export class InvalidTokenError extends AuthError {
   static readonly TYPE = AuthError.TYPE + ".invalid-token";
+  type = InvalidTokenError.TYPE;
+  static readonly matches = errorMatcher(InvalidTokenError.TYPE);
 }
 
 /**
  * UnexpectedError is raised when an unexpected error occurs.
  */
-export class UnexpectedError extends Error {
+export class UnexpectedError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "unexpected";
+  type = UnexpectedError.TYPE;
+  static readonly matches = errorMatcher(UnexpectedError.TYPE);
 
   constructor(message: string) {
     super(`
@@ -74,23 +86,31 @@ export class UnexpectedError extends Error {
 /**
  * QueryError is raised when a query error occurs.
  */
-export class QueryError extends Error {
+export class QueryError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "query";
+  type = QueryError.TYPE;
+  static readonly matches = errorMatcher(QueryError.TYPE);
 }
 
 export class NotFoundError extends QueryError {
   static readonly TYPE = QueryError.TYPE + ".not_found";
+  type = NotFoundError.TYPE;
+  static readonly matches = errorMatcher(NotFoundError.TYPE);
 }
 
 export class MultipleFoundError extends QueryError {
   static readonly TYPE = QueryError.TYPE + ".multiple_results";
+  type = MultipleFoundError.TYPE;
+  static readonly matches = errorMatcher(MultipleFoundError.TYPE);
 }
 
 /**
  * RouteError is raised when a routing error occurs.
  */
-export class RouteError extends Error {
+export class RouteError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "route";
+  type = RouteError.TYPE;
+  static readonly matches = errorMatcher(RouteError.TYPE);
   path: string;
 
   constructor(message: string, path: string) {
@@ -99,18 +119,26 @@ export class RouteError extends Error {
   }
 }
 
-export class ControlError extends Error {
+export class ControlError extends BaseTypedError {
   static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "control";
+  type = ControlError.TYPE;
+  static readonly matches = errorMatcher(ControlError.TYPE);
 }
 
 export class UnauthorizedError extends ControlError {
   static readonly TYPE = ControlError.TYPE + ".unauthorized";
+  type = UnauthorizedError.TYPE;
+  static readonly matches = errorMatcher(UnauthorizedError.TYPE);
 }
 
 /**
  * Raised when time-series data is not contiguous.
  */
-export class ContiguityError extends Error {}
+export class ContiguityError extends BaseTypedError {
+  static readonly TYPE = _FREIGHTER_EXCEPTION_PREFIX + "contiguity";
+  type = ContiguityError.TYPE;
+  static readonly matches = errorMatcher(ContiguityError.TYPE);
+}
 
 const decode = (payload: ErrorPayload): Error | null => {
   if (!payload.type.startsWith(_FREIGHTER_EXCEPTION_PREFIX)) return null;

package/src/framer/client.spec.ts

@@ -60,4 +60,10 @@ describe("Client", () => {
       await client.write(start, data.key, 1);
     });
   });
+  describe("retrieveGroup", () => {
+    it("should correctly retrieve the main channel group", async () => {
+      const group = await client.channels.retrieveGroup();
+      expect(group.name).toEqual("Channels");
+    });
+  });
 });