@synnaxlabs/client 0.15.0 → 0.15.2

package/dist/control/authority.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare class Authority extends Number {
-    static readonly ABSOLUTE = 255;
-    static readonly DEFAULT = 1;
+    static readonly Absolute = 255;
+    static readonly Default = 1;
     static readonly z: z.ZodUnion<[z.ZodType<Authority, z.ZodTypeDef, Authority>, z.ZodEffects<z.ZodNumber, Authority, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Authority, Number>]>;
 }

package/dist/framer/client.d.ts

@@ -26,7 +26,7 @@ export declare class Client {
      * for more information.
      * @returns a new {@link RecordWriter}.
      */
-    newWriter({ start, channels, controlSubject, authorities, }: WriterConfig): Promise<Writer>;
+    newWriter({ start, channels, controlSubject, authorities, mode, }: WriterConfig): Promise<Writer>;
     newStreamer(params: Params, from?: TimeStamp): Promise<Streamer>;
     /**
      * Writes telemetry to the given channel starting at the given timestamp.

package/dist/framer/writer.d.ts

@@ -11,7 +11,13 @@ declare enum Command {
     Write = 1,
     Commit = 2,
     Error = 3,
-    SetAuthority = 4
+    SetAuthority = 4,
+    SetMode = 5
+}
+export declare enum WriterMode {
+    PersistStream = 1,
+    PersistOnly = 2,
+    StreamOnly = 3
 }
 declare const reqZ: z.ZodObject<{
     command: z.ZodNativeEnum<typeof Command>;
@@ -27,24 +33,27 @@ declare const reqZ: z.ZodObject<{
             name: string;
             key: string;
         }>>;
-        keys: z.ZodArray<z.ZodNumber, "many">;
+        keys: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
         authorities: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<Authority, z.ZodTypeDef, Authority>, z.ZodEffects<z.ZodNumber, Authority, number>, z.ZodEffects<z.ZodType<Number, z.ZodTypeDef, Number>, Authority, Number>]>, "many">>;
+        mode: z.ZodOptional<z.ZodNativeEnum<typeof WriterMode>>;
     }, "strip", z.ZodTypeAny, {
-        keys: number[];
         start?: TimeStamp | undefined;
         controlSubject?: {
             name: string;
             key: string;
         } | undefined;
+        keys?: number[] | undefined;
         authorities?: Authority[] | undefined;
+        mode?: WriterMode | undefined;
     }, {
-        keys: number[];
         start?: number | Number | TimeStamp | undefined;
         controlSubject?: {
             name: string;
             key: string;
         } | undefined;
+        keys?: number[] | undefined;
         authorities?: (number | Number | Authority)[] | undefined;
+        mode?: WriterMode | undefined;
     }>>;
     frame: z.ZodOptional<z.ZodObject<{
         keys: z.ZodUnion<[z.ZodEffects<z.ZodNull, number[], null>, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>>]>;
@@ -107,13 +116,14 @@ declare const reqZ: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     command: Command;
     config?: {
-        keys: number[];
         start?: TimeStamp | undefined;
         controlSubject?: {
             name: string;
             key: string;
         } | undefined;
+        keys?: number[] | undefined;
         authorities?: Authority[] | undefined;
+        mode?: WriterMode | undefined;
     } | undefined;
     frame?: {
         keys: number[];
@@ -127,13 +137,14 @@ declare const reqZ: z.ZodObject<{
 }, {
     command: Command;
     config?: {
-        keys: number[];
         start?: number | Number | TimeStamp | undefined;
         controlSubject?: {
             name: string;
             key: string;
         } | undefined;
+        keys?: number[] | undefined;
         authorities?: (number | Number | Authority)[] | undefined;
+        mode?: WriterMode | undefined;
     } | undefined;
     frame?: {
         keys?: number[] | null | undefined;
@@ -183,6 +194,7 @@ export interface WriterConfig {
     channels: Params;
     controlSubject?: ControlSubject;
     authorities?: Authority | Authority[];
+    mode?: WriterMode;
 }
 /**
  * Writer is used to write telemetry to a set of channels in time order.
@@ -227,10 +239,11 @@ export declare class Writer {
     private readonly stream;
     private readonly adapter;
     private constructor();
-    static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, }: WriterConfig): Promise<Writer>;
+    static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, mode, }: WriterConfig): Promise<Writer>;
     write(channel: KeyOrName, data: NativeTypedArray): Promise<boolean>;
     write(frame: CrudeFrame): Promise<boolean>;
     setAuthority(value: Record<Key, Authority>): Promise<boolean>;
+    setMode(mode: WriterMode): Promise<boolean>;
     /**
      * Commits the written frames to the database. Commit is synchronous, meaning that it
      * will not return until all frames have been commited to the database.

package/dist/hardware/device/client.d.ts

@@ -1,9 +1,10 @@
+import { AsyncTermSearcher } from "@synnaxlabs/x";
 import { type framer } from '../../framer';
-import { type Device } from './payload';
+import { type Device, DeviceKey } from './payload';
 import { type Retriever } from './retriever';
 import { type Writer } from './writer';
 import { signals } from '../../signals';
-export declare class Client {
+export declare class Client implements AsyncTermSearcher<string, DeviceKey, Device> {
     private readonly retriever;
     private readonly writer;
     private readonly frameClient;
@@ -11,6 +12,8 @@ export declare class Client {
     create(device: Device): Promise<Device>;
     retrieve(key: string): Promise<Device>;
     retrieve(keys: string[]): Promise<Device[]>;
+    search(term: string): Promise<Device[]>;
+    page(offset: number, limit: number): Promise<Device[]>;
     delete(keys: string[]): Promise<void>;
     openDeviceTracker(): Promise<signals.Observable<string, Device>>;
 }

package/dist/hardware/device/retriever.d.ts

@@ -3,5 +3,7 @@ import { type Device } from './payload';
 export declare class Retriever {
     private readonly client;
     constructor(client: UnaryClient);
+    search(term: string): Promise<Device[]>;
+    page(offset: number, limit: number): Promise<Device[]>;
     retrieve(keys: string[]): Promise<Device[]>;
 }

package/dist/hardware/external.d.ts

@@ -1,2 +1 @@
-export * from './rack';
 export * from './client';

package/dist/hardware/rack/client.d.ts

@@ -1,11 +1,12 @@
 import { type framer } from '../../framer';
-import { type NewRack } from './payload';
+import { RackKey, type NewRack } from './payload';
 import { type Retriever } from './retriever';
 import { type Writer } from './writer';
 import { type NewTask, type Task } from '../task/payload';
 import { type Retriever as TaskRetriever } from '../task/retriever';
 import { type Writer as TaskWriter } from '../task/writer';
-export declare class Client {
+import { AsyncTermSearcher } from "@synnaxlabs/x";
+export declare class Client implements AsyncTermSearcher<string, RackKey, Rack> {
     private readonly retriever;
     private readonly writer;
     private readonly frameClient;
@@ -13,7 +14,10 @@ export declare class Client {
     private readonly taskRetriever;
     constructor(retriever: Retriever, writer: Writer, frameClient: framer.Client, taskWriter: TaskWriter, taskRetriever: TaskRetriever);
     create(rack: NewRack): Promise<Rack>;
-    retrieve(key: number): Promise<Rack>;
+    search(term: string): Promise<Rack[]>;
+    page(offset: number, limit: number): Promise<Rack[]>;
+    retrieve(key: RackKey): Promise<Rack>;
+    retrieve(keys: RackKey[]): Promise<Rack[]>;
     private sugar;
 }
 export declare class Rack {

package/dist/hardware/rack/retriever.d.ts

@@ -3,5 +3,7 @@ import { type RackPayload } from './payload';
 export declare class Retriever {
     private readonly client;
     constructor(client: UnaryClient);
+    page(offset: number, limit: number): Promise<RackPayload[]>;
+    search(term: string): Promise<RackPayload[]>;
     retrieve(keys: number[]): Promise<RackPayload[]>;
 }

package/dist/hardware/task/client.d.ts

@@ -1,10 +1,13 @@
-import { type NewTask, type Task } from './payload';
+import { AsyncTermSearcher } from "@synnaxlabs/x";
+import { TaskKey, type NewTask, type Task } from './payload';
 import { type Retriever } from './retriever';
 import { type Writer } from './writer';
-export declare class Client {
+export declare class Client implements AsyncTermSearcher<string, TaskKey, Task> {
     private readonly retriever;
     private readonly writer;
     constructor(retriever: Retriever, writer: Writer);
+    search(term: string): Promise<Task[]>;
+    page(offset: number, limit: number): Promise<Task[]>;
     create(task: NewTask): Promise<Task>;
     retrieve(rack: number): Promise<Task[]>;
     retrieve(keys: string[]): Promise<Task[]>;

package/dist/hardware/task/payload.d.ts

@@ -1,21 +1,22 @@
 import { type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 export declare const taskKeyZ: z.ZodEffects<z.ZodUnion<[z.ZodBigInt, z.ZodNumber]>, string, number | bigint>;
+export type TaskKey = z.infer<typeof taskKeyZ>;
 export declare const taskZ: z.ZodObject<{
     key: z.ZodEffects<z.ZodUnion<[z.ZodBigInt, z.ZodNumber]>, string, number | bigint>;
     name: z.ZodString;
     type: z.ZodString;
-    config: z.ZodType<Partial<Record<import("@synnaxlabs/x").Key, unknown>>, z.ZodTypeDef, Partial<Record<import("@synnaxlabs/x").Key, unknown>>>;
+    config: z.ZodType<UnknownRecord, z.ZodTypeDef, UnknownRecord>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     key: string;
     type: string;
-    config: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    config: UnknownRecord;
 }, {
     name: string;
     key: number | bigint;
     type: string;
-    config: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    config: UnknownRecord;
 }>;
 export declare const newTaskZ: z.ZodObject<{
     name: z.ZodString;

package/dist/hardware/task/retriever.d.ts

@@ -4,17 +4,25 @@ import { type Task } from './payload';
 declare const retrieveReqZ: z.ZodObject<{
     rack: z.ZodOptional<z.ZodNumber>;
     keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     rack?: number | undefined;
     keys?: string[] | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
 }, {
     rack?: number | undefined;
     keys?: string[] | undefined;
+    offset?: number | undefined;
+    limit?: number | undefined;
 }>;
 export type RetrieveRequest = z.infer<typeof retrieveReqZ>;
 export declare class Retriever {
     private readonly client;
     constructor(client: UnaryClient);
     retrieve(params: RetrieveRequest): Promise<Task[]>;
+    search(term: string): Promise<Task[]>;
+    page(offset: number, limit: number): Promise<Task[]>;
 }
 export {};

package/dist/index.d.ts

@@ -15,3 +15,6 @@ export { workspace } from './workspace';
 export { ranger } from './ranger';
 export { label } from './label';
 export { hardware } from './hardware';
+export { rack } from './hardware/rack';
+export { task } from './hardware/task';
+export { device } from './hardware/device';

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

@@ -1,3 +1,4 @@
+import { type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;
@@ -18,11 +19,11 @@ export declare const linePlotZ: z.ZodObject<{
 export declare const linePlotRemoteZ: z.ZodObject<{
     key: z.ZodString;
     name: z.ZodString;
-    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    data: z.ZodEffects<z.ZodString, UnknownRecord, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     key: string;
-    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    data: UnknownRecord;
 }, {
     name: string;
     key: string;

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

@@ -18,10 +18,10 @@ export declare const crudeLinePlotZ: z.ZodObject<{
 export declare const linePlotWriteZ: z.ZodObject<{
     name: z.ZodString;
     key: z.ZodOptional<z.ZodString>;
-    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    data: z.ZodEffects<z.ZodString, UnknownRecord, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    data: UnknownRecord;
     key?: string | undefined;
 }, {
     name: string;

package/dist/workspace/payload.d.ts

@@ -1,3 +1,4 @@
+import { type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;
@@ -18,11 +19,11 @@ export declare const workspaceZ: z.ZodObject<{
 export declare const workspaceRemoteZ: z.ZodObject<{
     name: z.ZodString;
     key: z.ZodString;
-    layout: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    layout: z.ZodEffects<z.ZodString, UnknownRecord, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     key: string;
-    layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    layout: UnknownRecord;
 }, {
     name: string;
     key: string;

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

@@ -1,3 +1,4 @@
+import { type UnknownRecord } from "@synnaxlabs/x";
 import { z } from "zod";
 export declare const keyZ: z.ZodString;
 export type Key = z.infer<typeof keyZ>;
@@ -22,11 +23,11 @@ export declare const pidRemoteZ: z.ZodObject<{
     key: z.ZodString;
     name: z.ZodString;
     snapshot: z.ZodBoolean;
-    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    data: z.ZodEffects<z.ZodString, UnknownRecord, string>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     key: string;
-    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    data: UnknownRecord;
     snapshot: boolean;
 }, {
     name: string;

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

@@ -21,11 +21,11 @@ export declare const crudePIDz: z.ZodObject<{
 export declare const pidWriteZ: z.ZodObject<{
     name: z.ZodString;
     key: z.ZodOptional<z.ZodString>;
-    data: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+    data: z.ZodEffects<z.ZodString, UnknownRecord, string>;
     snapshot: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    data: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+    data: UnknownRecord;
     key?: string | undefined;
     snapshot?: boolean | undefined;
 }, {

package/dist/workspace/writer.d.ts

@@ -20,11 +20,11 @@ declare const createResZ: z.ZodObject<{
     workspaces: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         key: z.ZodString;
-        layout: z.ZodEffects<z.ZodString, Partial<Record<import("@synnaxlabs/x").Key, unknown>>, string>;
+        layout: z.ZodEffects<z.ZodString, UnknownRecord, string>;
     }, "strip", z.ZodTypeAny, {
         name: string;
         key: string;
-        layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+        layout: UnknownRecord;
     }, {
         name: string;
         key: string;
@@ -34,7 +34,7 @@ declare const createResZ: z.ZodObject<{
     workspaces: {
         name: string;
         key: string;
-        layout: Partial<Record<import("@synnaxlabs/x").Key, unknown>>;
+        layout: UnknownRecord;
     }[];
 }, {
     workspaces: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.15.0",
+  "version": "0.15.2",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -17,8 +17,8 @@
   ],
   "dependencies": {
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.7.0",
-    "@synnaxlabs/x": "0.10.0"
+    "@synnaxlabs/freighter": "0.7.1",
+    "@synnaxlabs/x": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -27,8 +27,8 @@
     "vite": "^5.1.2",
     "vitest": "^1.2.2",
     "@synnaxlabs/vite-plugin": "0.0.1",
-    "@synnaxlabs/tsconfig": "0.0.2",
-    "eslint-config-synnaxlabs": "0.0.1"
+    "eslint-config-synnaxlabs": "0.0.1",
+    "@synnaxlabs/tsconfig": "0.0.2"
   },
   "main": "dist/client.cjs.js",
   "module": "dist/client.es.js",

package/src/client.ts

@@ -24,6 +24,7 @@ import { hardware } from "./hardware";
 import { device } from "./hardware/device";
 import { rack } from "./hardware/rack";
 import { task } from "./hardware/task";
+import { randomUUID } from "crypto";
 
 export const synnaxPropsZ = z.object({
   host: z.string().min(1),

package/src/control/authority.ts

@@ -10,8 +10,8 @@
 import { z } from "zod";
 
 export class Authority extends Number {
-  static readonly ABSOLUTE = 255;
-  static readonly DEFAULT = 1;
+  static readonly Absolute = 255;
+  static readonly Default = 1;
 
   static readonly z = z.union([
     z.instanceof(Authority),

package/src/framer/adapter.ts

@@ -9,6 +9,7 @@
 
 import { type Key, type Name, type Params } from "@/channel/payload";
 import { type Retriever, analyzeParams } from "@/channel/retriever";
+import { ValidationError } from "@/errors";
 import { type Frame } from "@/framer/frame";
 
 export class BackwardFrameAdapter {
@@ -95,22 +96,28 @@ export class ForwardFrameAdapter {
     this.adapter = a;
     normalized.forEach((name) => {
       const channel = fetched.find((channel) => channel.name === name);
-      if (channel == null) throw new Error(`Channel ${name} not found`);
+      if (channel == null) throw new ValidationError(`Channel ${name} was not provided in the list of channels when opening the writer`);
       a.set(channel.name, channel.key);
     });
     this.keys = fetched.map((c) => c.key);
   }
 
   adapt(fr: Frame): Frame {
-    if (this.adapter == null) return fr;
+    if (this.adapter == null) {
+      // assert that every col if of type number
+      fr.columns.forEach((col) => { 
+        if (typeof col !== "number") throw new ValidationError(`Channel ${col} was not provided in the list of channels when opening the writer`);
+      });
+      return fr;
+    }
     const a = this.adapter;
-    return fr.map((k, arr) => {
-      if (typeof k === "string") {
-        const key = a.get(k);
-        if (key == null) throw new Error(`Channel ${k} not found`);
+    return fr.map((col, arr) => {
+      if (typeof col === "string") {
+        const key = a.get(col);
+        if (key == null) throw new Error(`Channel ${col} not found`);
         return [key, arr];
       }
-      return [k, arr];
+      return [col, arr];
     });
   }
 }

package/src/framer/client.ts

@@ -22,7 +22,7 @@ import { Authority } from "@/control/authority";
 import { Frame } from "@/framer/frame";
 import { Iterator } from "@/framer/iterator";
 import { Streamer } from "@/framer/streamer";
-import { Writer, type WriterConfig } from "@/framer/writer";
+import { Writer, WriterMode, type WriterConfig } from "@/framer/writer";
 
 export class Client {
   private readonly stream: StreamClient;
@@ -56,13 +56,15 @@ export class Client {
     start,
     channels,
     controlSubject,
-    authorities = Authority.ABSOLUTE,
+    authorities = Authority.Absolute,
+    mode = WriterMode.PersistStream,
   }: WriterConfig): Promise<Writer> {
     return await Writer._open(this.retriever, this.stream, {
       start: start ?? TimeStamp.now(),
       controlSubject,
       channels,
       authorities,
+      mode,
     });
   }
 
@@ -87,7 +89,11 @@ export class Client {
     start: CrudeTimeStamp,
     data: NativeTypedArray,
   ): Promise<void> {
-    const w = await this.newWriter({ start, channels: to });
+    const w = await this.newWriter({
+      start,
+      channels: to,
+      mode: WriterMode.PersistOnly,
+    });
     try {
       await w.write(to, data);
       if (!(await w.commit())) throw (await w.error()) as Error;

package/src/framer/writer.spec.ts

@@ -11,19 +11,19 @@ import { DataType, Rate, TimeRange, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, test } from "vitest";
 
 import { type channel } from "@/channel";
+import { WriterMode } from "@/framer/writer";
 import { newClient } from "@/setupspecs";
 import { randomSeries } from "@/util/telem";
 
 const client = newClient();
 
-const newChannel = async (): Promise<channel.Channel> => {
-  return await client.channels.create({
+const newChannel = async (): Promise<channel.Channel> =>
+  await client.channels.create({
     name: "test",
     leaseholder: 1,
     rate: Rate.hz(1),
     dataType: DataType.FLOAT64,
   });
-};
 
 describe("Writer", () => {
   describe("Writer", () => {
@@ -38,6 +38,34 @@ describe("Writer", () => {
       }
       expect(true).toBeTruthy();
     });
+    test("write to unknown channel key", async () => {
+      const ch = await newChannel();
+      const writer = await client.telem.newWriter({ start: 0, channels: ch.key });
+      await expect(
+        writer.write("billy bob", randomSeries(10, DataType.FLOAT64)),
+      ).rejects.toThrow("Channel billy bob was not provided");
+      await writer.close();
+    });
+    test("stream when mode is set ot persist only", async () => {
+      const ch = await newChannel();
+      const stream = await client.telem.newStreamer(ch.key);
+      const writer = await client.telem.newWriter({
+        start: 0,
+        channels: ch.key,
+        mode: WriterMode.PersistOnly,
+      });
+      try {
+        await writer.write(ch.key, randomSeries(10, ch.dataType));
+      } finally {
+        await writer.close();
+      }
+      // Simulating a timeout.
+      const v = await Promise.race([
+        stream.read(),
+        new Promise((resolve) => setTimeout(() => resolve(123), 250)),
+      ]);
+      expect(v).toEqual(123);
+    });
   });
   describe("Client", () => {
     test("Client - basic write", async () => {

package/src/framer/writer.ts

@@ -36,13 +36,21 @@ enum Command {
   Commit = 2,
   Error = 3,
   SetAuthority = 4,
+  SetMode = 5,
+}
+
+export enum WriterMode {
+  PersistStream = 1,
+  PersistOnly = 2,
+  StreamOnly = 3,
 }
 
 const netConfigZ = z.object({
   start: TimeStamp.z.optional(),
   controlSubject: controlSubjectZ.optional(),
-  keys: z.number().array(),
+  keys: z.number().array().optional(),
   authorities: Authority.z.array().optional(),
+  mode: z.nativeEnum(WriterMode).optional(),
 });
 
 const reqZ = z.object({
@@ -66,6 +74,7 @@ export interface WriterConfig {
   channels: Params;
   controlSubject?: ControlSubject;
   authorities?: Authority | Authority[];
+  mode?: WriterMode;
 }
 
 /**
@@ -124,9 +133,10 @@ export class Writer {
     client: StreamClient,
     {
       channels,
-      authorities = Authority.ABSOLUTE,
+      authorities = Authority.Absolute,
       controlSubject: subject,
       start,
+      mode,
     }: WriterConfig,
   ): Promise<Writer> {
     const adapter = await ForwardFrameAdapter.open(retriever, channels);
@@ -139,6 +149,7 @@ export class Writer {
         keys: adapter.keys,
         controlSubject: subject,
         authorities: toArray(authorities),
+        mode,
       },
     });
     return writer;
@@ -167,9 +178,8 @@ export class Writer {
     data?: NativeTypedArray,
   ): Promise<boolean> {
     const isKeyOrName = ["string", "number"].includes(typeof frame);
-    if (isKeyOrName) {
-      frame = new Frame(frame, new Series({data: data as NativeTypedArray}));
-    }
+    if (isKeyOrName)
+      frame = new Frame(frame, new Series({ data: data as NativeTypedArray }));
     frame = this.adapter.adapt(new Frame(frame));
     // @ts-expect-error
     this.stream.send({ command: Command.Write, frame: frame.toPayload() });
@@ -187,6 +197,14 @@ export class Writer {
     return res.ack;
   }
 
+  async setMode(mode: WriterMode): Promise<boolean> {
+    const res = await this.execute({
+      command: Command.SetMode,
+      config: { mode },
+    });
+    return res.ack;
+  }
+
   /**
    * Commits the written frames to the database. Commit is synchronous, meaning that it
    * will not return until all frames have been commited to the database.