@synnaxlabs/client 0.53.1 → 0.54.0

package/src/ranger/client.ts

@@ -21,20 +21,18 @@ import { type channel } from "@/channel";
 import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { label } from "@/label";
-import { ontology } from "@/ontology";
-import { Client as AliasClient } from "@/ranger/alias/client";
-import { Client as KVClient } from "@/ranger/kv/client";
+import { type ontology } from "@/ontology";
+import { type Client as AliasClient } from "@/ranger/alias/client";
+import { type Client as KVClient } from "@/ranger/kv/client";
+import { type Name, type Params } from "@/ranger/payload";
 import {
   type Key,
-  type Keys,
   keyZ,
-  type Name,
-  type Names,
   type New,
-  type Params,
+  ontologyID,
   type Payload,
   payloadZ,
-} from "@/ranger/payload";
+} from "@/ranger/types.gen";
 import { type CreateOptions, type Writer } from "@/ranger/writer";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
@@ -56,8 +54,8 @@ export class Range {
   name: string;
   readonly kv: KVClient;
   readonly timeRange: TimeRange;
-  readonly color: color.Color | undefined;
-  readonly parent: Payload | null;
+  readonly color?: color.Color;
+  readonly parent?: Payload;
   readonly labels?: label.Label[];
   readonly channels: channel.Retriever;
   private readonly aliaser: AliasClient;
@@ -67,7 +65,7 @@ export class Range {
   private readonly rangeClient: Client;
 
   constructor(
-    { name, timeRange = TimeRange.ZERO, key, color, parent, labels }: Payload,
+    { name, timeRange = TimeRange.ZERO, key, color: color_, parent, labels }: Payload,
     {
       frameClient,
       kv,
@@ -84,7 +82,7 @@ export class Range {
     this.parent = parent;
     this.labels = labels;
     this.frameClient = frameClient;
-    this.color = color;
+    this.color = color_;
     this.kv = kv;
     this.aliaser = aliaser;
     this.channels = channels;
@@ -98,18 +96,17 @@ export class Range {
   }
 
   get payload(): Payload {
-    let parent: Payload | null = null;
-    if (this.parent != null)
-      if ("payload" in this.parent) parent = (this.parent as Range).payload;
-      else parent = this.parent;
-    return {
+    const r: Payload = {
       key: this.key,
       name: this.name,
       timeRange: this.timeRange,
       color: this.color,
       labels: this.labels,
-      parent,
     };
+    if (this.parent != null)
+      if ("payload" in this.parent) r.parent = (this.parent as Range).payload;
+      else r.parent = this.parent;
+    return r;
   }
 
   async setAlias(channel: channel.Key | Name, alias: string): Promise<void> {
@@ -195,7 +192,7 @@ const retrieveArgsZ = retrieveRequestZ
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
-const retrieveResZ = z.object({ ranges: array.nullableZ(payloadZ) });
+const retrieveResZ = z.object({ ranges: array.nullishToEmpty(payloadZ) });
 
 export class Client {
   readonly type: string = "range";
@@ -205,6 +202,8 @@ export class Client {
   private readonly channels: channel.Retriever;
   private readonly labelClient: label.Client;
   private readonly ontologyClient: ontology.Client;
+  private readonly createAliasClient: (key: Key) => AliasClient;
+  private readonly createKVClient: (key: Key) => KVClient;
 
   constructor(
     frameClient: framer.Client,
@@ -213,6 +212,8 @@ export class Client {
     channels: channel.Retriever,
     labelClient: label.Client,
     ontologyClient: ontology.Client,
+    createAliasClient: (key: Key) => AliasClient,
+    createKVClient: (key: Key) => KVClient,
   ) {
     this.frameClient = frameClient;
     this.writer = writer;
@@ -220,6 +221,8 @@ export class Client {
     this.channels = channels;
     this.labelClient = labelClient;
     this.ontologyClient = ontologyClient;
+    this.createAliasClient = createAliasClient;
+    this.createKVClient = createKVClient;
   }
 
   async create(range: New, options?: CreateOptions): Promise<Range>;
@@ -236,12 +239,12 @@ export class Client {
     await this.writer.rename(key, name);
   }
 
-  async delete(key: Key | Keys): Promise<void> {
+  async delete(key: Key | Key[]): Promise<void> {
     await this.writer.delete(array.toArray(key));
   }
 
   async retrieve(params: Key | Name): Promise<Range>;
-  async retrieve(params: Keys | Names): Promise<Range[]>;
+  async retrieve(params: Key[] | Name[]): Promise<Range[]>;
   async retrieve(params: CrudeTimeRange): Promise<Range[]>;
   async retrieve(params: RetrieveRequest): Promise<Range[]>;
   async retrieve(params: RetrieveArgs): Promise<Range | Range[]> {
@@ -259,7 +262,7 @@ export class Client {
   }
 
   getKV(range: Key): KVClient {
-    return new KVClient(range, this.unaryClient);
+    return this.createKVClient(range);
   }
 
   async retrieveParent(range: Key): Promise<Range | null> {
@@ -275,7 +278,7 @@ export class Client {
   }
 
   async retrieveAlias(range: Key, channel: channel.Key): Promise<string> {
-    const aliaser = new AliasClient(range, this.unaryClient);
+    const aliaser = this.createAliasClient(range);
     return await aliaser.retrieve(channel);
   }
 
@@ -283,30 +286,26 @@ export class Client {
     range: Key,
     channels: channel.Key[],
   ): Promise<Record<channel.Key, string>> {
-    const aliaser = new AliasClient(range, this.unaryClient);
-    return await aliaser.retrieve(channels);
+    return await this.createAliasClient(range).retrieve(channels);
   }
 
   async listAliases(range: Key): Promise<Record<channel.Key, string>> {
-    const aliaser = new AliasClient(range, this.unaryClient);
-    return await aliaser.list();
+    return await this.createAliasClient(range).list();
   }
 
   async setAlias(range: Key, channel: channel.Key, alias: string): Promise<void> {
-    const aliaser = new AliasClient(range, this.unaryClient);
-    await aliaser.set({ [channel]: alias });
+    await this.createAliasClient(range).set({ [channel]: alias });
   }
 
   async deleteAlias(range: Key, channels: channel.Key | channel.Key[]): Promise<void> {
-    const aliaser = new AliasClient(range, this.unaryClient);
-    await aliaser.delete(channels);
+    await this.createAliasClient(range).delete(channels);
   }
 
   sugarOne(payload: Payload): Range {
     return new Range(payload, {
       frameClient: this.frameClient,
-      kv: new KVClient(payload.key, this.unaryClient),
-      aliaser: new AliasClient(payload.key, this.unaryClient),
+      kv: this.createKVClient(payload.key),
+      aliaser: this.createAliasClient(payload.key),
       channels: this.channels,
       labelClient: this.labelClient,
       ontologyClient: this.ontologyClient,
@@ -319,20 +318,10 @@ export class Client {
   }
 
   resourceToRange(resource: ontology.Resource): Range {
-    return this.sugarOne({
-      key: resource.id.key,
-      name: resource.data?.name as string,
-      timeRange: new TimeRange(resource.data?.timeRange as CrudeTimeRange),
-      color: resource.data?.color as color.Color,
-      labels: [],
-      parent: null,
-    });
+    return this.sugarOne(convertOntologyResourceToPayload(resource));
   }
 }
 
-export const ontologyID = ontology.createIDFactory<Key>("range");
-export const TYPE_ONTOLOGY_ID = ontologyID("");
-
 export const aliasOntologyID = (key: Key): ontology.ID => ({
   type: "range-alias",
   key,
@@ -351,6 +340,6 @@ export const convertOntologyResourceToPayload = ({
     timeRange,
     color: c.success ? c.data : undefined,
     labels: [],
-    parent: null,
+    parent: undefined,
   };
 };

package/src/ranger/external.ts

@@ -7,6 +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 "@/ranger/alias";
 export * from "@/ranger/alias";
 export {
   /** @deprecated Use {@link alias.createKey} instead. */
@@ -20,17 +21,16 @@ export {
 } from "@/ranger/alias/payload";
 export * from "@/ranger/client";
 export * from "@/ranger/kv";
+export * from "@/ranger/kv";
 export {
   /** @deprecated Use {@link kv.DELETE_CHANNEL_NAME} instead. */
   DELETE_CHANNEL_NAME as KV_DELETE_CHANNEL,
   /** @deprecated Use {@link kv.SET_CHANNEL_NAME} instead. */
   SET_CHANNEL_NAME as KV_SET_CHANNEL,
   /** @deprecated Use {@link kv.Pair} instead. */
-  type Pair as KVPair,
   /** @deprecated Use {@link kv.createPairKey} instead. */
   createPairKey as kvPairKey,
-  /** @deprecated Use {@link kv.pairZ} instead. */
-  pairZ as kvPairZ,
 } from "@/ranger/kv/payload";
 export * from "@/ranger/payload";
+export * from "@/ranger/types.gen";
 export * from "@/ranger/writer";

package/src/ranger/kv/client.ts

@@ -11,11 +11,11 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { type Pair, pairZ } from "@/ranger/kv/payload";
-import { type Key, keyZ } from "@/ranger/payload";
+import { type Pair, pairZ } from "@/ranger/kv/types.gen";
+import { type Key, keyZ } from "@/ranger/types.gen";
 
 const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
-const getResZ = z.object({ pairs: array.nullableZ(pairZ) });
+const getResZ = z.object({ pairs: array.nullishToEmpty(pairZ) });
 const setReqZ = z.object({ range: keyZ, pairs: pairZ.array() });
 const deleteReqZ = z.object({ range: keyZ, keys: z.string().array() });
 

package/src/ranger/kv/external.ts

@@ -7,10 +7,6 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export {
-  createPairKey,
-  DELETE_CHANNEL_NAME as DELETE_CHANNEL,
-  type Pair,
-  pairZ,
-  SET_CHANNEL_NAME as SET_CHANNEL,
-} from "@/ranger/kv/payload";
+export * from "@/ranger/kv/client";
+export * from "@/ranger/kv/payload";
+export * from "@/ranger/kv/types.gen";

package/src/ranger/kv/payload.ts

@@ -7,16 +7,11 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z } from "zod";
-
-import { keyZ } from "@/ranger/payload";
+import { type Pair, pairZ } from "@/ranger/kv/types.gen";
 
 export const SET_CHANNEL_NAME = "sy_range_kv_set";
 export const DELETE_CHANNEL_NAME = "sy_range_kv_delete";
 
-export const pairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
-export interface Pair extends z.infer<typeof pairZ> {}
-
 export const createPairKey = ({ range, key }: Omit<Pair, "value">) =>
   `${range}<--->${key}`;
 

package/src/ranger/kv/types.gen.ts

@@ -0,0 +1,28 @@
+// 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.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { z } from "zod";
+
+import { keyZ } from "@/ranger/types.gen";
+
+/**
+ * Pair is a key-value metadata pair associated with a specific range, enabling
+ * arbitrary metadata storage on time ranges.
+ */
+export const pairZ = z.object({
+  /** range is the unique identifier of the range owning this key-value pair. */
+  range: keyZ,
+  /** key is the metadata key name. */
+  key: z.string(),
+  /** value is the metadata value stored as a string for flexibility. */
+  value: z.string(),
+});
+export interface Pair extends z.infer<typeof pairZ> {}

package/src/ranger/payload.ts

@@ -7,54 +7,10 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { color, math, TimeRange } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { label } from "@/label";
+import { type Key } from "@/ranger/types.gen";
 
-export const keyZ = z.uuid();
-export type Key = z.infer<typeof keyZ>;
 export const nameZ = z.string().min(1);
 export type Name = z.infer<typeof nameZ>;
-export type Keys = Key[];
-export type Names = Name[];
-export type Params = Key | Name | Keys | Names;
-
-export const payloadZ = z.object({
-  key: keyZ,
-  name: nameZ,
-  timeRange: TimeRange.z
-    .refine(({ isValid }) => isValid, {
-      error: "Time range start time must be before or equal to time range end time",
-    })
-    .refine(({ end }) => end.valueOf() <= math.MAX_INT64, {
-      error:
-        "Time range end time must be less than or equal to the maximum value of an int64",
-    })
-    .refine(({ start }) => start.valueOf() >= math.MIN_INT64, {
-      error:
-        "Time range start time must be greater than or equal to the minimum value of an int64",
-    }),
-  color: color.colorZ.optional(),
-  labels: label.labelZ
-    .array()
-    .or(z.null().transform(() => undefined))
-    .optional(),
-  get parent(): z.ZodUnion<readonly [z.ZodNull, typeof payloadZ]> {
-    // Using as unknown is bad, but unfortunately resolving the output type of this
-    // transform is nearly impossible.
-    return payloadZ
-      .optional()
-      .nullable()
-      .transform((p) => (p === undefined ? null : p)) as unknown as z.ZodUnion<
-      readonly [z.ZodNull, typeof payloadZ]
-    >;
-  },
-});
-
-export type Payload = z.infer<typeof payloadZ>;
-
-export const newZ = payloadZ
-  .omit({ parent: true, labels: true })
-  .partial({ key: true });
-export interface New extends z.input<typeof newZ> {}
+export type Params = Key | Name | Key[] | Name[];

package/src/ranger/ranger.spec.ts

@@ -16,7 +16,7 @@ import { createTestClient } from "@/testutil/client";
 
 const client = createTestClient();
 
-describe("Ranger", () => {
+describe("range", () => {
   describe("payload", () => {
     it("should validate the time range", () => {
       const payload = ranger.payloadZ.parse({
@@ -215,9 +215,7 @@ describe("Ranger", () => {
       const val = await rng.kv.get("foo");
       expect(val).toEqual("bar");
       await rng.kv.delete("foo");
-      await expect(async () => await rng.kv.get("foo")).rejects.toThrowError(
-        NotFoundError,
-      );
+      await expect(async () => await rng.kv.get("foo")).rejects.toThrow(NotFoundError);
     });
 
     it("should set and get multiple keys", async () => {

package/src/ranger/types.gen.ts

@@ -0,0 +1,66 @@
+// 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.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { color, label, telem, zod } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { ontology } from "@/ontology";
+
+export const keyZ = z.uuid();
+export type Key = z.infer<typeof keyZ>;
+
+/**
+ * Base is a user-defined region of time in the Synnax cluster. Ranges act as a
+ * method for labeling and categorizing telemetry data within specific time
+ * periods.
+ */
+export const baseZ = z.object({
+  /** key is the unique identifier for this range. */
+  key: keyZ,
+  /** name is a human-readable name for the range. */
+  name: z.string().min(1),
+  /**
+   * timeRange is the temporal extent of the range, defining its start and end
+   * timestamps.
+   */
+  timeRange: telem.timeRangeZ,
+  /**
+   * color is an optional display color for visual identification of the range
+   * in user interfaces.
+   */
+  color: color.colorZ.optional(),
+});
+export interface Base extends z.infer<typeof baseZ> {}
+
+export const apiRangeZ = baseZ.extend({
+  labels: zod.nullToUndefined(label.labelZ.array()),
+  get parent(): z.ZodOptional<typeof apiRangeZ> {
+    return apiRangeZ.optional();
+  },
+});
+export interface APIRange extends z.infer<typeof apiRangeZ> {}
+
+export const payloadZ = baseZ.omit({ timeRange: true }).extend({
+  labels: zod.nullToUndefined(label.labelZ.array()),
+  get parent(): z.ZodOptional<typeof payloadZ> {
+    return payloadZ.optional();
+  },
+  timeRange: telem.timeRangeBoundedZ,
+});
+export interface Payload extends z.infer<typeof payloadZ> {}
+
+export const newZ = payloadZ
+  .omit({ parent: true, labels: true })
+  .partial({ key: true });
+export interface New extends z.input<typeof newZ> {}
+
+export const ontologyID = ontology.createIDFactory<Key>("range");
+export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/ranger/writer.ts

@@ -11,7 +11,8 @@ import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { z } from "zod";
 
 import { ontology } from "@/ontology";
-import { keyZ, nameZ, type New, newZ, type Payload, payloadZ } from "@/ranger/payload";
+import { nameZ } from "@/ranger/payload";
+import { keyZ, type New, newZ, type Payload, payloadZ } from "@/ranger/types.gen";
 
 const createResZ = z.object({ ranges: payloadZ.array() });
 

package/src/schematic/client.ts

@@ -8,27 +8,27 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array, type record } from "@synnaxlabs/x";
+import { array, caseconv, record } from "@synnaxlabs/x";
 import { z } from "zod";
 
-import { ontology } from "@/ontology";
+import { symbol } from "@/schematic/symbol";
 import {
   type Key,
   keyZ,
   type New,
   newZ,
-  type Params,
-  remoteZ,
   type Schematic,
   schematicZ,
-} from "@/schematic/payload";
-import { symbol } from "@/schematic/symbol";
+} from "@/schematic/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { workspace } from "@/workspace";
 
 const renameReqZ = z.object({ key: keyZ, name: z.string() });
 
-const setDataReqZ = z.object({ key: keyZ, data: z.string() });
+const setDataReqZ = z.object({
+  key: keyZ,
+  data: caseconv.preserveCase(record.unknownZ()),
+});
 const deleteReqZ = z.object({ keys: keyZ.array() });
 
 const copyReqZ = z.object({
@@ -48,13 +48,13 @@ export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveReqZ>;
 export type CopyArgs = z.input<typeof copyReqZ>;
 
-const retrieveResZ = z.object({ schematics: array.nullableZ(remoteZ) });
+const retrieveResZ = z.object({ schematics: schematicZ.array() });
 
 const createReqZ = z.object({
   workspace: workspace.keyZ,
   schematics: newZ.array(),
 });
-const createResZ = z.object({ schematics: remoteZ.array() });
+const createResZ = z.object({ schematics: schematicZ.array() });
 
 const copyResZ = z.object({ schematic: schematicZ });
 const emptyResZ = z.object({});
@@ -99,7 +99,7 @@ export class Client {
     await sendRequired(
       this.client,
       "/schematic/set-data",
-      { key, data: JSON.stringify(data) },
+      { key, data },
       setDataReqZ,
       emptyResZ,
     );
@@ -122,7 +122,7 @@ export class Client {
     return isSingle ? res.schematics[0] : res.schematics;
   }
 
-  async delete(keys: Params): Promise<void> {
+  async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
       "/schematic/delete",
@@ -143,6 +143,3 @@ export class Client {
     return res.schematic;
   }
 }
-
-export const ontologyID = ontology.createIDFactory<Key>("schematic");
-export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/schematic/external.ts

@@ -8,5 +8,5 @@
 // included in the file licenses/APL.txt.
 
 export * from "@/schematic/client";
-export * from "@/schematic/payload";
 export * from "@/schematic/symbol";
+export * from "@/schematic/types.gen";

package/src/schematic/schematic.spec.ts

@@ -24,13 +24,18 @@ describe("Schematic", () => {
       });
       const schematic = await client.schematics.create(ws.key, {
         name: "Schematic",
-        data: { one: 1 },
+        data: { One: 1 },
       });
       expect(schematic.name).toEqual("Schematic");
       expect(schematic.key).not.toEqual(uuid.ZERO);
-      expect(schematic.data.one).toEqual(1);
+      expect(schematic.data.One).toEqual(1);
+      const retrieved = await client.schematics.retrieve({
+        key: schematic.key,
+      });
+      expect(retrieved.data.One).toEqual(1);
     });
   });
+
   describe("rename", () => {
     test("rename one", async () => {
       const ws = await client.workspaces.create({
@@ -48,6 +53,7 @@ describe("Schematic", () => {
       expect(res.name).toEqual("Schematic2");
     });
   });
+
   describe("setData", () => {
     test("set data", async () => {
       const ws = await client.workspaces.create({
@@ -65,6 +71,7 @@ describe("Schematic", () => {
       expect(res.data.two).toEqual(2);
     });
   });
+
   describe("delete", () => {
     test("delete one", async () => {
       const ws = await client.workspaces.create({
@@ -81,6 +88,50 @@ describe("Schematic", () => {
       );
     });
   });
+  describe("case preservation", () => {
+    test("should preserve key casing in data field on create/retrieve cycle", async () => {
+      const ws = await client.workspaces.create({
+        name: "CaseTest",
+        layout: {},
+      });
+      const schematic = await client.schematics.create(ws.key, {
+        name: "CaseTest",
+        data: {
+          camelCaseKey: "value1",
+          PascalCaseKey: "value2",
+          snake_case_key: "value3",
+          nested: {
+            innerCamelCase: 123,
+            InnerPascalCase: { deepKey: true },
+          },
+        },
+      });
+
+      const retrieved = await client.schematics.retrieve({
+        key: schematic.key,
+      });
+
+      const data = retrieved.data as Record<string, unknown>;
+      expect(data.camelCaseKey).toEqual("value1");
+      expect(data.PascalCaseKey).toEqual("value2");
+      expect(data.snake_case_key).toEqual("value3");
+      expect((data.nested as Record<string, unknown>).innerCamelCase).toEqual(123);
+      expect(
+        (
+          (data.nested as Record<string, unknown>).InnerPascalCase as Record<
+            string,
+            unknown
+          >
+        ).deepKey,
+      ).toEqual(true);
+      expect(Object.keys(data)).toContain("camelCaseKey");
+      expect(Object.keys(data)).toContain("PascalCaseKey");
+      expect(Object.keys(data)).toContain("snake_case_key");
+      expect(Object.keys(data)).not.toContain("camel_case_key");
+      expect(Object.keys(data)).not.toContain("pascal_case_key");
+    });
+  });
+
   describe("copy", () => {
     test("copy one", async () => {
       const ws = await client.workspaces.create({
@@ -100,6 +151,7 @@ describe("Schematic", () => {
       expect(schematic2.key).not.toEqual(uuid.ZERO);
       expect(schematic2.data.one).toEqual(1);
     });
+
     describe("snapshot", () => {
       it("should not allow the caller to edit the snapshot", async () => {
         const ws = await client.workspaces.create({

package/src/schematic/symbol/client.ts

@@ -20,7 +20,7 @@ import {
   newZ,
   type Symbol,
   symbolZ,
-} from "@/schematic/symbol/payload";
+} from "@/schematic/symbol/types.gen";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
 
 const createReqZ = z.object({ symbols: newZ.array(), parent: ontology.idZ });
@@ -42,7 +42,7 @@ export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
-const retrieveResZ = z.object({ symbols: array.nullableZ(symbolZ) });
+const retrieveResZ = z.object({ symbols: array.nullishToEmpty(symbolZ) });
 const createResZ = z.object({ symbols: symbolZ.array() });
 const emptyResZ = z.object({});
 const retrieveGroupReqZ = z.object({});
@@ -128,5 +128,3 @@ export class Client {
     return res.group;
   }
 }
-
-export const ontologyID = ontology.createIDFactory<Key>("schematic_symbol");