@synnaxlabs/client 0.56.2 → 0.57.1

package/src/log/actions.ts

@@ -0,0 +1,242 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { color } from "@synnaxlabs/x";
+
+import { actions } from "@/actions";
+import {
+  type Action,
+  addChannel,
+  createReduceAll,
+  type Handlers,
+  removeChannel,
+  rename,
+  setChannelAlias,
+  setChannelColor,
+  setChannelEntry,
+  setChannelNamesHidden,
+  setChannelNotation,
+  setChannelPrecision,
+  setChannels,
+  setChannelTimestampFormat,
+  setChannelTimestampTz,
+  setReceiptTimestampHidden,
+  setTimestampPrecision,
+  swapChannel,
+} from "@/log/actions.gen";
+import { channelEntryZ } from "@/log/types.gen";
+
+// Handlers report the narrowest resource each action touches as its target. Log-level
+// config (name, timestamp precision, display flags) targets the log key itself; channel
+// mutations target the specific channel so concurrent edits to distinct channels
+// neither coalesce nor invalidate each other's undoables.
+const handlers: Handlers = {
+  create: (state, payload) => {
+    Object.assign(state, payload.log);
+    return { inverse: [], targets: [payload.log.key] };
+  },
+
+  rename: (state, payload) => {
+    const oldName = state.name;
+    state.name = payload.name;
+    return { inverse: [rename({ name: oldName })], targets: [state.key] };
+  },
+
+  addChannel: (state, payload) => {
+    if (state.channels.some((e) => e.channel === payload.channel))
+      return actions.NO_OP_RESULT;
+    state.channels.push(
+      channelEntryZ.parse({ channel: payload.channel, color: color.ZERO }),
+    );
+    return {
+      inverse: [removeChannel({ channel: payload.channel })],
+      targets: [`channel:${payload.channel}`],
+    };
+  },
+
+  removeChannel: (state, payload) => {
+    const idx = state.channels.findIndex((e) => e.channel === payload.channel);
+    if (idx === -1) return actions.NO_OP_RESULT;
+    const oldEntry = actions.snapshotDraft(state.channels[idx]);
+    state.channels.splice(idx, 1);
+    return {
+      inverse: [
+        addChannel({ channel: payload.channel }),
+        setChannelEntry({ entry: oldEntry }),
+      ],
+      targets: [`channel:${payload.channel}`],
+    };
+  },
+
+  setChannelEntry: (state, payload) => {
+    const idx = state.channels.findIndex((e) => e.channel === payload.entry.channel);
+    if (idx === -1) {
+      state.channels.push(payload.entry);
+      return {
+        inverse: [removeChannel({ channel: payload.entry.channel })],
+        targets: [`channel:${payload.entry.channel}`],
+      };
+    }
+    const oldEntry = actions.snapshotDraft(state.channels[idx]);
+    state.channels[idx] = payload.entry;
+    return {
+      inverse: [setChannelEntry({ entry: oldEntry })],
+      targets: [`channel:${payload.entry.channel}`],
+    };
+  },
+
+  setChannelColor: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [
+      setChannelColor({
+        channel: payload.channel,
+        color: actions.snapshotDraft(entry.color),
+      }),
+    ];
+    entry.color = payload.color;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannelNotation: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [
+      setChannelNotation({ channel: payload.channel, notation: entry.notation }),
+    ];
+    entry.notation = payload.notation;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannelPrecision: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [
+      setChannelPrecision({ channel: payload.channel, precision: entry.precision }),
+    ];
+    entry.precision = payload.precision;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannelAlias: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [setChannelAlias({ channel: payload.channel, alias: entry.alias })];
+    entry.alias = payload.alias;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannelTimestampFormat: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [
+      setChannelTimestampFormat({
+        channel: payload.channel,
+        format: entry.timestamp.format,
+      }),
+    ];
+    entry.timestamp.format = payload.format;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannelTimestampTz: (state, payload) => {
+    const entry = state.channels.find((e) => e.channel === payload.channel);
+    if (entry == null) return actions.NO_OP_RESULT;
+    const inverse = [
+      setChannelTimestampTz({ channel: payload.channel, tz: entry.timestamp.tz }),
+    ];
+    entry.timestamp.tz = payload.tz;
+    return { inverse, targets: [`channel:${payload.channel}`] };
+  },
+
+  setChannels: (state, payload) => {
+    const oldChannels = actions.snapshotDraft(state.channels);
+    const targets = new Set<string>();
+    oldChannels.forEach((e) => targets.add(`channel:${e.channel}`));
+    payload.channels.forEach((e) => targets.add(`channel:${e.channel}`));
+    state.channels = payload.channels;
+    return { inverse: [setChannels({ channels: oldChannels })], targets: [...targets] };
+  },
+
+  swapChannel: (state, payload) => {
+    const idx = state.channels.findIndex((e) => e.channel === payload.from);
+    if (idx === -1) return actions.NO_OP_RESULT;
+    state.channels[idx].channel = payload.to;
+    return {
+      inverse: [swapChannel({ from: payload.to, to: payload.from })],
+      targets: [`channel:${payload.from}`, `channel:${payload.to}`],
+    };
+  },
+
+  setTimestampPrecision: (state, payload) => {
+    const oldPrecision = state.timestampPrecision;
+    state.timestampPrecision = payload.timestampPrecision;
+    return {
+      inverse: [setTimestampPrecision({ timestampPrecision: oldPrecision })],
+      targets: [state.key],
+    };
+  },
+
+  setChannelNamesHidden: (state, payload) => {
+    const oldValue = state.channelNamesHidden;
+    state.channelNamesHidden = payload.channelNamesHidden;
+    return {
+      inverse: [setChannelNamesHidden({ channelNamesHidden: oldValue })],
+      targets: [state.key],
+    };
+  },
+
+  setReceiptTimestampHidden: (state, payload) => {
+    const oldValue = state.receiptTimestampHidden;
+    state.receiptTimestampHidden = payload.receiptTimestampHidden;
+    return {
+      inverse: [setReceiptTimestampHidden({ receiptTimestampHidden: oldValue })],
+      targets: [state.key],
+    };
+  },
+};
+
+export const reduceAll = createReduceAll(handlers);
+
+// createOf hands the dispatch controller the document carried by a create
+// action so frames for never-cached documents ingest instead of drop.
+export const createOf = (action: Action) =>
+  action.type === "create" ? action.create.log : undefined;
+
+// kindOf keys single-channel edits by channel so rapid edits to one
+// channel's config coalesce into a single undoable, while edits to distinct
+// channels stay separate. Log-level edits (name, precision, flags) key by their
+// action type; multi-action batches collapse into one "transaction" undoable.
+export const kindOf = (actions: Action[]): string => {
+  if (actions.length === 0) return "default";
+  if (actions.length > 1) return "transaction";
+  const a = actions[0];
+  switch (a.type) {
+    case "add_channel":
+      return `channel:${a.addChannel.channel}`;
+    case "remove_channel":
+      return `channel:${a.removeChannel.channel}`;
+    case "set_channel_entry":
+      return `channel:${a.setChannelEntry.entry.channel}`;
+    case "set_channel_color":
+      return `channel:${a.setChannelColor.channel}`;
+    case "set_channel_notation":
+      return `channel:${a.setChannelNotation.channel}`;
+    case "set_channel_precision":
+      return `channel:${a.setChannelPrecision.channel}`;
+    case "set_channel_alias":
+      return `channel:${a.setChannelAlias.channel}`;
+    case "set_channel_timestamp_format":
+      return `channel:${a.setChannelTimestampFormat.channel}`;
+    case "set_channel_timestamp_tz":
+      return `channel:${a.setChannelTimestampTz.channel}`;
+    default:
+      return a.type;
+  }
+};

package/src/log/client.ts

@@ -8,88 +8,259 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { array, caseconv, record } from "@synnaxlabs/x";
+import { array, type destructor, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { type Key, keyZ, type Log, logZ, type New, newZ } from "@/log/types.gen";
-import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { workspace } from "@/workspace";
+import { actions } from "@/actions";
+import { createOf, kindOf, reduceAll } from "@/log/actions";
+import {
+  type Action,
+  dispatchReqZ,
+  rename as renameAction,
+  scopedActionZ,
+} from "@/log/actions.gen";
+import { type Key, keyZ, type Log, logZ, type New, ontologyID } from "@/log/types.gen";
+import { type ontology } from "@/ontology";
+import { project } from "@/project";
+import { query } from "@/query";
 
-const renameReqZ = z.object({ key: keyZ, name: z.string() });
+export const SET_CHANNEL_NAME = "sy_log_set";
+export const DELETE_CHANNEL_NAME = "sy_log_delete";
 
-const setDataReqZ = z.object({
-  key: keyZ,
-  data: caseconv.preserveCase(record.unknownZ()),
-});
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
-const retrieveReqZ = z.object({ keys: keyZ.array() });
-const singleRetrieveArgsZ = z
+const retrieveReqZ = z.object({
+  keys: keyZ.array(),
+  ignoreNotFoundError: z.boolean().optional(),
+});
+const retrieveMultiParamsZ = retrieveReqZ.or(query.keyListZ(keyZ));
+const singleRetrieveParamsZ = z
   .object({ key: keyZ })
   .transform(({ key }) => ({ keys: [key] }));
 
-export const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveReqZ]);
-export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
-export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export const retrieveParamsZ = z.union([singleRetrieveParamsZ, retrieveReqZ]);
+export type RetrieveParams = z.input<typeof retrieveParamsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveParamsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
 
-const retrieveResZ = z.object({ logs: array.nullishToEmpty(logZ) });
+interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
+
+const retrieveResZ = z.object({ logs: logZ.array().default(() => []) });
 
-const createReqZ = z.object({ workspace: workspace.keyZ, logs: newZ.array() });
+const createReqZ = z.object({ project: project.keyZ, logs: logZ.array() });
 const createResZ = z.object({ logs: logZ.array() });
 
 const emptyResZ = z.object({});
 
-export class Client {
-  private readonly client: UnaryClient;
+/**
+ * Client-side matching for a request: exact for the requested key set, the
+ * only field a request carries.
+ */
+const requestFilter = (req: RetrieveRequest): ((l: Log) => boolean) => {
+  const keySet = new Set(req.keys);
+  return (l) => keySet.has(l.key);
+};
+
+export interface ClientConfig {
+  unary: UnaryClient;
+  cache: query.Cache;
+  ontology: ontology.Client;
+}
 
-  constructor(client: UnaryClient) {
-    this.client = client;
+export class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Log> {
+  private readonly cfg: ClientConfig;
+  private readonly store: query.Table<Key, Log>;
+  private readonly dispatcher: actions.Controller<Key, Log, Action>;
+
+  constructor(cfg: ClientConfig) {
+    const { cache } = cfg;
+    // Dispatch mutates documents server-side, so fetched copies never clobber
+    // a doc holding locally replayed edits: the table hydrates if-absent.
+    const store = cache.createTable<Key, Log>({
+      name: "logs",
+      hydrate: "if-absent",
+      fetch: async (keys) =>
+        await this.execRetrieve({ keys, ignoreNotFoundError: true }),
+      listen: [query.createDeleteListener(DELETE_CHANNEL_NAME, keyZ)],
+    });
+    const dispatcher = new actions.Controller<Key, Log, Action>({
+      store,
+      onError: cache.onError,
+      reduce: reduceAll,
+      kindOf,
+      createOf,
+    });
+    cache.listen(dispatcher.listener(SET_CHANNEL_NAME, scopedActionZ));
+    super(cache, {
+      name: "log",
+      table: store,
+      request: {
+        schema: retrieveMultiParamsZ,
+        fetch: async (req) => await this.execRetrieve(req),
+        matches: (log, req) => requestFilter(req)(log),
+      },
+    });
+    this.cfg = cfg;
+    this.store = store;
+    this.dispatcher = dispatcher;
   }
 
-  async create(workspace: workspace.Key, log: New): Promise<Log>;
-  async create(workspace: workspace.Key, logs: New[]): Promise<Log[]>;
-  async create(workspace: workspace.Key, logs: New | New[]): Promise<Log | Log[]> {
+  async create(
+    project: project.Key,
+    log: New,
+    opts?: query.WriteOptions<Log[]>,
+  ): Promise<Log>;
+  async create(
+    project: project.Key,
+    logs: New[],
+    opts?: query.WriteOptions<Log[]>,
+  ): Promise<Log[]>;
+  async create(
+    project: project.Key,
+    logs: New | New[],
+    opts: query.WriteOptions<Log[]> = {},
+  ): Promise<Log | Log[]> {
     const isMany = Array.isArray(logs);
-    const res = await this.client.send(
-      "/log/create",
-      { workspace, logs: array.toArray(logs) },
-      createReqZ,
-      createResZ,
-    );
+    const optimistic = array
+      .toArray(logs)
+      .map((l) => zod.parse(logZ, l, { label: "log" }));
+    const res = await query.optimistic({
+      rollbacks: [this.store.set(optimistic)],
+      onOptimistic: () => opts.onOptimistic?.(optimistic),
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/log/create",
+          { project, logs: optimistic },
+          createReqZ,
+          createResZ,
+        ),
+    });
+    this.store.set(res.logs);
     return isMany ? res.logs : res.logs[0];
   }
 
-  async rename(key: Key, name: string): Promise<void> {
-    await this.client.send("/log/rename", { key, name }, renameReqZ, emptyResZ);
+  async rename(key: Key, name: string, opts: query.WriteOptions = {}): Promise<void> {
+    const rename = () => [
+      query.partialUpdate(this.store, key, { name }),
+      this.cfg.ontology.cache.renameResource(ontologyID(key), name),
+    ];
+    await query.optimistic({
+      rollbacks: rename(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () => await this.sendDispatch(key, "", [renameAction({ name })]),
+    });
+    rename();
   }
 
-  async setData(key: Key, data: record.Unknown): Promise<void> {
-    await this.client.send("/log/set-data", { key, data }, setDataReqZ, emptyResZ);
+  /**
+   * Applies actions to the cached log and sends them to the server, recording an
+   * undoable entry. Returns false without side effects when the log isn't cached. Rolls
+   * back the local apply and rethrows on send failure.
+   */
+  async dispatch(
+    key: Key,
+    actions: Action | Action[],
+    opts: actions.Options<Log, Action> = {},
+  ): Promise<boolean> {
+    return await this.dispatcher.dispatch(
+      key,
+      array.toArray(actions),
+      this.dispatchSender(key),
+      opts,
+    );
   }
 
-  async retrieve(args: RetrieveSingleParams): Promise<Log>;
-  async retrieve(args: RetrieveMultipleParams): Promise<Log[]>;
-  async retrieve(
-    args: RetrieveSingleParams | RetrieveMultipleParams,
-  ): Promise<Log | Log[]> {
-    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
-    const res = await this.client.send(
-      "/log/retrieve",
-      args,
-      retrieveArgsZ,
-      retrieveResZ,
-    );
-    checkForMultipleOrNoResults("Log", args, res.logs, isSingle);
-    return isSingle ? res.logs[0] : res.logs;
+  /**
+   * Reverts the log's most recent undoable entry. Returns false when
+   * nothing is undoable.
+   */
+  async undo(key: Key): Promise<boolean> {
+    return await this.dispatcher.undo(key, this.dispatchSender(key));
+  }
+
+  /**
+   * Re-applies the log's most recently undone entry. Returns false when
+   * nothing is redoable.
+   */
+  async redo(key: Key): Promise<boolean> {
+    return await this.dispatcher.redo(key, this.dispatchSender(key));
+  }
+
+  /** Whether the log has a live undo entry. */
+  hasUndo(key: Key): boolean {
+    return this.dispatcher.hasUndo(key);
   }
 
-  async delete(keys: Key | Key[]): Promise<void> {
-    await this.client.send(
-      "/log/delete",
-      { keys: array.toArray(keys) },
-      deleteReqZ,
+  /** Whether the log has a live redo entry. */
+  hasRedo(key: Key): boolean {
+    return this.dispatcher.hasRedo(key);
+  }
+
+  /**
+   * Subscribes to changes in the log's undo/redo stacks. Returns a
+   * destructor that unsubscribes.
+   */
+  onUndoStateChange(callback: () => void, key?: Key): destructor.Destructor {
+    return this.dispatcher.onUndoStateChange(callback, key);
+  }
+
+  /** Stages actions committed atomically as one undoable entry. */
+  beginTransaction(key: Key, kind?: string): actions.Transaction<Action> {
+    return this.dispatcher.transaction(key, this.dispatchSender(key), kind);
+  }
+
+  private dispatchSender(key: Key): actions.SendDispatch<Action> {
+    return async (actions, dispatchKey) =>
+      await this.sendDispatch(key, dispatchKey, actions);
+  }
+
+  private async sendDispatch(
+    key: Key,
+    dispatchKey: string,
+    actions: Action[],
+  ): Promise<void> {
+    await this.cfg.unary.send(
+      "/log/dispatch",
+      { key, dispatchKey, actions },
+      dispatchReqZ,
       emptyResZ,
     );
   }
+
+  async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
+    const keysArr = array.toArray(keys);
+    const drop = () => [
+      this.cfg.ontology.cache.deleteRelationships(ontologyID(keysArr)),
+      this.store.delete(keysArr),
+    ];
+    await query.optimistic({
+      rollbacks: drop(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/log/delete",
+          { keys: keysArr },
+          deleteReqZ,
+          emptyResZ,
+        ),
+    });
+    drop();
+  }
+
+  /** Subscribes to every log delete delivered to the cache. */
+  onDelete(handler: (key: Key) => void): destructor.Destructor {
+    return this.store.subscribe((event) => {
+      if (event.variant === "delete") handler(event.key);
+    });
+  }
+
+  private async execRetrieve(params: RetrieveMultipleParams): Promise<Log[]> {
+    const res = await this.cfg.unary.send(
+      "/log/retrieve",
+      params,
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.logs;
+  }
 }

package/src/log/external.ts

@@ -7,5 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+export * from "@/log/actions";
+export * from "@/log/actions.gen";
 export * from "@/log/client";
 export * from "@/log/types.gen";

package/src/log/types.gen.ts

@@ -9,34 +9,65 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { caseconv, record } from "@synnaxlabs/x";
+import { color, notation, telem, uuid } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { channel } from "@/channel";
 import { ontology } from "@/ontology";
 
+/** TimestampConfig is per-channel timestamp display configuration. */
+export const timestampConfigZ = z.object({
+  /** format controls how channel timestamps are rendered. */
+  format: telem.timestampFormatZ,
+  /** tz is the time zone used when rendering timestamps. */
+  tz: telem.timeZoneZ,
+});
+export interface TimestampConfig extends z.infer<typeof timestampConfigZ> {}
+
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
+/** ChannelEntry is a per-channel display configuration entry within a log. */
+export const channelEntryZ = z.object({
+  /** channel is the channel this entry references. */
+  channel: channel.keyZ,
+  /** color is the display color for the channel. */
+  color: color.colorZ,
+  /** notation is the numeric notation used to render samples. */
+  notation: notation.notationZ.default("standard"),
+  /**
+   * precision is the number of decimal digits to display. -1 means "use the log-level
+   * precision"; 17 is the maximum significant digits for a float64.
+   */
+  precision: z.int32().min(-1).max(17).default(-1),
+  /** alias is a human-readable alias displayed in place of the channel name. */
+  alias: z.string().default(""),
+  /** timestamp is the per-channel timestamp display configuration. */
+  timestamp: timestampConfigZ.prefault({ format: "preciseDate", tz: "local" }),
+});
+export interface ChannelEntry extends z.infer<typeof channelEntryZ> {}
+
 /**
- * Log is a timestamped event and message logging component. Logs display
- * chronological records of events, system messages, and audit trails with
- * filtering and formatting capabilities.
+ * Log is a timestamped event and message logging component. Logs display chronological
+ * records of events, system messages, and audit trails with filtering and formatting
+ * capabilities.
  */
 export const logZ = z.object({
   /** key is the unique identifier for this log. */
-  key: keyZ,
+  key: keyZ.default(uuid.create),
   /** name is a human-readable name for the log. */
-  name: z.string(),
-  /**
-   * data is the log configuration including message formatting, filtering
-   * rules, and display options.
-   */
-  data: caseconv.preserveCase(record.nullishToEmpty()),
+  name: z.string().min(1, "name is required"),
+  /** channels are the channels displayed in this log, in order. */
+  channels: channelEntryZ.array().default(() => []),
+  /** timestampPrecision is the precision of displayed timestamps (0-3). */
+  timestampPrecision: z.int32().min(0).max(3).default(0),
+  /** channelNamesHidden is true when channel names are hidden. */
+  channelNamesHidden: z.boolean().default(false),
+  /** receiptTimestampHidden is true when the receipt timestamp column is hidden. */
+  receiptTimestampHidden: z.boolean().default(false),
 });
 export interface Log extends z.infer<typeof logZ> {}
-
-export const newZ = logZ.partial({ key: true });
-export interface New extends z.input<typeof newZ> {}
+export interface New extends z.input<typeof logZ> {}
 
 export const ontologyID = ontology.createIDFactory<Key>("log");
 export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/modbus/external.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * from "@/modbus/types.gen";

package/src/modbus/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * as modbus from "@/modbus/external";