@synnaxlabs/client 0.17.6 → 0.18.0

package/dist/framer/client.d.ts

@@ -1,10 +1,10 @@
 import { type StreamClient } from "@synnaxlabs/freighter";
-import { type TypedArray, type Series, type TimeRange, type CrudeTimeStamp, TimeStamp } from "@synnaxlabs/x";
+import { type Series, type TimeRange, type CrudeTimeStamp, type CrudeSeries } from "@synnaxlabs/x";
 import { type KeyOrName, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Frame } from './frame';
 import { Iterator } from './iterator';
-import { Streamer } from './streamer';
+import { Streamer, type StreamerConfig } from './streamer';
 import { Writer, type WriterConfig } from './writer';
 export declare class Client {
     private readonly stream;
@@ -17,7 +17,7 @@ export declare class Client {
      * @param keys - A list of channel keys to iterate over.
      * @returns a new {@link TypedIterator}.
      */
-    newIterator(tr: TimeRange, channels: Params): Promise<Iterator>;
+    openIterator(tr: TimeRange, channels: Params): Promise<Iterator>;
     /**
      * Opens a new writer on the given channels.
      *
@@ -26,18 +26,39 @@ export declare class Client {
      * for more information.
      * @returns a new {@link RecordWriter}.
      */
-    newWriter({ start, channels, controlSubject, authorities, mode, }: WriterConfig): Promise<Writer>;
-    newStreamer(params: Params, from?: TimeStamp): Promise<Streamer>;
+    openWriter(config: WriterConfig): Promise<Writer>;
+    /***
+     * Opens a new streamer on the given channels.
+     *
+     * @param channels - A key, name, list of keys, or list of names of the channels to
+     * stream values from.
+     * @throws a QueryError if any of the given channels do not exist.
+     * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
+     * a network socket will remain open.
+     */
+    openStreamer(channels: Params): Promise<Streamer>;
+    /**
+     * Opens a new streamer with the provided configuration.
+     *
+     * @param config - Configuration parameters for the streamer.
+     * @param config.channels - The channels to stream values from. Can be a key, name,
+     * list of keys, or list of names.
+     * @param config.from - If this parameter is set and is before the current time,
+     * the streamer will first read and receive historical data from before this point
+     * and then will start reading new values.
+     *
+     */
+    openStreamer(config: StreamerConfig): Promise<Streamer>;
     /**
      * Writes telemetry to the given channel starting at the given timestamp.
      *
-     * @param to - The key of the channel to write to.
+     * @param channel - The key of the channel to write to.
      * @param start - The starting timestamp of the first sample in data.
      * @param data  - The telemetry to write. This telemetry must have the same
      * data type as the channel.
      * @throws if the channel does not exist.
      */
-    write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void>;
+    write(channel: KeyOrName, start: CrudeTimeStamp, data: CrudeSeries): Promise<void>;
     read(tr: TimeRange, channel: KeyOrName): Promise<Series>;
     read(tr: TimeRange, channels: Params): Promise<Frame>;
     private readFrame;

package/dist/framer/frame.d.ts

@@ -1,4 +1,4 @@
-import { Size, Series, TimeRange, DataType, TimeStamp, type TelemValue } from "@synnaxlabs/x";
+import { Size, Series, TimeRange, DataType, TimeStamp, type TelemValue, MultiSeries } from "@synnaxlabs/x";
 import { z } from "zod";
 import { type KeyOrName, type Keys, type Names, type Params } from '../channel/payload';
 type ColumnType = "key" | "name" | null;
@@ -98,13 +98,13 @@ export declare class Frame {
      */
     get isWeaklyAligned(): boolean;
     timeRange(col?: KeyOrName): TimeRange;
-    latest(): Record<string, TelemValue>;
+    latest(): Record<string, TelemValue | undefined>;
     get timeRanges(): TimeRange[];
     /**
      * @returns lazy arrays matching the given channel key or name.
      * @param key the channel key or name.
      */
-    get(key: KeyOrName): Series[];
+    get(key: KeyOrName): MultiSeries;
     /**
      * @returns a frame with the given channel keys or names.
      * @param keys the channel keys or names.
@@ -145,6 +145,8 @@ export declare class Frame {
      * @param fn a function that takes a channel key and typed array.
      */
     forEach(fn: (k: KeyOrName, arr: Series, i: number) => void): void;
+    at(index: number, required: true): Record<KeyOrName, TelemValue>;
+    at(index: number, required?: false): Record<KeyOrName, TelemValue | undefined>;
     /**
      * @returns a new frame containing all typed arrays in the current frame that pass
      * the provided filter function.

package/dist/framer/streamer.d.ts

@@ -3,12 +3,16 @@ import { type CrudeTimeStamp } from "@synnaxlabs/x";
 import { type Key, type Params } from '../channel/payload';
 import { type Retriever } from '../channel/retriever';
 import { Frame } from './frame';
+export interface StreamerConfig {
+    channels: Params;
+    from?: CrudeTimeStamp;
+}
 export declare class Streamer implements AsyncIterator<Frame>, AsyncIterable<Frame> {
     private readonly stream;
     private readonly adapter;
     private constructor();
     get keys(): Key[];
-    static _open(start: CrudeTimeStamp, channels: Params, retriever: Retriever, client: StreamClient): Promise<Streamer>;
+    static _open(retriever: Retriever, client: StreamClient, { channels, from }: StreamerConfig): Promise<Streamer>;
     next(): Promise<IteratorResult<Frame, any>>;
     read(): Promise<Frame>;
     update(params: Params): Promise<void>;

package/dist/framer/writer.d.ts

@@ -378,43 +378,43 @@ declare const resZ: z.ZodObject<{
 }>;
 type Response = z.infer<typeof resZ>;
 export interface WriterConfig {
-    start: CrudeTimeStamp;
     channels: Params;
+    start?: CrudeTimeStamp;
     controlSubject?: ControlSubject;
     authorities?: Authority | Authority[];
     mode?: WriterMode;
 }
 /**
  * Writer is used to write telemetry to a set of channels in time order.
- * It should not be instantiated directly, and should instead be instantited via the
+ * It should not be instantiated directly, and should instead be instantiated via the
  * FramerClient {@link FrameClient#openWriter}.
  *
- * The writer is a streaming protocol that is heavily optimized for prerformance. This
- * comes at the cost of icnreased complexity, and should only be used directly when
- * writing large volumes of data (such as recording telemetry from a sensor or ingsting
- * data froma file). Simpler methods (such as the frame client's write method) should
+ * The writer is a streaming protocol that is heavily optimized for performance. This
+ * comes at the cost of increased complexity, and should only be used directly when
+ * writing large volumes of data (such as recording telemetry from a sensor or ingesting
+ * data from file). Simpler methods (such as the frame client's write method) should
  * be used for most use cases.
  *
  * The protocol is as follows:
  *
  * 1. The writer is opened with a starting timestamp and a list of channel keys. The
- * writer will fail to open if the starting timstamp overlaps with any existing telemetry
- * for any channels specified. If the writer opens successfuly, the caller is then
+ * writer will fail to open if the starting timestamp overlaps with any existing telemetry
+ * for any channels specified. If the writer opens successfully, the caller is then
  * free to write frames to the writer.
  *
  * 2. To write a frame, the caller can use the write method and follow the validation
  * rules described in its method's documentation. This process is asynchronous, meaning
  * that write calls may return before teh frame has been written to the cluster. This
  * also means that the writer can accumulate an error after write is called. If the writer
- * accumulates an erorr, all subsequent write and commit calls will return False. The
- * caller can check for errors by calling the error mehtod, which returns the accumulated
+ * accumulates an error, all subsequent write and commit calls will return False. The
+ * caller can check for errors by calling the error method, which returns the accumulated
  * error and resets the writer for future use. The caller can also check for errors by
  * closing the writer, which will throw any accumulated error.
  *
  * 3. To commit the written frames to the cluster, the caller can call the commit method.
  * Unlike write, commit is synchronous, meaning that it will not return until the frames
- * have been written to the cluster. If the writer has accumulated an erorr, commit will
- * return false. After the caller acknowledges the erorr, they can attempt to commit again.
+ * have been written to the cluster. If the writer has accumulated an error, commit will
+ * return false. After the caller acknowledges the error, they can attempt to commit again.
  * Commit can be called several times throughout a writer's lifetime, and will only
  * commit the frames that have been written since the last commit.
  *
@@ -427,7 +427,7 @@ export declare class Writer {
     private readonly stream;
     private readonly adapter;
     private constructor();
-    static _open(retriever: Retriever, client: StreamClient, { channels, authorities, controlSubject: subject, start, mode, }: WriterConfig): Promise<Writer>;
+    static _open(retriever: Retriever, client: StreamClient, { channels, start, authorities, controlSubject: subject, mode, }: WriterConfig): Promise<Writer>;
     write(channel: KeyOrName, data: CrudeSeries): Promise<boolean>;
     write(channel: KeysOrNames, data: CrudeSeries[]): Promise<boolean>;
     write(frame: CrudeFrame): Promise<boolean>;

package/dist/index.d.ts

@@ -9,8 +9,8 @@ export { Frame } from './framer/frame';
 export { ontology } from './ontology';
 export { control } from './control';
 export { Authority } from './control/authority';
-export { DataType, Density, Rate, Series, TimeRange, TimeSpan, TimeStamp, } from "@synnaxlabs/x";
-export type { TypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, SampleValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
+export { DataType, Density, Rate, Series, TimeRange, TimeSpan, TimeStamp, MultiSeries, } from "@synnaxlabs/x";
+export type { TypedArray, CrudeDataType, CrudeDensity, CrudeRate, CrudeSize, CrudeTimeSpan, CrudeTimeStamp, TelemValue, NumericTelemValue, TimeStampStringFormat, TZInfo, } from "@synnaxlabs/x";
 export { workspace } from './workspace';
 export { ranger } from './ranger';
 export { label } from './label';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@synnaxlabs/client",
   "private": false,
-  "version": "0.17.6",
+  "version": "0.18.0",
   "type": "module",
   "description": "The Client Library for Synnax",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/client/ts",
@@ -18,8 +18,8 @@
   "dependencies": {
     "async-mutex": "^0.4.0",
     "zod": "3.22.4",
-    "@synnaxlabs/freighter": "0.9.2",
-    "@synnaxlabs/x": "0.14.2"
+    "@synnaxlabs/freighter": "0.9.3",
+    "@synnaxlabs/x": "0.15.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -29,8 +29,8 @@
     "vite": "^5.1.2",
     "vitest": "^1.2.2",
     "@synnaxlabs/tsconfig": "0.0.2",
-    "@synnaxlabs/vite-plugin": "0.0.1",
-    "eslint-config-synnaxlabs": "0.0.1"
+    "eslint-config-synnaxlabs": "0.0.1",
+    "@synnaxlabs/vite-plugin": "0.0.1"
   },
   "main": "dist/client.cjs",
   "module": "dist/client.js",

package/src/control/state.ts

@@ -111,7 +111,7 @@ export class StateTracker implements observe.Observable<Transfer[]> {
   }
 
   static async open(client: FrameClient): Promise<StateTracker> {
-    const streamer = await client.newStreamer("sy_node_1_control");
+    const streamer = await client.openStreamer("sy_node_1_control");
     return new StateTracker(streamer);
   }
 

package/src/framer/adapter.spec.ts

@@ -41,8 +41,8 @@ describe("WriteFrameAdapter", () => {
     expect(res.series).toHaveLength(2);
     expect(res.get(timeCh.key)).toHaveLength(1);
     expect(res.get(dataCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a record of names to single values", async () => {
@@ -55,8 +55,8 @@ describe("WriteFrameAdapter", () => {
     expect(res2.series).toHaveLength(2);
     expect(res2.get(timeCh.key)).toHaveLength(1);
     expect(res2.get(dataCh.key)).toHaveLength(1);
-    expect(res2.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res2.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res2.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res2.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a single name to a single series", async () => {
@@ -64,7 +64,7 @@ describe("WriteFrameAdapter", () => {
     expect(res3.columns).toHaveLength(1);
     expect(res3.series).toHaveLength(1);
     expect(res3.get(dataCh.key)).toHaveLength(1);
-    expect(res3.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res3.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt multiple names to multiple series", async () => {
@@ -75,8 +75,8 @@ describe("WriteFrameAdapter", () => {
     );
     expect(res4.get(timeCh.key)).toHaveLength(1);
     expect(res4.get(dataCh.key)).toHaveLength(1);
-    expect(res4.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res4.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res4.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res4.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a frame keyed by name", async () => {
@@ -88,8 +88,8 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should not modify a frame keyed by key", async () => {
@@ -101,8 +101,8 @@ describe("WriteFrameAdapter", () => {
     const res = await adapter.adapt(fr);
     expect(res.columns).toHaveLength(2);
     expect(res.series).toHaveLength(2);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
-    expect(res.get(dataCh.key)[0].at(0)).toEqual(1);
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
+    expect(res.get(dataCh.key).at(0)).toEqual(1);
   });
 
   it("should correctly adapt a map of series", async () => {
@@ -113,6 +113,6 @@ describe("WriteFrameAdapter", () => {
     expect(res.columns).toHaveLength(1);
     expect(res.series).toHaveLength(1);
     expect(res.get(timeCh.key)).toHaveLength(1);
-    expect(res.get(timeCh.key)[0].at(0)).toEqual(Number(ts));
+    expect(res.get(timeCh.key).at(0)).toEqual(Number(ts));
   });
 });

package/src/framer/client.ts

@@ -9,19 +9,17 @@
 
 import { type StreamClient } from "@synnaxlabs/freighter";
 import {
-  type TypedArray,
   type Series,
   type TimeRange,
   type CrudeTimeStamp,
-  TimeStamp,
+  type CrudeSeries,
 } from "@synnaxlabs/x";
 
 import { type KeyOrName, type Params } from "@/channel/payload";
 import { type Retriever, analyzeParams } from "@/channel/retriever";
-import { Authority } from "@/control/authority";
 import { Frame } from "@/framer/frame";
 import { Iterator } from "@/framer/iterator";
-import { Streamer } from "@/framer/streamer";
+import { Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, WriterMode, type WriterConfig } from "@/framer/writer";
 
 export class Client {
@@ -40,7 +38,7 @@ export class Client {
    * @param keys - A list of channel keys to iterate over.
    * @returns a new {@link TypedIterator}.
    */
-  async newIterator(tr: TimeRange, channels: Params): Promise<Iterator> {
+  async openIterator(tr: TimeRange, channels: Params): Promise<Iterator> {
     return await Iterator._open(tr, channels, this.retriever, this.stream);
   }
 
@@ -52,46 +50,61 @@ export class Client {
    * for more information.
    * @returns a new {@link RecordWriter}.
    */
-  async newWriter({
-    start,
-    channels,
-    controlSubject,
-    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,
-    });
+  async openWriter(config: WriterConfig): Promise<Writer> {
+    return await Writer._open(this.retriever, this.stream, config);
   }
 
-  async newStreamer(
-    params: Params,
-    from: TimeStamp = TimeStamp.now(),
-  ): Promise<Streamer> {
-    return await Streamer._open(from, params, this.retriever, this.stream);
+  /***
+   * Opens a new streamer on the given channels.
+   *
+   * @param channels - A key, name, list of keys, or list of names of the channels to
+   * stream values from.
+   * @throws a QueryError if any of the given channels do not exist.
+   * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
+   * a network socket will remain open.
+   */
+  async openStreamer(channels: Params): Promise<Streamer>;
+
+  /**
+   * Opens a new streamer with the provided configuration.
+   *
+   * @param config - Configuration parameters for the streamer.
+   * @param config.channels - The channels to stream values from. Can be a key, name,
+   * list of keys, or list of names.
+   * @param config.from - If this parameter is set and is before the current time,
+   * the streamer will first read and receive historical data from before this point
+   * and then will start reading new values.
+   *
+   */
+  async openStreamer(config: StreamerConfig): Promise<Streamer>;
+
+  async openStreamer(config: StreamerConfig | Params): Promise<Streamer> {
+    const isObject = typeof config === "object";
+    if (Array.isArray(config) || !isObject) config = { channels: config as Params };
+    return await Streamer._open(this.retriever, this.stream, config as StreamerConfig);
   }
 
   /**
    * Writes telemetry to the given channel starting at the given timestamp.
    *
-   * @param to - The key of the channel to write to.
+   * @param channel - The key of the channel to write to.
    * @param start - The starting timestamp of the first sample in data.
    * @param data  - The telemetry to write. This telemetry must have the same
    * data type as the channel.
    * @throws if the channel does not exist.
    */
-  async write(to: KeyOrName, start: CrudeTimeStamp, data: TypedArray): Promise<void> {
-    const w = await this.newWriter({
+  async write(
+    channel: KeyOrName,
+    start: CrudeTimeStamp,
+    data: CrudeSeries,
+  ): Promise<void> {
+    const w = await this.openWriter({
       start,
-      channels: to,
+      channels: channel,
       mode: WriterMode.PersistOnly,
     });
     try {
-      await w.write(to, data);
+      await w.write(channel, data);
       await w.commit();
     } finally {
       await w.close();
@@ -110,7 +123,7 @@ export class Client {
   }
 
   private async readFrame(tr: TimeRange, params: Params): Promise<Frame> {
-    const i = await this.newIterator(tr, params);
+    const i = await this.openIterator(tr, params);
     const frame = new Frame();
     try {
       for await (const f of i) frame.push(f);

package/src/framer/frame.spec.ts

@@ -400,4 +400,110 @@ describe("framer.Frame", () => {
       expect(f.latest()).toEqual({ 12: 3, 13: 3 });
     });
   });
+
+  describe("sample access", () => {
+    it("should return the sample at the given index", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      expect(f.get(12).at(0)).toEqual(1);
+    });
+  });
+
+  describe("at", () => {
+    it("should return the sample at the given index", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      expect(f.at(0)).toEqual({ 12: 1, 13: 1 });
+    });
+    it("should throw an error if required is true and the index is out of bounds", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      expect(() => f.at(3, true)).toThrow();
+    });
+    it("should return undefined if required is false and the index is out of bounds", () => {
+      const f = new framer.Frame(
+        new Map([
+          [
+            12,
+            [
+              new Series({
+                data: new Float32Array([1, 2, 3]),
+                timeRange: new TimeRange(40, 50000),
+              }),
+            ],
+          ],
+          [
+            13,
+            [
+              new Series({
+                data: new Float32Array([1, 2]),
+                timeRange: new TimeRange(500, 50001),
+              }),
+            ],
+          ],
+        ]),
+      );
+      expect(f.at(2)).toEqual({ 12: 3, 13: undefined });
+    });
+  });
 });

package/src/framer/frame.ts

@@ -16,6 +16,7 @@ import {
   unique,
   TimeStamp,
   type TelemValue,
+  MultiSeries,
 } from "@synnaxlabs/x";
 import { z } from "zod";
 
@@ -34,6 +35,7 @@ const columnType = (columns: Params): ColumnType => {
   const arrKeys = toArray(columns);
   if (arrKeys.length === 0) return null;
   if (typeof arrKeys[0] === "number") return "key";
+  if (!isNaN(parseInt(arrKeys[0]))) return "key";
   return "name";
 };
 
@@ -252,18 +254,11 @@ export class Frame {
     }
     const group = this.get(col);
     if (group == null) return TimeRange.ZERO;
-    return new TimeRange(
-      group[0].timeRange.start,
-      group[group.length - 1].timeRange.end,
-    );
+    return group.timeRange;
   }
 
-  latest(): Record<string, TelemValue> {
-    return Object.fromEntries(
-      this.columns
-        .map((c, i) => [c, this.series[i].at(-1)])
-        .filter(([_, v]) => v != null),
-    );
+  latest(): Record<string, TelemValue | undefined> {
+    return this.at(-1);
   }
 
   get timeRanges(): TimeRange[] {
@@ -274,7 +269,7 @@ export class Frame {
    * @returns lazy arrays matching the given channel key or name.
    * @param key the channel key or name.
    */
-  get(key: KeyOrName): Series[];
+  get(key: KeyOrName): MultiSeries;
 
   /**
    * @returns a frame with the given channel keys or names.
@@ -282,9 +277,9 @@ export class Frame {
    */
   get(keys: Keys | Names): Frame;
 
-  get(key: KeyOrName | Keys | Names): Series[] | Frame {
+  get(key: KeyOrName | Keys | Names): MultiSeries | Frame {
     if (Array.isArray(key)) return this.filter((k) => (key as Keys).includes(k as Key));
-    return this.series.filter((_, i) => this.columns[i] === key);
+    return new MultiSeries(this.series.filter((_, i) => this.columns[i] === key));
   }
 
   /**
@@ -364,6 +359,18 @@ export class Frame {
     });
   }
 
+  at(index: number, required: true): Record<KeyOrName, TelemValue>;
+
+  at(index: number, required?: false): Record<KeyOrName, TelemValue | undefined>;
+
+  at(index: number, required = false): Record<KeyOrName, TelemValue | undefined> {
+    const res: Record<KeyOrName, TelemValue> = {};
+    this.uniqueColumns.forEach((k) => {
+      res[k] = this.get(k).at(index, required as true);
+    });
+    return res;
+  }
+
   /**
    * @returns a new frame containing all typed arrays in the current frame that pass
    * the provided filter function.

package/src/framer/iterator.spec.ts

@@ -28,7 +28,7 @@ const newChannel = async (): Promise<channel.Channel> => {
 describe("Iterator", () => {
   test("happy path", async () => {
     const ch = await newChannel();
-    const writer = await client.telem.newWriter({
+    const writer = await client.telem.openWriter({
       start: TimeStamp.SECOND,
       channels: ch.key,
     });
@@ -42,7 +42,7 @@ describe("Iterator", () => {
       await writer.close();
     }
 
-    const iter = await client.telem.newIterator(
+    const iter = await client.telem.openIterator(
       new TimeRange(TimeSpan.ZERO, TimeSpan.seconds(4)),
       [ch.key],
     );
@@ -52,7 +52,7 @@ describe("Iterator", () => {
       let c = 0;
       while (await iter.next(TimeSpan.seconds(1))) {
         c++;
-        expect(iter.value.get(ch.key)[0]).toHaveLength(25);
+        expect(iter.value.get(ch.key)).toHaveLength(25);
       }
       expect(c).toEqual(3);
     } finally {