@synnaxlabs/client 0.1.0 → 0.1.2

package/build/module/lib/segment/iterator.js

@@ -0,0 +1,248 @@
+import { EOF, ErrorPayloadSchema, } from '@synnaxlabs/freighter';
+import { z } from 'zod';
+import { TimeRange } from '../telem';
+import { SegmentPayloadSchema } from './payload';
+import TypedSegment from './typed';
+var Command;
+(function (Command) {
+    Command[Command["Open"] = 0] = "Open";
+    Command[Command["Next"] = 1] = "Next";
+    Command[Command["Prev"] = 2] = "Prev";
+    Command[Command["First"] = 3] = "First";
+    Command[Command["Last"] = 4] = "Last";
+    Command[Command["NextSpan"] = 5] = "NextSpan";
+    Command[Command["PrevSpan"] = 6] = "PrevSpan";
+    Command[Command["NextRange"] = 7] = "NextRange";
+    Command[Command["Valid"] = 8] = "Valid";
+    Command[Command["Error"] = 9] = "Error";
+    Command[Command["SeekFirst"] = 10] = "SeekFirst";
+    Command[Command["SeekLast"] = 11] = "SeekLast";
+    Command[Command["SeekLT"] = 12] = "SeekLT";
+    Command[Command["SeekGE"] = 13] = "SeekGE";
+})(Command || (Command = {}));
+var ResponseVariant;
+(function (ResponseVariant) {
+    ResponseVariant[ResponseVariant["None"] = 0] = "None";
+    ResponseVariant[ResponseVariant["Ack"] = 1] = "Ack";
+    ResponseVariant[ResponseVariant["Data"] = 2] = "Data";
+})(ResponseVariant || (ResponseVariant = {}));
+const RequestSchema = z.object({
+    command: z.nativeEnum(Command),
+    span: z.number().optional(),
+    range: z.instanceof(TimeRange).optional(),
+    stamp: z.number().optional(),
+    keys: z.string().array().optional(),
+});
+const ResponseSchema = z.object({
+    variant: z.nativeEnum(ResponseVariant),
+    ack: z.boolean(),
+    command: z.nativeEnum(Command),
+    error: ErrorPayloadSchema.optional(),
+    segments: SegmentPayloadSchema.array().nullable(),
+});
+/**
+ * Used to iterate over a clusters telemetry in time-order. It should not be
+ * instantiated directly, and should instead be instantiated via the SegmentClient.
+ *
+ * Using an iterator is ideal when querying/processing large ranges of data, but
+ * is relatively complex and difficult to use. If you're looking to retrieve
+ *  telemetry between two timestamps, see the SegmentClient.read method.
+ */
+export class CoreIterator {
+    static ENDPOINT = '/segment/iterate';
+    client;
+    stream;
+    aggregate = false;
+    values = [];
+    constructor(client, aggregate = false) {
+        this.client = client;
+        this.aggregate = aggregate;
+    }
+    /**
+     * Opens the iterator, configuring it to iterate over the telemetry in the
+     * channels with the given keys within the provided time range.
+     *
+     * @param tr - The time range to iterate over.
+     * @param keys - The keys of the channels to iterate over.
+     */
+    async open(tr, keys) {
+        this.stream = await this.client.stream(CoreIterator.ENDPOINT, RequestSchema, 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        ResponseSchema);
+        await this.execute({ command: Command.Open, keys, range: tr });
+        this.values = [];
+    }
+    /**
+     * Reads the next segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    async next() {
+        return this.execute({ command: Command.Next });
+    }
+    /**
+     * Reads the previous segment for each channel in the iterator.
+     *
+     * @returns false if the next segment can't be found for one or more channels or
+     * the iterator has accumulated an error.
+     */
+    async prev() {
+        return this.execute({ command: Command.Prev });
+    }
+    /**
+     * Seeks to the beginning of the time range and reads the first segment of each
+     * channel in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel
+     * or the iterator has accumulated an error.
+     */
+    async first() {
+        return this.execute({ command: Command.First });
+    }
+    /**
+     * Seeks to the end of the time range and reads the last segment of each channel
+     * in the iterator.
+     *
+     * @returns false if no segments exists in the time range for a particular channel,
+     * or the iterator has accumulated an error.
+     */
+    async last() {
+        return this.execute({ command: Command.Last });
+    }
+    /**
+     * Reads the next time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a
+     * particular channel or the iterator has accumulated an error.
+     */
+    async nextSpan(span) {
+        return this.execute({ command: Command.NextSpan, span });
+    }
+    /**
+     * Reads the previous time span of telemetry for each channel in the iterator.
+     *
+     * @returns false if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    async prevSpan(span) {
+        return this.execute({ command: Command.PrevSpan, span });
+    }
+    /**
+     * Seeks the iterator to the start of the time range and reads the telemetry within
+     * the range for each channel.
+     *
+     * @returns: False if a segment satisfying the request can't be found for a particular
+     * channel or the iterator has accumulated an error.
+     */
+    async nextRange(range) {
+        return this.execute({ command: Command.NextRange, range });
+    }
+    /**
+     * Seeks the iterator to the first segment in the time range, but does not read
+     * it. Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    async seekFirst() {
+        return this.execute({ command: Command.SeekFirst });
+    }
+    /** Seeks the iterator to the last segment in the time range, but does not read it.
+     * Also invalidates the iterator. The iterator will not be considered valid
+     * until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    async seekLast() {
+        return this.execute({ command: Command.SeekLast });
+    }
+    /**
+     * Seeks the iterator to the first segment whose start is less than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    async seekLT(stamp) {
+        return this.execute({ command: Command.SeekLT, stamp });
+    }
+    /**
+     * Seeks the iterator to the first segment whose start is greater than or equal to
+     * the provided timestamp. Also invalidates the iterator. The iterator will not be
+     * considered valid until a call to first, last, next, prev, prev_span, next_span, or next_range.
+     *
+     * @returns false if the iterator is not pointing to a valid segment for a particular
+     * channel or has accumulated an error.
+     */
+    async seekGE(stamp) {
+        return this.execute({ command: Command.SeekGE, stamp });
+    }
+    /**
+     * @returns true if the iterator value contains a valid segment, and fale otherwise.
+     * valid most commonly returns false when the iterator is exhausted or has
+     * accumulated an error.
+     */
+    async valid() {
+        return this.execute({ command: Command.Valid });
+    }
+    /**
+     * Closes the iterator. An iterator MUST be closed after use, and this method
+     * should probably be placed in a 'finally' block. If the iterator is not closed,
+     * it may leak resources.
+     */
+    async close() {
+        if (!this.stream)
+            throw new Error('iterator.open() must be called before any other method');
+        this.stream.closeSend();
+        const [, exc] = await this.stream.receive();
+        if (!(exc instanceof EOF))
+            throw exc;
+    }
+    async execute(request) {
+        if (!this.stream)
+            throw new Error('iterator.open() must be called before any other method');
+        const err = this.stream.send(request);
+        if (err)
+            throw err;
+        if (!this.aggregate)
+            this.values = [];
+        for (;;) {
+            const [res, err] = await this.stream.receive();
+            if (err || !res)
+                throw err;
+            if (res.variant == ResponseVariant.Ack)
+                return res.ack;
+            if (res.segments)
+                this.values.push(...res.segments);
+        }
+    }
+}
+export class TypedIterator extends CoreIterator {
+    channels;
+    constructor(client, channels, aggregate = false) {
+        super(client, aggregate);
+        this.channels = channels;
+    }
+    async value() {
+        const result = {};
+        this.values.sort((a, b) => a.start.valueOf() - b.start.valueOf());
+        const keys = this.values.map((v) => v.channelKey);
+        const channels = await this.channels.getN(...keys);
+        this.values.forEach((v) => {
+            const sugared = new TypedSegment(channels.find((c) => c.key == v.channelKey), v);
+            if (v.channelKey in result) {
+                result[v.channelKey].extend(sugared);
+            }
+            else {
+                result[v.channelKey] = sugared;
+            }
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/iterator.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/module/lib/segment/iterator.spec.js

@@ -0,0 +1,57 @@
+import test from 'ava';
+import Synnax from '../client';
+import { DataType, Rate, TimeRange, TimeSpan } from '../telem';
+import { randomTypedArray } from '../util/telem';
+const client = new Synnax({ host: 'localhost', port: 8080 });
+const newChannel = async () => {
+    return await client.channel.create({
+        name: 'test',
+        nodeId: 1,
+        rate: Rate.Hz(25),
+        dataType: DataType.Float64,
+    });
+};
+test('TypedIterator - basic iteration', async (t) => {
+    const ch = await newChannel();
+    const writer = await client.data.newWriter([ch.key]);
+    const data = randomTypedArray(25, ch.dataType);
+    try {
+        await writer.write(ch.key, TimeSpan.Second, data);
+        await writer.write(ch.key, TimeSpan.Seconds(2), data);
+        await writer.write(ch.key, TimeSpan.Seconds(3), data);
+    }
+    finally {
+        await writer.close();
+    }
+    const iterator = await client.data.newIterator(new TimeRange(TimeSpan.Zero, TimeSpan.Seconds(4)), [ch.key], false);
+    try {
+        t.true(await iterator.first());
+        t.true((await iterator.value())[ch.key].view.length === 25);
+        let c = 1;
+        while (await iterator.next()) {
+            c++;
+            t.true((await iterator.value())[ch.key].view.length === 25);
+        }
+        t.true(c === 3);
+    }
+    finally {
+        await iterator.close();
+    }
+});
+test('Client - basic read', async (t) => {
+    const ch = await newChannel();
+    const writer = await client.data.newWriter([ch.key]);
+    const data = randomTypedArray(25, ch.dataType);
+    try {
+        await writer.write(ch.key, TimeSpan.Second, data);
+        await writer.write(ch.key, TimeSpan.Seconds(2), data);
+        await writer.write(ch.key, TimeSpan.Seconds(3), data);
+    }
+    finally {
+        await writer.close();
+    }
+    const resData = await client.data.read(ch.key, TimeSpan.Zero, TimeSpan.Seconds(4));
+    resData.slice(0, 25).forEach((v, i) => t.true(v === data[i]));
+    t.true(resData.length === 75);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/payload.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { TimeStamp } from '../telem';
+export declare const SegmentPayloadSchema: z.ZodObject<{
+    channelKey: z.ZodString;
+    start: z.ZodEffects<z.ZodNumber, TimeStamp, number>;
+    data: z.ZodEffects<z.ZodString, Uint8Array, string>;
+}, "strip", z.ZodTypeAny, {
+    data: Uint8Array;
+    channelKey: string;
+    start: TimeStamp;
+}, {
+    data: string;
+    channelKey: string;
+    start: number;
+}>;
+export declare type SegmentPayload = z.infer<typeof SegmentPayloadSchema>;

package/build/module/lib/segment/payload.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { TimeStamp } from '../telem';
+export const SegmentPayloadSchema = z.object({
+    channelKey: z.string(),
+    start: z.number().transform((n) => new TimeStamp(n)),
+    data: z.string().transform((s) => new Uint8Array(atob(s)
+        .split('')
+        .map((c) => c.charCodeAt(0)))),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF5bG9hZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvc2VnbWVudC9wYXlsb2FkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUVyQyxNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDO0lBQzNDLFVBQVUsRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFO0lBQ3RCLEtBQUssRUFBRSxDQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNwRCxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLFNBQVMsQ0FDeEIsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUNKLElBQUksVUFBVSxDQUNaLElBQUksQ0FBQyxDQUFDLENBQUM7U0FDSixLQUFLLENBQUMsRUFBRSxDQUFDO1NBQ1QsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQy9CLENBQ0o7Q0FDRixDQUFDLENBQUMifQ==

package/build/module/lib/segment/splitter.d.ts

@@ -0,0 +1,7 @@
+import { Size } from '../telem';
+import TypedSegment from './typed';
+export default class Splitter {
+    threshold: Size;
+    constructor(threshold: Size);
+    split(segment: TypedSegment): TypedSegment[];
+}

package/build/module/lib/segment/splitter.js

@@ -0,0 +1,26 @@
+import { ValidationError } from '../errors';
+import TypedSegment from './typed';
+export default class Splitter {
+    threshold;
+    constructor(threshold) {
+        this.threshold = threshold;
+    }
+    split(segment) {
+        if (segment.size.smallerThan(this.threshold))
+            return [segment];
+        if (!segment.channel.density)
+            throw new ValidationError('Cannot split segment because channel density is undefined');
+        const splitPoint = this.threshold.valueOf() -
+            (this.threshold.valueOf() % segment.channel.density.valueOf());
+        const truncated = new TypedSegment(segment.channel, {
+            ...segment.payload,
+            data: segment.payload.data.slice(0, splitPoint),
+        });
+        const next = new TypedSegment(segment.channel, {
+            ...segment.payload,
+            data: segment.payload.data.slice(splitPoint),
+        });
+        return [truncated, ...this.split(next)];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BsaXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlZ21lbnQvc3BsaXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUc1QyxPQUFPLFlBQVksTUFBTSxTQUFTLENBQUM7QUFFbkMsTUFBTSxDQUFDLE9BQU8sT0FBTyxRQUFRO0lBQzNCLFNBQVMsQ0FBTztJQUVoQixZQUFZLFNBQWU7UUFDekIsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7SUFDN0IsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFxQjtRQUN6QixJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUM7WUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDL0QsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsT0FBTztZQUMxQixNQUFNLElBQUksZUFBZSxDQUN2QiwyREFBMkQsQ0FDNUQsQ0FBQztRQUNKLE1BQU0sVUFBVSxHQUNkLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFO1lBQ3hCLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQUFDO1FBQ2pFLE1BQU0sU0FBUyxHQUFHLElBQUksWUFBWSxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUU7WUFDbEQsR0FBRyxPQUFPLENBQUMsT0FBTztZQUNsQixJQUFJLEVBQUUsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxVQUFVLENBQUM7U0FDaEQsQ0FBQyxDQUFDO1FBQ0gsTUFBTSxJQUFJLEdBQUcsSUFBSSxZQUFZLENBQUMsT0FBTyxDQUFDLE9BQU8sRUFBRTtZQUM3QyxHQUFHLE9BQU8sQ0FBQyxPQUFPO1lBQ2xCLElBQUksRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDO1NBQzdDLENBQUMsQ0FBQztRQUNILE9BQU8sQ0FBQyxTQUFTLEVBQUUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7SUFDMUMsQ0FBQztDQUNGIn0=

package/build/module/lib/segment/typed.d.ts

@@ -0,0 +1,15 @@
+import { ChannelPayload } from '../channel/payload';
+import { Size, TimeRange, TimeSpan, TimeStamp, TypedArray } from '../telem';
+import { SegmentPayload } from './payload';
+export default class TypedSegment {
+    payload: SegmentPayload;
+    channel: ChannelPayload;
+    view: TypedArray;
+    constructor(channel: ChannelPayload, payload: SegmentPayload);
+    get start(): TimeStamp;
+    get span(): TimeSpan;
+    get range(): TimeRange;
+    get end(): TimeStamp;
+    get size(): Size;
+    extend(other: TypedSegment): void;
+}

package/build/module/lib/segment/typed.js

@@ -0,0 +1,49 @@
+import { ValidationError } from '../errors';
+import { Size, } from '../telem';
+export default class TypedSegment {
+    payload;
+    channel;
+    view;
+    constructor(channel, payload) {
+        this.channel = channel;
+        this.payload = payload;
+        this.view = new this.channel.dataType.arrayConstructor(this.payload.data.buffer);
+    }
+    get start() {
+        return this.payload.start;
+    }
+    get span() {
+        return this.channel.rate.byteSpan(this.view.byteLength, this.channel.density);
+    }
+    get range() {
+        return this.start.spanRange(this.span);
+    }
+    get end() {
+        return this.range.end;
+    }
+    get size() {
+        return Size.Bytes(this.view.byteLength);
+    }
+    extend(other) {
+        if (other.channel.key !== this.channel.key) {
+            throw new ValidationError(`
+        Cannot extend segment because channel keys mismatch.
+        Segment Channel Key: ${this.channel.key}
+        Other Segment Channel Key: ${other.channel.key}
+      `);
+        }
+        if (!this.end.equals(other.start)) {
+            throw new Error(`
+      Cannot extend segment because segments are not contiguous.
+      Segment End: ${this.end}
+      Other Segment Start: ${other.start}
+      `);
+        }
+        const newData = new Uint8Array(this.view.byteLength + other.view.byteLength);
+        newData.set(this.payload.data, 0);
+        newData.set(other.payload.data, this.view.byteLength);
+        this.payload.data = newData;
+        this.view = new this.channel.dataType.arrayConstructor(this.payload.data.buffer);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/validator.d.ts

@@ -0,0 +1,22 @@
+import { DataType, TimeStamp, TypedArray } from '../telem';
+import TypedSegment from './typed';
+export declare class ScalarTypeValidator {
+    validate(array: TypedArray, dataType: DataType): void;
+}
+export declare type ContiguityValidatorProps = {
+    allowNoHighWaterMark: boolean;
+    allowOverlap: boolean;
+    allowGaps: boolean;
+};
+export declare class ContiguityValidator {
+    highWaterMarks: Map<string, TimeStamp>;
+    allowNoHighWaterMark: boolean;
+    allowOverlap: boolean;
+    allowGaps: boolean;
+    constructor(props: ContiguityValidatorProps);
+    validate(segment: TypedSegment): void;
+    private enforceNoOverlap;
+    private enforceNoGaps;
+    private getHighWaterMark;
+    private updateHighWaterMark;
+}

package/build/module/lib/segment/validator.js

@@ -0,0 +1,60 @@
+import { ContiguityError, UnexpectedError, ValidationError } from '../errors';
+export class ScalarTypeValidator {
+    validate(array, dataType) {
+        if (!dataType.checkArray(array)) {
+            throw new ValidationError({
+                field: 'data',
+                message: `Data type mismatch. Expected ${dataType} but got ${array.constructor.name}`,
+            });
+        }
+    }
+}
+export class ContiguityValidator {
+    highWaterMarks;
+    allowNoHighWaterMark = false;
+    allowOverlap = false;
+    allowGaps = false;
+    constructor(props) {
+        this.highWaterMarks = new Map();
+        this.allowNoHighWaterMark = props.allowNoHighWaterMark;
+        this.allowOverlap = props.allowOverlap;
+        this.allowGaps = props.allowGaps;
+    }
+    validate(segment) {
+        if (!segment.channel.key) {
+            throw new UnexpectedError('Channel key is not set');
+        }
+        const hwm = this.getHighWaterMark(segment.channel.key);
+        if (hwm) {
+            this.enforceNoOverlap(hwm, segment);
+            this.enforceNoGaps(hwm, segment);
+        }
+        this.updateHighWaterMark(segment);
+    }
+    enforceNoOverlap(hwm, seg) {
+        if (!this.allowOverlap && seg.start.before(hwm)) {
+            throw new ContiguityError(`Segment overlaps with previous segment. Previous segment ends at ${hwm.toString()}
+        Segment starts at ${seg.start.toString()}`);
+        }
+    }
+    enforceNoGaps(hwm, seg) {
+        if (!this.allowGaps && !seg.start.equals(hwm)) {
+            throw new ContiguityError(`Segment is not contiguous with previous segment. Previous segment ends at ${hwm.toString()}
+        Segment starts at ${seg.start.toString()}`);
+        }
+    }
+    getHighWaterMark(key) {
+        const hwm = this.highWaterMarks.get(key);
+        if (!hwm && !this.allowNoHighWaterMark) {
+            throw new UnexpectedError('No high water mark found for channel key ' + key);
+        }
+        return hwm;
+    }
+    updateHighWaterMark(seg) {
+        if (!seg.channel.key) {
+            throw new UnexpectedError('Channel key is not set');
+        }
+        this.highWaterMarks.set(seg.channel.key, seg.end);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/segment/writer.d.ts

@@ -0,0 +1,98 @@
+import { StreamClient } from '@synnaxlabs/freighter';
+import ChannelRegistry from '../channel/registry';
+import { TypedArray, UnparsedTimeStamp } from '../telem';
+import { SegmentPayload } from './payload';
+/**
+ * CoreWriter is used to write telemetry to a set of channels in time-order. It
+ * should not be instantiated directly, but rather through a {@link SegmentClient}.
+ *
+ * Using a writer is ideal when writing large volumes of data (such as recording
+ * telemetry from a sensor), but it is relatively complex and challenging to use.
+ * If you're looking to write a contiguous block of telemetry, see the {@link SegmentClient}
+ * write() method.
+ */
+export declare class CoreWriter {
+    private static ENDPOINT;
+    private client;
+    private stream;
+    private keys;
+    constructor(client: StreamClient);
+    /**
+     * Opens the writer, acquiring an exclusive lock on the given channels for
+     * the duration of the writer's lifetime. open must be called before any other
+     * writer methods.
+     *
+     * @param keys - A list of keys representing the channels the writer will write
+     * to.
+     */
+    open(keys: string[]): Promise<void>;
+    /**
+     * Validates and writes the given segments to the database. The provided segments
+     * must:
+     *
+     *   1. Be in time order (on a per-channel basis)
+     *   2. Have channel keys in the set of keys this writer was opened with.
+     *   3. Have non-zero length data with the correct data type.
+     *
+     * @param segments - A list of segments to write to the database.
+     * @returns false if the writer has accumulated an error. In this case,
+     * the caller should stop executing requests and close the writer.
+     */
+    write(segments: SegmentPayload[]): Promise<boolean>;
+    /**
+     * Closes the writer, raising any accumulated error encountered during operation.
+     * A writer MUST be closed after use, and this method should probably be placed
+     * in a 'finally' block. If the writer is not closed, the database will not release
+     * the exclusive lock on the channels, preventing any other callers from
+     * writing to them. It also might leak resources and threads.
+     */
+    close(): Promise<void>;
+    private checkKeys;
+}
+/**
+ * TypedWriter is used to write telemetry to a set of channels in time-order. It
+ * should not be instantiated directly, but rather through a {@link SegmentClient}.
+ *
+ * Using a writer is ideal when writing large volumes of data (such as recording
+ * telemetry from a sensor), but it is relatively complex and challenging to use.
+ * If you're looking to write a contiguous block of telemetry, see the {@link SegmentClient}
+ * write() method.
+ */
+export declare class TypedWriter {
+    private core;
+    private splitter;
+    private channels;
+    private scalarTypeValidator;
+    private contiguityValidator;
+    constructor(client: StreamClient, channels: ChannelRegistry);
+    /**
+     * Opens the writer, acquiring an exclusive lock on the given channels for
+     * the duration of the writer's lifetime. open must be called before any other
+     * writer methods.
+     *
+     * @param keys - A list of keys representing the channels the writer will write
+     * to.
+     */
+    open(keys: string[]): Promise<void>;
+    /**
+     * Writes the given telemetry to the database.
+     *
+     * @param to - They key of the channel to write to. This must be in the set of
+     * keys this writer was opened with.
+     * @param start - The start time of the telemetry. This must be equal to
+     * the end of the previous segment written to the channel (unless it's the first
+     * write to that channel).
+     * @param data - The telemetry to write. This must be a valid type for the channel.
+     * @returns false if the writer has accumulated an error. In this case,
+     * the caller should stop executing requests and close the writer.
+     */
+    write(to: string, start: UnparsedTimeStamp, data: TypedArray): Promise<boolean>;
+    /**
+     * Closes the writer, raising any accumulated error encountered during operation.
+     * A writer MUST be closed after use, and this method should probably be placed
+     * in a 'finally' block. If the writer is not closed, the database will not release
+     * the exclusive lock on the channels, preventing any other callers from
+     * writing to them. It also might leak resources and threads.
+     */
+    close(): Promise<void>;
+}