@synnaxlabs/client 0.43.1 → 0.44.2

package/src/ontology/writer.ts

@@ -8,9 +8,9 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { z } from "zod/v4";
+import { z } from "zod";
 
-import { type CrudeID, ID, idZ } from "@/ontology/payload";
+import { type ID, idZ } from "@/ontology/payload";
 
 const ADD_CHILDREN_ENDPOINT = "/ontology/add-children";
 const REMOVE_CHILDREN_ENDPOINT = "/ontology/remove-children";
@@ -29,40 +29,31 @@ export class Writer {
     this.client = client;
   }
 
-  async addChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
+  async addChildren(id: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
       ADD_CHILDREN_ENDPOINT,
-      { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
+      { id, children },
       addRemoveChildrenReqZ,
       emptyResZ,
     );
   }
 
-  async removeChildren(id: CrudeID, ...children: CrudeID[]): Promise<void> {
+  async removeChildren(id: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof addRemoveChildrenReqZ, typeof emptyResZ>(
       this.client,
       REMOVE_CHILDREN_ENDPOINT,
-      { id: new ID(id).payload, children: children.map((c) => new ID(c).payload) },
+      { id, children },
       addRemoveChildrenReqZ,
       emptyResZ,
     );
   }
 
-  async moveChildren(
-    from: CrudeID,
-    to: CrudeID,
-    ...children: CrudeID[]
-  ): Promise<void> {
-    const req = {
-      from: new ID(from).payload,
-      to: new ID(to).payload,
-      children: children.map((c) => new ID(c).payload),
-    };
+  async moveChildren(from: ID, to: ID, ...children: ID[]): Promise<void> {
     await sendRequired<typeof moveChildrenReqZ, typeof emptyResZ>(
       this.client,
       MOVE_CHILDREN_ENDPOINT,
-      req,
+      { from, to, children },
       moveChildrenReqZ,
       emptyResZ,
     );

package/src/ranger/alias.ts

@@ -8,13 +8,13 @@
 // 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 { z } from "zod/v4";
+import { z } from "zod";
 
 import { channel } from "@/channel";
 import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
-import { signals } from "@/signals";
 
 export const SET_ALIAS_CHANNEL_NAME = "sy_range_alias_set";
 export const DELETE_ALIAS_CHANNEL_NAME = "sy_range_alias_delete";
@@ -38,10 +38,15 @@ const listReqZ = z.object({ range: keyZ });
 
 const listResZ = z.object({ aliases: z.record(z.string(), z.string()) });
 
+const retrieveReqZ = z.object({ range: keyZ, channels: channel.keyZ.array() });
+
+const retrieveResZ = z.object({ aliases: z.record(z.string(), z.string()) });
+
 export class Aliaser {
   private static readonly SET_ENDPOINT = "/range/alias/set";
   private static readonly RESOLVE_ENDPOINT = "/range/alias/resolve";
   private static readonly LIST_ENDPOINT = "/range/alias/list";
+  private static readonly RETRIEVE_ENDPOINT = "/range/alias/retrieve";
   private static readonly DELETE_ENDPOINT = "/range/alias/delete";
   private readonly frameClient: framer.Client;
   private readonly cache = new Map<string, channel.Key>();
@@ -109,6 +114,23 @@ export class Aliaser {
     ).aliases;
   }
 
+  async retrieve(alias: channel.Key): Promise<string>;
+  async retrieve(aliases: channel.Key[]): Promise<Record<channel.Key, string>>;
+
+  async retrieve(
+    alias: channel.Key | channel.Key[],
+  ): Promise<string | Record<channel.Key, string>> {
+    const isSingle = typeof alias === "number";
+    const res = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
+      this.client,
+      Aliaser.RETRIEVE_ENDPOINT,
+      { range: this.rangeKey, channels: array.toArray(alias) },
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return isSingle ? res.aliases[alias] : res.aliases;
+  }
+
   async delete(aliases: channel.Key[]): Promise<void> {
     await sendRequired<typeof deleteReqZ, typeof deleteResZ>(
       this.client,
@@ -118,44 +140,30 @@ export class Aliaser {
       deleteResZ,
     );
   }
-
-  async openChangeTracker(): Promise<signals.Observable<string, Alias>> {
-    return await signals.openObservable<string, Alias>(
-      this.frameClient,
-      SET_ALIAS_CHANNEL_NAME,
-      DELETE_ALIAS_CHANNEL_NAME,
-      decodeAliasChanges(this.rangeKey),
-    );
-  }
 }
 
-export interface Alias {
+export const aliasZ = z.object({
+  alias: z.string().optional(),
+  channel: channel.keyZ,
+  range: keyZ,
+});
+export interface Alias extends z.infer<typeof aliasZ> {}
+
+export type AliasChange = change.Change<string, Alias>;
+
+const SEPARATOR = "---";
+
+export const aliasKey = (alias: Pick<Alias, "range" | "channel">): string =>
+  `${alias.range}${SEPARATOR}${alias.channel}`;
+
+export interface DecodedDeleteAliasChange {
   range: Key;
   channel: channel.Key;
-  alias: string;
 }
 
-export type AliasChange = change.Change<string, Alias>;
-
-const aliasZ = z.object({ range: keyZ, channel: channel.keyZ, alias: z.string() });
-
-const separator = "---";
-
-const decodeAliasChanges =
-  (rangeKey: Key): signals.Decoder<string, Alias> =>
-  (variant, data) => {
-    if (variant === "delete")
-      return data
-        .toStrings()
-        .filter((k) => k.split(separator)[0] === rangeKey)
-        .map((alias) => ({
-          variant,
-          key: alias,
-          value: undefined,
-        }));
-    return data.parseJSON(aliasZ).map((alias) => ({
-      variant,
-      key: alias.alias,
-      value: alias,
-    }));
-  };
+export const decodeDeleteAliasChange = (
+  deletedAlias: string,
+): DecodedDeleteAliasChange => {
+  const [range, channel] = deletedAlias.split(SEPARATOR);
+  return { range, channel: Number(channel) };
+};

package/src/ranger/client.ts

@@ -8,43 +8,53 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { type CrudeTimeRange, observe, sortTimeRange, TimeRange } from "@synnaxlabs/x";
-import { array } from "@synnaxlabs/x/array";
-import { type AsyncTermSearcher } from "@synnaxlabs/x/search";
+import { array, type CrudeTimeRange, TimeRange } from "@synnaxlabs/x";
 import { type Series } from "@synnaxlabs/x/telem";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { type channel } from "@/channel";
-import { MultipleFoundError, NotFoundError, QueryError } from "@/errors";
+import { QueryError } from "@/errors";
 import { type framer } from "@/framer";
 import { label } from "@/label";
-import { ontology } from "@/ontology";
-import { type Alias, Aliaser } from "@/ranger/alias";
+import { type ontology } from "@/ontology";
+import { Aliaser } from "@/ranger/alias";
 import { KV } from "@/ranger/kv";
 import {
-  ALIAS_ONTOLOGY_TYPE,
-  analyzeParams,
   type Key,
   type Keys,
   keyZ,
   type Name,
   type Names,
   type New,
-  ONTOLOGY_TYPE,
   type Params,
   type Payload,
   payloadZ,
 } from "@/ranger/payload";
 import { type CreateOptions, type Writer } from "@/ranger/writer";
-import { signals } from "@/signals";
+import { checkForMultipleOrNoResults } from "@/util/retrieve";
 import { nullableArrayZ } from "@/util/zod";
 
+export const SET_CHANNEL_NAME = "sy_range_set";
+export const DELETE_CHANNEL_NAME = "sy_range_delete";
+
+interface RangeConstructionOptions {
+  frameClient: framer.Client;
+  kv: KV;
+  aliaser: Aliaser;
+  channels: channel.Retriever;
+  labelClient: label.Client;
+  ontologyClient: ontology.Client;
+  rangeClient: Client;
+}
+
 export class Range {
   key: string;
   name: string;
   readonly kv: KV;
   readonly timeRange: TimeRange;
   readonly color: string | undefined;
+  readonly parent: Payload | null;
+  readonly labels?: label.Label[];
   readonly channels: channel.Retriever;
   private readonly aliaser: Aliaser;
   private readonly frameClient: framer.Client;
@@ -53,29 +63,30 @@ export class Range {
   private readonly rangeClient: Client;
 
   constructor(
-    name: string,
-    timeRange: TimeRange = TimeRange.ZERO,
-    key: string,
-    color: string | undefined,
-    _frameClient: framer.Client,
-    _kv: KV,
-    _aliaser: Aliaser,
-    _channels: channel.Retriever,
-    _labelClient: label.Client,
-    _ontologyClient: ontology.Client,
-    _rangeClient: Client,
+    { name, timeRange = TimeRange.ZERO, key, color, parent, labels }: Payload,
+    {
+      frameClient,
+      kv,
+      aliaser,
+      channels,
+      labelClient,
+      ontologyClient,
+      rangeClient,
+    }: RangeConstructionOptions,
   ) {
     this.key = key;
     this.name = name;
     this.timeRange = timeRange;
-    this.frameClient = _frameClient;
+    this.parent = parent;
+    this.labels = labels;
+    this.frameClient = frameClient;
     this.color = color;
-    this.kv = _kv;
-    this.aliaser = _aliaser;
-    this.channels = _channels;
-    this.labelClient = _labelClient;
-    this.ontologyClient = _ontologyClient;
-    this.rangeClient = _rangeClient;
+    this.kv = kv;
+    this.aliaser = aliaser;
+    this.channels = channels;
+    this.labelClient = labelClient;
+    this.ontologyClient = ontologyClient;
+    this.rangeClient = rangeClient;
   }
 
   get ontologyID(): ontology.ID {
@@ -83,11 +94,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 {
       key: this.key,
       name: this.name,
       timeRange: this.timeRange,
       color: this.color,
+      labels: this.labels,
+      parent,
     };
   }
 
@@ -109,10 +126,6 @@ export class Range {
     return await this.aliaser.resolve(alias);
   }
 
-  async openAliasTracker(): Promise<signals.Observable<string, Alias>> {
-    return await this.aliaser.openChangeTracker();
-  }
-
   async retrieveParent(): Promise<Range | null> {
     return this.rangeClient.retrieveParent(this.key);
   }
@@ -133,8 +146,8 @@ export class Range {
     return await this.frameClient.read(this.timeRange, channels);
   }
 
-  async labels(): Promise<label.Label[]> {
-    return await this.labelClient.retrieveFor(ontologyID(this.key));
+  async retrieveLabels(): Promise<label.Label[]> {
+    return await this.labelClient.retrieve({ for: ontologyID(this.key) });
   }
 
   async addLabel(...labels: label.Key[]): Promise<void> {
@@ -142,69 +155,47 @@ export class Range {
   }
 
   async removeLabel(...labels: label.Key[]): Promise<void> {
-    await this.labelClient.removeLabels(ontologyID(this.key), labels);
-  }
-
-  async openChildRangeTracker(): Promise<observe.ObservableAsyncCloseable<Range[]>> {
-    const wrapper = new observe.Observer<Range[]>();
-    const initial: ontology.Resource[] = (await this.retrieveChildren()).map((r) => {
-      const id = ontologyID(r.key);
-      return { id, key: id.toString(), name: r.name, data: r.payload };
-    });
-    const base = await this.ontologyClient.openDependentTracker({
-      target: this.ontologyID,
-      dependents: initial,
-      resourceType: "range",
-    });
-    base.onChange((r: ontology.Resource[]) =>
-      wrapper.notify(this.rangeClient.resourcesToRanges(r)),
-    );
-    wrapper.setCloser(async () => await base.close());
-    return wrapper;
+    await this.labelClient.remove(ontologyID(this.key), labels);
   }
 
-  async openParentRangeTracker(): Promise<observe.ObservableAsyncCloseable<Range> | null> {
-    const wrapper = new observe.Observer<Range>();
-    const p = await this.retrieveParent();
-    if (p == null) return null;
-    const id = ontologyID(p.key);
-    const resourceP = { id, key: id.toString(), name: p.name, data: p.payload };
-    const base = await this.ontologyClient.openDependentTracker({
-      target: this.ontologyID,
-      dependents: [resourceP],
-      relationshipDirection: "to",
-    });
-    base.onChange((resources: ontology.Resource[]) => {
-      const ranges = this.rangeClient.resourcesToRanges(resources);
-      if (ranges.length === 0) return;
-      const p = ranges[0];
-      wrapper.notify(p);
-    });
-    wrapper.setCloser(async () => await base.close());
-    return wrapper;
+  static sort(a: Range, b: Range): number {
+    return TimeRange.sort(a.timeRange, b.timeRange);
   }
 }
 
-export const sort = (a: Range, b: Range): -1 | 0 | 1 =>
-  sortTimeRange(a.timeRange, b.timeRange);
-
-const retrieveReqZ = z.object({
+const retrieveRequestZ = z.object({
   keys: keyZ.array().optional(),
   names: z.array(z.string()).optional(),
-  term: z.string().optional(),
+  searchTerm: z.string().optional(),
   overlapsWith: TimeRange.z.optional(),
   limit: z.number().int().optional(),
   offset: z.number().int().optional(),
   hasLabels: label.keyZ.array().optional(),
+  includeLabels: z.boolean().optional(),
+  includeParent: z.boolean().optional(),
 });
 
-export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
+export type RetrieveRequest = z.infer<typeof retrieveRequestZ>;
+
+const retrieveArgsZ = retrieveRequestZ
+  .or(keyZ.array().transform((keys) => ({ keys })))
+  .or(keyZ.transform((key) => ({ keys: [key] })))
+  .or(z.string().transform((name) => ({ names: [name] })))
+  .or(
+    z
+      .string()
+      .array()
+      .transform((names) => ({ names })),
+  )
+  .or(TimeRange.z.transform((timeRange) => ({ overlapsWith: timeRange })));
+
+export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
 const RETRIEVE_ENDPOINT = "/range/retrieve";
 
 const retrieveResZ = z.object({ ranges: nullableArrayZ(payloadZ) });
 
-export class Client implements AsyncTermSearcher<string, Key, Range> {
+export class Client {
   readonly type: string = "range";
   private readonly frameClient: framer.Client;
   private readonly writer: Writer;
@@ -247,48 +238,28 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     await this.writer.delete(array.toArray(key));
   }
 
-  async search(term: string): Promise<Range[]> {
-    return this.sugarMany(await this.execRetrieve({ term }));
-  }
-
-  async page(offset: number, limit: number): Promise<Range[]> {
-    return this.sugarMany(await this.execRetrieve({ offset, limit }));
-  }
-
-  async retrieve(range: CrudeTimeRange): Promise<Range[]>;
-  async retrieve(range: Key | Name): Promise<Range>;
-  async retrieve(range: Keys | Names): Promise<Range[]>;
-  async retrieve(ranges: Params | CrudeTimeRange): Promise<Range | Range[]> {
-    if (typeof ranges === "object" && "start" in ranges)
-      return await this.execRetrieve({ overlapsWith: new TimeRange(ranges) });
-    const { single, actual, variant, normalized, empty } = analyzeParams(ranges);
-    if (empty) return [];
-    const retrieved = await this.execRetrieve({ [variant]: normalized });
-    if (!single) return retrieved;
-    if (retrieved.length === 0)
-      throw new NotFoundError(`range matching ${actual as string} not found`);
-    if (retrieved.length > 1)
-      throw new MultipleFoundError(
-        `multiple ranges matching ${actual as string} found`,
-      );
-    return retrieved[0];
-  }
-
-  getKV(range: Key): KV {
-    return new KV(range, this.unaryClient, this.frameClient);
-  }
-
-  private async execRetrieve(req: RetrieveRequest): Promise<Range[]> {
-    const { ranges } = await sendRequired<typeof retrieveReqZ, typeof retrieveResZ>(
+  async retrieve(params: Key | Name): Promise<Range>;
+  async retrieve(params: Keys | Names): Promise<Range[]>;
+  async retrieve(params: TimeRange): Promise<Range[]>;
+  async retrieve(params: RetrieveRequest): Promise<Range[]>;
+  async retrieve(params: RetrieveArgs): Promise<Range | Range[]> {
+    const isSingle = typeof params === "string";
+    const { ranges } = await sendRequired(
       this.unaryClient,
       RETRIEVE_ENDPOINT,
-      req,
-      retrieveReqZ,
+      params,
+      retrieveArgsZ,
       retrieveResZ,
     );
+    checkForMultipleOrNoResults("Range", params, ranges, isSingle);
+    if (isSingle) return this.sugarMany(ranges)[0];
     return this.sugarMany(ranges);
   }
 
+  getKV(range: Key): KV {
+    return new KV(range, this.unaryClient);
+  }
+
   async retrieveParent(range: Key): Promise<Range | null> {
     const res = await this.ontologyClient.retrieveParents(ontologyID(range));
     if (res.length === 0) return null;
@@ -297,42 +268,47 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
     return await this.retrieve(first.id.key);
   }
 
-  sugarOne(payload: Payload): Range {
-    return new Range(
-      payload.name,
-      payload.timeRange,
-      payload.key,
-      payload.color,
-      this.frameClient,
-      new KV(payload.key, this.unaryClient, this.frameClient),
-      new Aliaser(payload.key, this.frameClient, this.unaryClient),
-      this.channels,
-      this.labelClient,
-      this.ontologyClient,
-      this,
-    );
+  sugarOntologyResource(resource: ontology.Resource): Range {
+    return this.sugarOne(convertOntologyResourceToPayload(resource));
   }
 
-  sugarMany(payloads: Payload[]): Range[] {
-    return payloads.map((payload) => this.sugarOne(payload));
+  async retrieveAlias(range: Key, channel: channel.Key): Promise<string> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.retrieve(channel);
   }
 
-  async openTracker(): Promise<signals.Observable<string, Range>> {
-    return await signals.openObservable<string, Range>(
-      this.frameClient,
-      "sy_range_set",
-      "sy_range_delete",
-      (variant, data) => {
-        if (variant === "delete")
-          return data.toUUIDs().map((k) => ({ variant, key: k, value: undefined }));
-        const sugared = this.sugarMany(data.parseJSON(payloadZ));
-        return sugared.map((r) => ({ variant, key: r.key, value: r }));
-      },
-    );
+  async retrieveAliases(
+    range: Key,
+    channels: channel.Key[],
+  ): Promise<Record<channel.Key, string>> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.retrieve(channels);
   }
 
-  resourcesToRanges(resources: ontology.Resource[]): Range[] {
-    return resources.map((r) => this.resourceToRange(r));
+  async listAliases(range: Key): Promise<Record<channel.Key, string>> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    return await aliaser.list();
+  }
+
+  async setAlias(range: Key, channel: channel.Key, alias: string): Promise<void> {
+    const aliaser = new Aliaser(range, this.frameClient, this.unaryClient);
+    await aliaser.set({ [channel]: alias });
+  }
+
+  sugarOne(payload: Payload): Range {
+    return new Range(payload, {
+      frameClient: this.frameClient,
+      kv: new KV(payload.key, this.unaryClient),
+      aliaser: new Aliaser(payload.key, this.frameClient, this.unaryClient),
+      channels: this.channels,
+      labelClient: this.labelClient,
+      ontologyClient: this.ontologyClient,
+      rangeClient: this,
+    });
+  }
+
+  sugarMany(payloads: Payload[]): Range[] {
+    return payloads.map((payload) => this.sugarOne(payload));
   }
 
   resourceToRange(resource: ontology.Resource): Range {
@@ -341,12 +317,31 @@ export class Client implements AsyncTermSearcher<string, Key, Range> {
       name: resource.data?.name as string,
       timeRange: new TimeRange(resource.data?.timeRange as CrudeTimeRange),
       color: resource.data?.color as string,
+      labels: [],
+      parent: null,
     });
   }
 }
 
-export const ontologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key });
+export const ontologyID = (key: Key): ontology.ID => ({ type: "range", key });
+
+export const aliasOntologyID = (key: Key): ontology.ID => ({
+  type: "range-alias",
+  key,
+});
 
-export const aliasOntologyID = (key: Key): ontology.ID =>
-  new ontology.ID({ type: ALIAS_ONTOLOGY_TYPE, key });
+export const convertOntologyResourceToPayload = ({
+  data,
+  id: { key },
+  name,
+}: ontology.Resource): Payload => {
+  const timeRange = TimeRange.z.parse(data?.timeRange);
+  return {
+    key,
+    name,
+    timeRange,
+    color: typeof data?.color === "string" ? data.color : undefined,
+    labels: [],
+    parent: null,
+  };
+};

package/src/ranger/external.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.
 
-export { type Alias, type AliasChange } from "@/ranger/alias";
+export * from "@/ranger/alias";
 export * from "@/ranger/client";
 export * from "@/ranger/kv";
 export * from "@/ranger/payload";

package/src/ranger/kv.ts

@@ -10,16 +10,20 @@
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { array } from "@synnaxlabs/x/array";
 import { isObject } from "@synnaxlabs/x/identity";
-import { z } from "zod/v4";
+import { z } from "zod";
 
-import { type framer } from "@/framer";
 import { type Key, keyZ } from "@/ranger/payload";
-import { signals } from "@/signals";
 import { nullableArrayZ } from "@/util/zod";
 
-const kvPairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
+export const KV_SET_CHANNEL = "sy_range_kv_set";
+export const KV_DELETE_CHANNEL = "sy_range_kv_delete";
+
+export const kvPairZ = z.object({ range: keyZ, key: z.string(), value: z.string() });
 export interface KVPair extends z.infer<typeof kvPairZ> {}
 
+export const kvPairKey = ({ range, key }: Omit<KVPair, "value">) =>
+  `${range}<--->${key}`;
+
 const getReqZ = z.object({ range: keyZ, keys: z.string().array() });
 export interface GetRequest extends z.infer<typeof getReqZ> {}
 
@@ -37,12 +41,10 @@ export class KV {
   private static readonly DELETE_ENDPOINT = "/range/kv/delete";
   private readonly rangeKey: Key;
   private readonly client: UnaryClient;
-  private readonly frameClient: framer.Client;
 
-  constructor(rng: Key, client: UnaryClient, frameClient: framer.Client) {
+  constructor(rng: Key, client: UnaryClient) {
     this.rangeKey = rng;
     this.client = client;
-    this.frameClient = frameClient;
   }
 
   async get(key: string): Promise<string>;
@@ -92,24 +94,4 @@ export class KV {
       z.unknown(),
     );
   }
-
-  async openTracker(): Promise<signals.Observable<string, KVPair>> {
-    return await signals.openObservable<string, KVPair>(
-      this.frameClient,
-      "sy_range_kv_set",
-      "sy_range_kv_delete",
-      (variant, data) => {
-        if (variant === "delete")
-          return data.toStrings().map((combinedKey) => {
-            const [range, key] = combinedKey.split("<--->", 2);
-            return { variant, key: combinedKey, value: { range, key, value: "" } };
-          });
-        return data.parseJSON(kvPairZ).map((pair) => ({
-          variant,
-          key: `${pair.range}${pair.key}`,
-          value: pair,
-        }));
-      },
-    );
-  }
 }