@synnaxlabs/client 0.56.2 → 0.57.0

package/src/device/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record, zod } from "@synnaxlabs/x";
+import { array, type destructor, primitive, type record, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import {
@@ -18,23 +18,27 @@ import {
   type Key,
   keyZ,
   type New,
-  newZ,
   ontologyID,
+  statusZ,
 } from "@/device/types.gen";
 import { ontology } from "@/ontology";
+import { query } from "@/query";
 import { keyZ as rackKeyZ } from "@/rack/types.gen";
+import { type status } from "@/status";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 export const SET_CHANNEL_NAME = "sy_device_set";
 export const DELETE_CHANNEL_NAME = "sy_device_delete";
 
+const genericDeviceZ = deviceZ();
+
 const createReqZ = <
   Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
   Make extends z.ZodType<string> = z.ZodString,
   Model extends z.ZodType<string> = z.ZodString,
 >(
   schemas?: DeviceSchemas<Properties, Make, Model>,
-) => z.object({ devices: zod.toArray(newZ(schemas)) });
+) => z.object({ devices: zod.toArray(deviceZ(schemas)) });
 
 const createResZ = <
   Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
@@ -60,6 +64,7 @@ const retrieveRequestZ = z.object({
   includeStatus: z.boolean().optional(),
   includeParent: z.boolean().optional(),
 });
+const retrieveMultiParamsZ = retrieveRequestZ.or(query.keyListZ(keyZ));
 
 const retrieveResZ = <
   Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
@@ -67,9 +72,14 @@ const retrieveResZ = <
   Model extends z.ZodType<string> = z.ZodString,
 >(
   schemas?: DeviceSchemas<Properties, Make, Model>,
-) => z.object({ devices: array.nullishToEmpty(deviceZ(schemas)) });
+) =>
+  z.object({
+    devices: deviceZ(schemas)
+      .array()
+      .default(() => []),
+  });
 
-const singleRetrieveArgsZ = z
+const singleRetrieveParamsZ = z
   .object({
     key: keyZ,
     includeStatus: z.boolean().optional(),
@@ -79,12 +89,16 @@ const singleRetrieveArgsZ = z
     includeStatus,
   }));
 
-export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveParamsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
-const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
+const retrieveParamsZ = z.union([singleRetrieveParamsZ, retrieveRequestZ]);
+
+export type RetrieveParams = z.input<typeof retrieveParamsZ>;
+
+interface RetrieveRequest extends z.infer<typeof retrieveRequestZ> {}
 
-export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
+type SingleQuery = { key: Key; includeStatus?: boolean };
 
 type RetrieveSchemas<
   Properties extends z.ZodType<record.Unknown>,
@@ -92,11 +106,136 @@ type RetrieveSchemas<
   Model extends z.ZodType<string>,
 > = { schemas: DeviceSchemas<Properties, Make, Model> };
 
-export class Client {
-  private readonly client: UnaryClient;
+/** Query fields only the server can evaluate. */
+const SERVER_FIELDS = ["searchTerm", "limit", "offset", "includeParent"] as const;
+
+/** Drops includeStatus when unset so equivalent queries hash identically. */
+const normalizeSingle = ({ key, includeStatus }: RetrieveSingleParams): SingleQuery =>
+  includeStatus === true ? { key, includeStatus: true } : { key };
+
+const singleQueryZ = z
+  .union([
+    z.strictObject({ key: keyZ, includeStatus: z.boolean().optional() }),
+    keyZ.transform((key) => ({ key })),
+  ])
+  .transform(normalizeSingle);
+
+/** The table never holds statuses; the status table is their single home. */
+const stripStatus = ({ status: _, ...device }: Device): Omit<Device, "status"> =>
+  device;
+
+/**
+ * Client-side matching for a request: key, name, make, model, location, and
+ * rack sets. Server-computed shapes (search, pagination, parent resolution)
+ * never reach this filter; they refetch instead.
+ */
+const requestFilter = (
+  req: RetrieveRequest,
+): ((d: Omit<Device, "status">) => boolean) => {
+  const keySet = primitive.isNonZero(req.keys) ? new Set(req.keys) : undefined;
+  const nameSet = primitive.isNonZero(req.names) ? new Set(req.names) : undefined;
+  const makeSet = primitive.isNonZero(req.makes) ? new Set(req.makes) : undefined;
+  const modelSet = primitive.isNonZero(req.models) ? new Set(req.models) : undefined;
+  const locationSet = primitive.isNonZero(req.locations)
+    ? new Set(req.locations)
+    : undefined;
+  const rackSet = primitive.isNonZero(req.racks) ? new Set(req.racks) : undefined;
+  return (d) => {
+    if (keySet != null && !keySet.has(d.key)) return false;
+    if (nameSet != null && !nameSet.has(d.name)) return false;
+    if (makeSet != null && !makeSet.has(d.make)) return false;
+    if (modelSet != null && !modelSet.has(d.model)) return false;
+    if (locationSet != null && !locationSet.has(d.location)) return false;
+    if (rackSet != null && !rackSet.has(d.rack)) return false;
+    return true;
+  };
+};
+
+// Device statuses live in the status table under the "device:<key>" status
+// key, carrying the device key in their details.
+const affectedDeviceKeys = (
+  event: query.TableEvent<status.Key, status.Status>,
+): Key[] | null => {
+  if (event.variant === "set") {
+    const parsed = statusZ.safeParse(event.value);
+    return parsed.success ? [parsed.data.details.device] : null;
+  }
+  const [type, key] = event.key.split(":");
+  if (type !== "device" || !primitive.isNonZero(key)) return null;
+  return [key];
+};
+
+export interface ClientConfig {
+  unary: UnaryClient;
+  cache: query.Cache;
+  statusStore: query.Table<status.Key, status.Status>;
+  ontology: ontology.Client;
+}
+
+export class Client extends query.Retriever<
+  typeof retrieveMultiParamsZ,
+  Key,
+  Omit<Device, "status">,
+  Device,
+  RetrieveSingleParams,
+  SingleQuery
+> {
+  private readonly cfg: ClientConfig;
+  private readonly store: query.Table<Key, Omit<Device, "status">>;
 
-  constructor(client: UnaryClient) {
-    this.client = client;
+  constructor(cfg: ClientConfig) {
+    const { cache, statusStore } = cfg;
+    // Explicitly omit 'status' from the device type to make sure we aren't
+    // storing two copies of the statuses in the store.
+    const store = cache.createTable<Key, Omit<Device, "status">>({
+      name: "devices",
+      fetch: async (keys) => await this.fetchThrough({ keys }),
+      listen: [
+        query.createSetListener(SET_CHANNEL_NAME, genericDeviceZ, {
+          value: ({ status: _, ...device }) => device,
+        }),
+        query.createDeleteListener(DELETE_CHANNEL_NAME, keyZ),
+      ],
+    });
+    // Composed rows always carry status; includeStatus only gates fetch flags.
+    const composed = cache.derive<Key, Omit<Device, "status">, Device>({
+      name: "device.composed",
+      source: store,
+      compose: (record) => this.compose(record, true),
+      watch: [query.deriveWatch(statusStore, (event) => affectedDeviceKeys(event))],
+    });
+    const single = cache.queries<SingleQuery, Device, Key, Device>({
+      name: "device",
+      table: composed,
+      fetch: async (q) => [(await this.fetchSingle(q)).key],
+      // The composed row always carries status; the query gates whether the
+      // answer keeps it, mirroring the request space.
+      compose: (records, q) =>
+        q.includeStatus === true ? records[0] : stripStatus(records[0]),
+      keyOf: (q) => q.key,
+      single: true,
+    });
+    super(cache, {
+      name: "device",
+      table: store,
+      request: {
+        schema: retrieveMultiParamsZ,
+        fetch: async (req) => (await this.fetchThrough(req)).map(stripStatus),
+        matches: (d, req) => requestFilter(req)(d),
+        serverFields: SERVER_FIELDS,
+        watch: [
+          query.watch(statusStore, (event, q: RetrieveRequest) => {
+            if (q.includeStatus !== true) return null;
+            return affectedDeviceKeys(event);
+          }),
+        ],
+      },
+      compose: (record, q) =>
+        this.compose(record, (q as { includeStatus?: boolean }).includeStatus === true),
+      single: { schema: singleQueryZ, space: single },
+    });
+    this.cfg = cfg;
+    this.store = store;
   }
 
   async retrieve<
@@ -104,34 +243,37 @@ export class Client {
     Make extends z.ZodType<string>,
     Model extends z.ZodType<string>,
   >(
-    args: RetrieveSingleParams & RetrieveSchemas<Properties, Make, Model>,
+    params: RetrieveSingleParams & RetrieveSchemas<Properties, Make, Model>,
   ): Promise<Device<Properties, Make, Model>>;
 
-  async retrieve(args: RetrieveSingleParams): Promise<Device>;
+  async retrieve(params: Key | RetrieveSingleParams): Promise<Device>;
 
   async retrieve<
     Properties extends z.ZodType<record.Unknown>,
     Make extends z.ZodType<string>,
     Model extends z.ZodType<string>,
   >(
-    args: RetrieveMultipleParams & RetrieveSchemas<Properties, Make, Model>,
+    params: RetrieveMultipleParams & RetrieveSchemas<Properties, Make, Model>,
   ): Promise<Array<Device<Properties, Make, Model>>>;
 
-  async retrieve(args: RetrieveMultipleParams): Promise<Array<Device>>;
+  async retrieve(params: RetrieveMultipleParams): Promise<Array<Device>>;
 
   async retrieve(
-    args: RetrieveArgs & { schemas?: DeviceSchemas },
+    rawParams: Key | (RetrieveParams & { schemas?: DeviceSchemas }),
   ): Promise<Device | Array<Device>> {
-    const { schemas, ...rest } = args;
-    const isSingle = typeof rest === "object" && "key" in rest;
-    const res = await this.client.send(
-      "/device/retrieve",
-      rest,
-      retrieveArgsZ,
-      retrieveResZ(schemas),
-    );
-    checkForMultipleOrNoResults("Device", rest, res.devices, isSingle);
-    return isSingle ? res.devices[0] : res.devices;
+    const params = typeof rawParams === "string" ? { key: rawParams } : rawParams;
+    const { schemas, ...rest } = params;
+    const isSingle = "key" in rest;
+    // Schemas are not hashable, so schema-typed retrieves bypass the query
+    // cache and hit the network, still writing records through.
+    if (schemas != null) {
+      const devices = await this.execRetrieve(rest, schemas);
+      checkForMultipleOrNoResults("Device", rest, devices, isSingle);
+      this.writeThrough(devices);
+      return isSingle ? devices[0] : devices;
+    }
+    if (isSingle) return await super.retrieve(rest);
+    return await super.retrieve(rest);
   }
 
   async create(device: New): Promise<Device>;
@@ -145,9 +287,14 @@ export class Client {
   >(
     device: New<Properties, Make, Model>,
     schemas: DeviceSchemas<Properties, Make, Model>,
+    opts?: query.WriteOptions,
   ): Promise<Device<Properties, Make, Model>>;
 
-  async create(device: New, schemas?: DeviceSchemas): Promise<Device>;
+  async create(
+    device: New,
+    schemas?: DeviceSchemas,
+    opts?: query.WriteOptions,
+  ): Promise<Device>;
 
   async create<
     Properties extends z.ZodType<record.Unknown>,
@@ -156,31 +303,136 @@ export class Client {
   >(
     devices: New<Properties, Make, Model>[],
     schemas: DeviceSchemas<Properties, Make, Model>,
+    opts?: query.WriteOptions,
   ): Promise<Device<Properties, Make, Model>[]>;
 
-  async create(devices: New[], schemas?: DeviceSchemas): Promise<Device[]>;
+  async create(
+    devices: New[],
+    schemas?: DeviceSchemas,
+    opts?: query.WriteOptions,
+  ): Promise<Device[]>;
 
   async create(
     devices: New | New[],
     schemas?: DeviceSchemas,
+    opts: query.WriteOptions = {},
   ): Promise<Device | Device[]> {
     const isSingle = !Array.isArray(devices);
-    const res = await this.client.send(
-      "/device/create",
-      { devices: array.toArray(devices) },
-      createReqZ(schemas),
-      createResZ(schemas),
-    );
+    // Filling the schema defaults up front hands the cache the same records the request
+    // carries. It is the schema createReqZ already applies.
+    const normalized = array
+      .toArray(devices)
+      .map((device) => deviceZ(schemas).parse(device) as Device);
+    const apply = () => [this.store.set(normalized.map(stripStatus))];
+    const res = await query.optimistic({
+      rollbacks: apply(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/device/create",
+          { devices: normalized },
+          createReqZ(schemas),
+          createResZ(schemas),
+        ),
+    });
+    this.store.set(res.devices.map(stripStatus));
     return isSingle ? res.devices[0] : res.devices;
   }
 
-  async delete(keys: Key | Key[]): Promise<void> {
-    await this.client.send(
-      "/device/delete",
-      { keys: array.toArray(keys) },
-      deleteReqZ,
-      deleteResZ,
+  async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
+    const keysArr = array.toArray(keys);
+    const drop = () => [
+      this.cfg.ontology.cache.deleteResources(ontologyID(keysArr)),
+      this.store.delete(keysArr),
+    ];
+    await query.optimistic({
+      rollbacks: drop(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/device/delete",
+          { keys: keysArr },
+          deleteReqZ,
+          deleteResZ,
+        ),
+    });
+    drop();
+  }
+
+  async rename(key: Key, name: string, opts: query.WriteOptions = {}): Promise<void> {
+    const dev = await this.retrieve(key);
+    const renamed = { ...dev, name };
+    await query.optimistic({
+      rollbacks: [this.store.set(renamed.key, stripStatus(renamed))],
+      onOptimistic: opts.onOptimistic,
+      commit: async () => {
+        await this.create(renamed);
+      },
+    });
+  }
+
+  /** Subscribes to every device set delivered to the cache. Statuses excluded. */
+  onSet(handler: (device: Omit<Device, "status">) => void): destructor.Destructor {
+    return this.store.subscribe((event) => {
+      if (event.variant === "set") handler(event.value);
+    });
+  }
+
+  /** Subscribes to every device delete delivered to the cache. */
+  onDelete(handler: (key: Key) => void): destructor.Destructor {
+    return this.store.subscribe((event) => {
+      if (event.variant === "delete") handler(event.key);
+    });
+  }
+
+  /** Rebuilds a cached device, attaching its cached status when requested. */
+  private compose(cached: Omit<Device, "status">, includeStatus: boolean): Device {
+    if (!includeStatus) return cached;
+    const st = this.cfg.statusStore.get(statusKey(cached.key));
+    if (st == null) return cached;
+    const parsed = statusZ.safeParse(st);
+    if (!parsed.success) return cached;
+    return { ...cached, status: parsed.data };
+  }
+
+  /** Writes fetched devices and their included statuses. */
+  private writeThrough(devices: Device[]): void {
+    this.store.set(devices.map(stripStatus));
+    devices.forEach(({ status: st }) => {
+      if (st != null) this.cfg.statusStore.set(st);
+    });
+  }
+
+  private async execRetrieve(
+    params: RetrieveParams,
+    schemas?: DeviceSchemas,
+  ): Promise<Device[]> {
+    const res = await this.cfg.unary.send(
+      "/device/retrieve",
+      params,
+      retrieveParamsZ,
+      retrieveResZ(schemas),
     );
+    return res.devices;
+  }
+
+  /** Fetches devices and writes their included statuses through the caches. */
+  private async fetchThrough(req: RetrieveRequest): Promise<Device[]> {
+    const devices = await this.execRetrieve(req);
+    this.writeThrough(devices);
+    return devices;
+  }
+
+  private async fetchSingle(q: SingleQuery): Promise<Device> {
+    // A status-bearing hit needs both the record and its status cached.
+    if (q.includeStatus !== true) {
+      const cached = this.store.get(q.key);
+      if (cached != null) return cached;
+    }
+    const devices = await this.execRetrieve(q);
+    checkForMultipleOrNoResults("Device", q, devices, true);
+    this.writeThrough(devices);
+    return devices[0];
   }
 }
 

package/src/device/types.gen.ts

@@ -9,16 +9,20 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { type optional, record, status } from "@synnaxlabs/x";
+import { type optional, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
 import { rack } from "@/rack";
+import { status } from "@/status";
 
 export const keyZ = z.string();
 export type Key = z.infer<typeof keyZ>;
 
-/** StatusDetails contains device-specific status details identifying the device and its associated rack. */
+/**
+ * StatusDetails contains device-specific status details identifying the device and its
+ * associated rack.
+ */
 export const statusDetailsZ = z.object({
   /** rack is the key of the rack this device belongs to. */
   rack: rack.keyZ,
@@ -47,13 +51,13 @@ export const deviceZ = <
 >({ properties, make, model }: Partial<DeviceSchemas<Properties, Make, Model>> = {}) =>
   z.object({
     key: keyZ,
-    rack: rack.keyZ,
-    location: z.string().min(1, "Location is required"),
-    make: make ?? z.string().min(1, "Make is required"),
-    model: model ?? z.string().min(1, "Model is required"),
-    name: z.string().min(1, "Name is required"),
+    rack: rack.keyZ.refine((v) => v !== 0, "rack is required"),
+    location: z.string().min(1, "location is required"),
+    make: make ?? z.string().min(1, "make is required"),
+    model: model ?? z.string().min(1, "model is required"),
+    name: z.string().min(1, "name is required"),
     configured: z.boolean().default(false),
-    properties: properties ?? record.nullishToEmpty(),
+    properties: properties ?? record.unknownZ().default(() => ({})),
     status: statusZ.optional(),
     parent: ontology.idZ.optional(),
   });
@@ -73,28 +77,13 @@ export interface Device<
   status?: Status;
   parent?: ontology.ID;
 }
-
-export interface NewSchemas<
-  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
-  Make extends z.ZodType<string> = z.ZodType<string>,
-  Model extends z.ZodType<string> = z.ZodType<string>,
-> {
-  properties: Properties;
-  make: Make;
-  model: Model;
-}
-
-export const newZ = <
-  Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
-  Make extends z.ZodType<string> = z.ZodString,
-  Model extends z.ZodType<string> = z.ZodString,
->({ properties, make, model }: Partial<NewSchemas<Properties, Make, Model>> = {}) =>
-  deviceZ({ properties, make, model }).partial({ key: true, configured: true });
 export type New<
   Properties extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
   Make extends z.ZodType<string> = z.ZodString,
   Model extends z.ZodType<string> = z.ZodString,
-> = optional.Optional<Device<Properties, Make, Model>, "key" | "configured">;
+> = optional.Optional<Omit<Device<Properties, Make, Model>, "status">, "configured"> & {
+  status?: status.New<typeof statusDetailsZ>;
+};
 
 export const ontologyID = ontology.createIDFactory<Key>("device");
 export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/errors.ts

@@ -13,9 +13,7 @@ import { z } from "zod";
 
 export class SynnaxError extends errors.createTyped("sy") {}
 
-/**
- * Raised when a validation error occurs.
- */
+/** Raised when a validation error occurs. */
 export class ValidationError extends SynnaxError.sub("validation") {}
 
 export class PathError extends ValidationError.sub("path") {
@@ -37,25 +35,39 @@ export class PathError extends ValidationError.sub("path") {
     const decoded = PathError.encodedSchema.parse(JSON.parse(payload.data));
     return new PathError(decoded.path, errors.decode(decoded.error) as Error);
   }
+
+  static matchExact(e: unknown): e is PathError {
+    return (
+      e != null &&
+      typeof e === "object" &&
+      "path" in e &&
+      "error" in e &&
+      "type" in e &&
+      typeof e.type === "string" &&
+      e.type === PathError.TYPE
+    );
+  }
 }
 
-/**
- * AuthError is raised when an authentication error occurs.
- */
+/** AuthError is raised when an authentication error occurs. */
 export class AuthError extends SynnaxError.sub("auth") {}
 
-/**
- * InvalidTokenError is raised when an authentication token is invalid.
- */
+/** InvalidTokenError is raised when an authentication token is invalid. */
 export class InvalidTokenError extends AuthError.sub("invalid_token") {}
 
 export class ExpiredTokenError extends AuthError.sub("expired_token") {}
 
-export class AccessDeniedError extends AuthError.sub("access_denied") {}
+/** Raised when the caller's policies do not permit the action. */
+export class AccessDeniedError extends AuthError.sub("access_denied") {
+  toStatus() {
+    return {
+      message: "You do not have permission to do that",
+      description: this.message,
+    };
+  }
+}
 
-/**
- * UnexpectedError is raised when an unexpected error occurs.
- */
+/** UnexpectedError is raised when an unexpected error occurs. */
 export class UnexpectedError extends SynnaxError.sub("unexpected") {
   constructor(message: string) {
     super(`
@@ -68,18 +80,14 @@ export class UnexpectedError extends SynnaxError.sub("unexpected") {
   }
 }
 
-/**
- * QueryError is raised when a query error occurs.
- */
+/** QueryError is raised when a query error occurs. */
 export class QueryError extends SynnaxError.sub("query") {}
 
 export class NotFoundError extends QueryError.sub("not_found") {}
 
 export class MultipleFoundError extends QueryError.sub("multiple_results") {}
 
-/**
- * RouteError is raised when a routing error occurs.
- */
+/** RouteError is raised when a routing error occurs. */
 export class RouteError extends SynnaxError.sub("route") {
   path: string;
 
@@ -100,8 +108,13 @@ export class DisconnectedError extends SynnaxError.sub("disconnected") {
 }
 
 /**
- * Raised when time-series data is not contiguous.
+ * Whether the error means the Core could not be reached: a request that failed on
+ * the wire, or one short-circuited while the connection is known unreachable.
  */
+export const isConnectionError = (err: unknown): boolean =>
+  Unreachable.matches(err) || DisconnectedError.matches(err);
+
+/** Raised when time-series data is not contiguous. */
 export class ContiguityError extends SynnaxError.sub("contiguity") {}
 
 const decode = (payload: errors.Payload): Error | null => {
@@ -116,6 +129,8 @@ const decode = (payload: errors.Payload): Error | null => {
       return new InvalidTokenError(payload.data);
     if (payload.type.startsWith(ExpiredTokenError.TYPE))
       return new ExpiredTokenError(payload.data);
+    if (payload.type.startsWith(AccessDeniedError.TYPE))
+      return new AccessDeniedError(payload.data);
     return new AuthError(payload.data);
   }
 
@@ -142,8 +157,16 @@ const decode = (payload: errors.Payload): Error | null => {
   return new UnexpectedError(payload.data);
 };
 
-const encode = (): errors.Payload => {
-  throw new errors.NotImplemented();
+const encode: errors.Encoder = (error) => {
+  if (!error.type.startsWith(SynnaxError.TYPE)) return null;
+  if (PathError.matchExact(error)) {
+    const { path, error: cause } = error;
+    return {
+      type: PathError.TYPE,
+      data: JSON.stringify({ path, error: errors.encode(cause) }),
+    };
+  }
+  return { type: error.type, data: error.message };
 };
 
 errors.register({ encode, decode });

package/src/{workspace → ethercat}/external.ts

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

package/src/{workspace → ethercat}/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as workspace from "@/workspace/external";
+export * as ethercat from "@/ethercat/external";