@synnaxlabs/client 0.46.1 → 0.48.0

package/src/framer/streamer.spec.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, Unreachable } from "@synnaxlabs/freighter";
+import { id, sleep } from "@synnaxlabs/x";
 import { DataType, Series, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, it, test, vi } from "vitest";
 
@@ -46,7 +47,12 @@ describe("Streamer", () => {
       await expect(client.openStreamer({ channels: ch.key })).resolves.not.toThrow();
     });
     it("should not throw an error when the streamer is opened with zero channels", async () => {
-      await expect(client.openStreamer([])).resolves.not.toThrow();
+      await expect(
+        (async () => {
+          const s = await client.openStreamer([]);
+          s.close();
+        })(),
+      ).resolves.not.toThrow();
     });
     it("should throw an error when the streamer is opened with a channel that does not exist", async () => {
       await expect(client.openStreamer([5678])).rejects.toThrow("not found");
@@ -120,12 +126,12 @@ describe("Streamer", () => {
         // Create source channels with the timestamp index
         const [channelA, channelB] = await client.channels.create([
           {
-            name: "test_a",
+            name: id.create(),
             dataType: DataType.FLOAT64,
             index: timeChannel.key,
           },
           {
-            name: "test_b",
+            name: id.create(),
             dataType: DataType.FLOAT64,
             index: timeChannel.key,
           },
@@ -135,14 +141,13 @@ describe("Streamer", () => {
         const calcChannel = await client.channels.create({
           name: "test_calc",
           dataType: DataType.FLOAT64,
-          index: timeChannel.key,
           virtual: true,
-          expression: "return test_a + test_b",
-          requires: [channelA.key, channelB.key],
+          expression: `return ${channelA.name} + ${channelB.name}`,
         });
 
         // Set up streamer to listen for calculated results
         const streamer = await client.openStreamer(calcChannel.key);
+        await sleep.sleep(TimeSpan.milliseconds(10));
 
         // Write test data
         const startTime = TimeStamp.now();
@@ -170,17 +175,18 @@ describe("Streamer", () => {
           streamer.close();
         }
       });
+
       test("calculated channel with constant", async () => {
         // Create an index channel for timestamps
         const timeChannel = await client.channels.create({
-          name: "calc_const_time",
+          name: id.create(),
           isIndex: true,
           dataType: DataType.TIMESTAMP,
         });
 
         // Create base channel with index
         const baseChannel = await client.channels.create({
-          name: "base_channel",
+          name: id.create(),
           dataType: DataType.FLOAT64,
           index: timeChannel.key,
         });
@@ -189,13 +195,12 @@ describe("Streamer", () => {
         const calcChannel = await client.channels.create({
           name: "calc_const_channel",
           dataType: DataType.FLOAT64,
-          index: timeChannel.key,
           virtual: true,
           expression: `return ${baseChannel.name} + 5`,
-          requires: [baseChannel.key],
         });
 
         const streamer = await client.openStreamer(calcChannel.key);
+        await sleep.sleep(TimeSpan.milliseconds(20));
 
         const startTime = TimeStamp.now();
         const writer = await client.openWriter({
@@ -242,13 +247,12 @@ describe("Streamer", () => {
         const calcChannel = await client.channels.create({
           name: "multi_calc",
           dataType: DataType.FLOAT64,
-          index: timeChannel.key,
           virtual: true,
           expression: "return (multi_test_a * 2) + (multi_test_b / 2)",
-          requires: [channelA.key, channelB.key],
         });
 
         const streamer = await client.openStreamer(calcChannel.key);
+        await sleep.sleep(TimeSpan.milliseconds(5));
 
         const startTime = TimeStamp.now();
         const writer = await client.openWriter({
@@ -271,6 +275,62 @@ describe("Streamer", () => {
           streamer.close();
         }
       });
+
+      describe("legacy calculations", async () => {
+        it("should correctly execute a calculation with a requires field", async () => {
+          const timeChannel = await client.channels.create({
+            name: "calc_test_time",
+            isIndex: true,
+            dataType: DataType.TIMESTAMP,
+          });
+
+          const [channelA, channelB] = await client.channels.create([
+            {
+              name: id.create(),
+              dataType: DataType.FLOAT64,
+              index: timeChannel.key,
+            },
+            {
+              name: id.create(),
+              dataType: DataType.FLOAT64,
+              index: timeChannel.key,
+            },
+          ]);
+
+          const calcChannel = await client.channels.create({
+            name: "test_calc",
+            dataType: DataType.FLOAT64,
+            virtual: true,
+            expression: `return ${channelA.name} + ${channelB.name}`,
+            requires: [channelA.key, channelB.key],
+          });
+
+          const streamer = await client.openStreamer(calcChannel.key);
+          await sleep.sleep(TimeSpan.milliseconds(10));
+
+          const startTime = TimeStamp.now();
+          const writer = await client.openWriter({
+            start: startTime,
+            channels: [timeChannel.key, channelA.key, channelB.key],
+          });
+
+          try {
+            await writer.write({
+              [timeChannel.key]: [startTime],
+              [channelA.key]: new Float64Array([2.5]),
+              [channelB.key]: new Float64Array([2.5]),
+            });
+
+            const frame = await streamer.read();
+
+            const calcData = Array.from(frame.get(calcChannel.key));
+            expect(calcData).toEqual([5.0]);
+          } finally {
+            await writer.close();
+            streamer.close();
+          }
+        });
+      });
     });
   });
 

package/src/framer/streamer.ts

@@ -34,8 +34,6 @@ const resZ = z.object({ frame: frameZ });
  */
 export interface StreamerResponse extends z.infer<typeof resZ> {}
 
-const ENDPOINT = "/frame/stream";
-
 const intermediateStreamerConfigZ = z.object({
   /** The channels to stream data from. Can be channel keys, names, or payloads. */
   channels: paramsZ,
@@ -106,9 +104,12 @@ export const createStreamOpener =
     const adapter = await ReadAdapter.open(retriever, cfg.channels);
     if (cfg.useHighPerformanceCodec)
       client = client.withCodec(new WSStreamerCodec(adapter.codec));
-    const stream = await client.stream(ENDPOINT, reqZ, resZ);
+    const stream = await client.stream("/frame/stream", reqZ, resZ);
     const streamer = new CoreStreamer(stream, adapter);
-    stream.send({ keys: adapter.keys, downsampleFactor: cfg.downsampleFactor ?? 1 });
+    stream.send({
+      keys: Array.from(adapter.keys),
+      downsampleFactor: cfg.downsampleFactor,
+    });
     const [, err] = await stream.receive();
     if (err != null) throw err;
     return streamer;
@@ -139,7 +140,7 @@ class CoreStreamer implements Streamer {
   }
 
   get keys(): channel.Key[] {
-    return this.adapter.keys;
+    return Array.from(this.adapter.keys);
   }
 
   async next(): Promise<IteratorResult<Frame, any>> {
@@ -160,7 +161,7 @@ class CoreStreamer implements Streamer {
     const hasChanged = await this.adapter.update(channels);
     if (!hasChanged) return;
     this.stream.send({
-      keys: this.adapter.keys,
+      keys: Array.from(this.adapter.keys),
       downsampleFactor: this.downsampleFactor,
     });
   }

package/src/framer/writer.spec.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 { DataType, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
+import { DataType, TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, it, test } from "vitest";
 
 import { UnauthorizedError, ValidationError } from "@/errors";
@@ -77,7 +77,6 @@ describe("Writer", () => {
       const writer = await client.openWriter({
         start: TimeStamp.seconds(1),
         channels,
-        enableAutoCommit: true,
       });
       const [index, data] = channels;
       try {
@@ -102,7 +101,6 @@ describe("Writer", () => {
       const writer = await client.openWriter({
         start: TimeStamp.seconds(1),
         channels,
-        enableAutoCommit: true,
         autoIndexPersistInterval: ALWAYS_INDEX_PERSIST_ON_AUTO_COMMIT,
       });
       const [index, data] = channels;
@@ -122,7 +120,6 @@ describe("Writer", () => {
       const writer = await client.openWriter({
         start: TimeStamp.seconds(1),
         channels,
-        enableAutoCommit: true,
         autoIndexPersistInterval: TimeSpan.milliseconds(100),
       });
       const [index, data] = channels;
@@ -169,7 +166,6 @@ describe("Writer", () => {
       const writer = await client.openWriter({
         start: TimeStamp.now(),
         channels: [indexCh.key, dataCh.key],
-        enableAutoCommit: true,
       });
 
       await expect(async () => {
@@ -210,13 +206,11 @@ describe("Writer", () => {
         start,
         channels,
         authorities: 10,
-        enableAutoCommit: true,
       });
       const w2 = await client.openWriter({
         start,
         channels,
         authorities: 20,
-        enableAutoCommit: true,
       });
       const [index, data] = channels;
       await w1.write({
@@ -244,13 +238,11 @@ describe("Writer", () => {
         start,
         channels,
         authorities: 10,
-        enableAutoCommit: true,
       });
       const w2 = await client.openWriter({
         start,
         channels,
         authorities: 20,
-        enableAutoCommit: true,
       });
       const [index, data] = channels;
       await w1.write({

package/src/framer/writer.ts

@@ -8,8 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { EOF, type Stream, type WebSocketClient } from "@synnaxlabs/freighter";
-import { control, errors } from "@synnaxlabs/x";
-import { type CrudeSeries, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
+import { control, type CrudeSeries, errors, TimeSpan, TimeStamp } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";
@@ -17,13 +16,7 @@ import { SynnaxError } from "@/errors";
 import { WriteAdapter } from "@/framer/adapter";
 import { WSWriterCodec } from "@/framer/codec";
 import { type CrudeFrame, frameZ } from "@/framer/frame";
-
-export enum WriterCommand {
-  Open = 0,
-  Write = 1,
-  Commit = 2,
-  SetAuthority = 3,
-}
+import { WriterCommand } from "@/framer/payload";
 
 export enum WriterMode {
   PersistStream = 1,
@@ -80,7 +73,7 @@ const baseWriterConfigZ = z.object({
    * If enableAutoCommit is true, then the writer will commit after each write, and
    * will flush that commit to index after the specified autoIndexPersistInterval.
    */
-  enableAutoCommit: z.boolean().default(false),
+  enableAutoCommit: z.boolean().default(true),
   /** autoIndexPersistInterval sets the interval at which commits will be flushed to
    * disk. */
   autoIndexPersistInterval: TimeSpan.z.default(TimeSpan.SECOND),
@@ -153,45 +146,46 @@ export type AuthorityArgs = z.input<typeof authorityArgsZ>;
 interface Response extends z.infer<typeof resZ> {}
 
 /**
- * Writer is used to write telemetry to a set of channels in time order.
- * It should not be instantiated directly, and should instead be instantiated via the
- * FramerClient {@link FrameClient#openWriter}.
+ * Writer is used to write telemetry to a set of channels in time order. 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 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.
+ * 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 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.
+ *    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 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.
+ *    rules described in its method's documentation. This process is asynchronous,
+ *    meaning that write calls may return before the 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 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 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.
+ * 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
+ *    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.
  *
  * 4. A writer MUST be closed after use in order to prevent resource leaks. Close should
- * typically be called in a 'finally' block. If the writer has accumulated an error,
- * close will throw the error.
+ *    typically be called in a 'finally' block. If the writer has accumulated an error,
+ *    close will throw the error.
  */
 export class Writer {
-  private static readonly ENDPOINT = "/frame/write";
   private readonly stream: Stream<typeof reqZ, typeof resZ>;
   private readonly adapter: WriteAdapter;
   private closeErr: Error | null = null;
@@ -210,7 +204,7 @@ export class Writer {
     const adapter = await WriteAdapter.open(retriever, cfg.channels);
     if (cfg.useHighPerformanceCodec)
       client = client.withCodec(new WSWriterCodec(adapter.codec));
-    const stream = await client.stream(Writer.ENDPOINT, reqZ, resZ);
+    const stream = await client.stream("/frame/write", reqZ, resZ);
     const writer = new Writer(stream, adapter);
     await writer.execute({
       command: WriterCommand.Open,

package/src/hardware/task/client.ts

@@ -8,8 +8,15 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, caseconv, id, type record, strings } from "@synnaxlabs/x";
-import { type CrudeTimeSpan, TimeSpan } from "@synnaxlabs/x/telem";
+import {
+  array,
+  caseconv,
+  type CrudeTimeSpan,
+  id,
+  type record,
+  strings,
+  TimeSpan,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type framer } from "@/framer";

package/src/index.ts

@@ -12,7 +12,14 @@ export { policy } from "@/access/policy";
 export { arc } from "@/arc";
 export { channel } from "@/channel";
 export { Channel, isCalculated } from "@/channel/client";
-export { default as Synnax, type SynnaxProps, synnaxPropsZ } from "@/client";
+export {
+  checkConnection,
+  type CheckConnectionParams,
+  newConnectionChecker,
+  default as Synnax,
+  type SynnaxParams,
+  synnaxParamsZ,
+} from "@/client";
 export * from "@/connection";
 export { control } from "@/control";
 export {
@@ -37,7 +44,7 @@ export { ontology } from "@/ontology";
 export { group } from "@/ontology/group";
 export { ranger } from "@/ranger";
 export { status } from "@/status";
-export { createTestClient, TEST_CLIENT_PROPS } from "@/testutil/client";
+export { createTestClient, TEST_CLIENT_PARAMS } from "@/testutil/client";
 export { user } from "@/user";
 export { workspace } from "@/workspace";
 export { lineplot } from "@/workspace/lineplot";
@@ -63,4 +70,4 @@ export {
   type TimeStampStringFormat,
   type TypedArray,
   type TZInfo,
-} from "@synnaxlabs/x/telem";
+} from "@synnaxlabs/x";

package/src/label/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x/array";
+import { array } from "@synnaxlabs/x";
 import z from "zod";
 
 import { type Key, keyZ, type Label, labelZ } from "@/label/payload";

package/src/ranger/alias.ts

@@ -8,8 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x";
-import { type change } from "@synnaxlabs/x/change";
+import { array, type change } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { channel } from "@/channel";

package/src/ranger/client.ts

@@ -8,8 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type CrudeTimeRange, TimeRange } from "@synnaxlabs/x";
-import { type Series } from "@synnaxlabs/x/telem";
+import { array, type CrudeTimeRange, type Series, TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type channel } from "@/channel";

package/src/ranger/kv.ts

@@ -8,8 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x/array";
-import { isObject } from "@synnaxlabs/x/identity";
+import { array, isObject } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type Key, keyZ } from "@/ranger/payload";

package/src/ranger/payload.ts

@@ -7,8 +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 { math } from "@synnaxlabs/x";
-import { TimeRange } from "@synnaxlabs/x/telem";
+import { math, TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { label } from "@/label";

package/src/ranger/ranger.spec.ts

@@ -7,8 +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 { math, uuid } from "@synnaxlabs/x";
-import { DataType, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
+import { DataType, math, TimeSpan, TimeStamp, uuid } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
 import { NotFoundError } from "@/errors";

package/src/status/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x/array";
+import { array } from "@synnaxlabs/x";
 import z from "zod";
 
 import { label } from "@/label";

package/src/status/payload.ts

@@ -17,7 +17,9 @@ export type Key = z.infer<typeof keyZ>;
 
 export type Params = Key | Key[];
 
-export const statusZ = status.statusZ;
+export const statusZ = <Details extends z.ZodType = z.ZodNever>(
+  detailsSchema?: Details,
+) => status.statusZ(detailsSchema);
 
 export const newZ = <DetailsSchema extends z.ZodType = z.ZodNever>(
   detailsSchema?: DetailsSchema,
@@ -27,7 +29,7 @@ export type New<DetailsSchema extends z.ZodType = z.ZodNever> = z.input<
   ReturnType<typeof newZ<DetailsSchema>>
 >;
 
-export type Status<Details = never> = status.Status<Details>;
+export type Status<Details extends z.ZodType = z.ZodNever> = status.Status<Details>;
 
 export const SET_CHANNEL_NAME = "sy_status_set";
 export const DELETE_CHANNEL_NAME = "sy_status_delete";

package/src/testutil/client.ts

@@ -9,9 +9,9 @@
 
 import { TimeSpan } from "@synnaxlabs/x";
 
-import Synnax, { type SynnaxProps } from "@/client";
+import Synnax, { type SynnaxParams } from "@/client";
 
-export const TEST_CLIENT_PROPS: SynnaxProps = {
+export const TEST_CLIENT_PARAMS: SynnaxParams = {
   host: "localhost",
   port: 9090,
   username: "synnax",
@@ -23,5 +23,5 @@ export const TEST_CLIENT_PROPS: SynnaxProps = {
   },
 };
 
-export const createTestClient = (props?: Partial<SynnaxProps>): Synnax =>
-  new Synnax({ ...TEST_CLIENT_PROPS, ...props });
+export const createTestClient = (params?: Partial<SynnaxParams>): Synnax =>
+  new Synnax({ ...TEST_CLIENT_PARAMS, ...params });

package/src/transport.ts

@@ -14,9 +14,7 @@ import {
   unaryWithBreaker,
   WebSocketClient,
 } from "@synnaxlabs/freighter";
-import { type breaker } from "@synnaxlabs/x";
-import { binary } from "@synnaxlabs/x/binary";
-import { type URL } from "@synnaxlabs/x/url";
+import { binary, type breaker, type URL } from "@synnaxlabs/x";
 
 const baseAPIEndpoint = "/api/v1/";
 

package/src/user/writer.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x/array";
+import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { type Key, keyZ, type New, newZ, type User, userZ } from "@/user/payload";

package/src/util/parseWithoutKeyConversion.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 record } from "@synnaxlabs/x/record";
+import { type record } from "@synnaxlabs/x";
 
 // --- VERY IMPORTANT ---
 // Synnax's encoders (in the binary package inside x) automatically convert the case of

package/src/util/telem.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 DataType, type TypedArray } from "@synnaxlabs/x/telem";
+import { type DataType, type TypedArray } from "@synnaxlabs/x";
 
 export const randomSeries = (length: number, dataType: DataType): TypedArray => {
   // create random bytes of the correct length

package/src/workspace/lineplot/payload.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 { record } from "@synnaxlabs/x/record";
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";

package/src/workspace/log/payload.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 { record } from "@synnaxlabs/x/record";
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";

package/src/workspace/payload.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 { record } from "@synnaxlabs/x/record";
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";

package/src/workspace/schematic/payload.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 { record } from "@synnaxlabs/x/record";
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";

package/src/workspace/table/payload.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 { record } from "@synnaxlabs/x/record";
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { parseWithoutKeyConversion } from "@/util/parseWithoutKeyConversion";

package/tsconfig.json

@@ -3,5 +3,5 @@
   "compilerOptions": {
     "baseUrl": "."
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*", "eslint.config.ts"]
 }