@synnaxlabs/client 0.56.1 → 0.57.0

package/src/lineplot/client.ts

@@ -8,98 +8,270 @@
 // 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 { actions } from "@/actions";
+import { createOf, kindOf, reduceAll } from "@/lineplot/actions";
+import {
+  type Action,
+  dispatchReqZ,
+  rename as renameAction,
+  scopedActionZ,
+} from "@/lineplot/actions.gen";
 import {
   type Key,
   keyZ,
   type LinePlot,
   linePlotZ,
   type New,
-  newZ,
+  ontologyID,
 } from "@/lineplot/types.gen";
-import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { workspace } from "@/workspace";
+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_lineplot_set";
+export const DELETE_CHANNEL_NAME = "sy_lineplot_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({ linePlots: array.nullishToEmpty(linePlotZ) });
+interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
 
-const createReqZ = z.object({ workspace: workspace.keyZ, linePlots: newZ.array() });
+const retrieveResZ = z.object({ linePlots: linePlotZ.array().default(() => []) });
+
+const createReqZ = z.object({ project: project.keyZ, linePlots: linePlotZ.array() });
 const createResZ = z.object({ linePlots: linePlotZ.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): ((p: LinePlot) => boolean) => {
+  const keySet = new Set(req.keys);
+  return (p) => keySet.has(p.key);
+};
 
-  constructor(client: UnaryClient) {
-    this.client = client;
+export interface ClientConfig {
+  unary: UnaryClient;
+  cache: query.Cache;
+  ontology: ontology.Client;
+}
+
+export class Client extends query.Retriever<
+  typeof retrieveMultiParamsZ,
+  Key,
+  LinePlot
+> {
+  private readonly cfg: ClientConfig;
+  private readonly store: query.Table<Key, LinePlot>;
+  private readonly dispatcher: actions.Controller<Key, LinePlot, 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, LinePlot>({
+      name: "line plots",
+      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, LinePlot, Action>({
+      store,
+      onError: cache.onError,
+      reduce: reduceAll,
+      kindOf,
+      createOf,
+    });
+    cache.listen(dispatcher.listener(SET_CHANNEL_NAME, scopedActionZ));
+    super(cache, {
+      name: "line plot",
+      table: store,
+      request: {
+        schema: retrieveMultiParamsZ,
+        fetch: async (req) => await this.execRetrieve(req),
+        matches: (plot, req) => requestFilter(req)(plot),
+      },
+    });
+    this.cfg = cfg;
+    this.store = store;
+    this.dispatcher = dispatcher;
   }
 
-  async create(workspace: workspace.Key, linePlot: New): Promise<LinePlot>;
-  async create(workspace: workspace.Key, linePlots: New[]): Promise<LinePlot[]>;
   async create(
-    workspace: workspace.Key,
+    project: project.Key,
+    linePlot: New,
+    opts?: query.WriteOptions<LinePlot[]>,
+  ): Promise<LinePlot>;
+  async create(
+    project: project.Key,
+    linePlots: New[],
+    opts?: query.WriteOptions<LinePlot[]>,
+  ): Promise<LinePlot[]>;
+  async create(
+    project: project.Key,
     linePlots: New | New[],
+    opts: query.WriteOptions<LinePlot[]> = {},
   ): Promise<LinePlot | LinePlot[]> {
     const isMany = Array.isArray(linePlots);
-    const res = await this.client.send(
-      "/lineplot/create",
-      { workspace, linePlots: array.toArray(linePlots) },
-      createReqZ,
-      createResZ,
-    );
+    const optimistic = array
+      .toArray(linePlots)
+      .map((p) => zod.parse(linePlotZ, p, { label: "line plot" }));
+    const res = await query.optimistic({
+      rollbacks: [this.store.set(optimistic)],
+      onOptimistic: () => opts.onOptimistic?.(optimistic),
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/lineplot/create",
+          { project, linePlots: optimistic },
+          createReqZ,
+          createResZ,
+        ),
+    });
+    this.store.set(res.linePlots);
     return isMany ? res.linePlots : res.linePlots[0];
   }
 
-  async rename(key: Key, name: string): Promise<void> {
-    await this.client.send("/lineplot/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("/lineplot/set-data", { key, data }, setDataReqZ, emptyResZ);
+  /**
+   * Applies actions to the cached line plot and sends them to the server, recording an
+   * undoable entry. Returns false without side effects when the line plot isn't cached.
+   * Rolls back the local apply and rethrows on send failure.
+   */
+  async dispatch(
+    key: Key,
+    actions: Action | Action[],
+    opts: actions.Options<LinePlot, Action> = {},
+  ): Promise<boolean> {
+    return await this.dispatcher.dispatch(
+      key,
+      array.toArray(actions),
+      this.dispatchSender(key),
+      opts,
+    );
   }
 
-  async retrieve(args: RetrieveSingleParams): Promise<LinePlot>;
-  async retrieve(args: RetrieveMultipleParams): Promise<LinePlot[]>;
-  async retrieve(
-    args: RetrieveSingleParams | RetrieveMultipleParams,
-  ): Promise<LinePlot | LinePlot[]> {
-    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
-    const res = await this.client.send(
-      "/lineplot/retrieve",
-      args,
-      retrieveArgsZ,
-      retrieveResZ,
-    );
-    checkForMultipleOrNoResults("LinePlot", args, res.linePlots, isSingle);
-    return isSingle ? res.linePlots[0] : res.linePlots;
+  /**
+   * Reverts the line plot'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 line plot'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 line plot has a live undo entry. */
+  hasUndo(key: Key): boolean {
+    return this.dispatcher.hasUndo(key);
+  }
+
+  /** Whether the line plot has a live redo entry. */
+  hasRedo(key: Key): boolean {
+    return this.dispatcher.hasRedo(key);
+  }
+
+  /**
+   * Subscribes to changes in the line plot'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);
   }
 
-  async delete(keys: Key | Key[]): Promise<void> {
-    await this.client.send(
-      "/lineplot/delete",
-      { keys: array.toArray(keys) },
-      deleteReqZ,
+  private async sendDispatch(
+    key: Key,
+    dispatchKey: string,
+    actions: Action[],
+  ): Promise<void> {
+    await this.cfg.unary.send(
+      "/lineplot/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(
+          "/lineplot/delete",
+          { keys: keysArr },
+          deleteReqZ,
+          emptyResZ,
+        ),
+    });
+    drop();
+  }
+
+  /** Subscribes to every line plot 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<LinePlot[]> {
+    const res = await this.cfg.unary.send(
+      "/lineplot/retrieve",
+      params,
+      retrieveReqZ,
+      retrieveResZ,
+    );
+    return res.linePlots;
+  }
 }

package/src/lineplot/external.ts

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

package/src/lineplot/line.ts

@@ -0,0 +1,80 @@
+// 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 { type channel } from "@/channel";
+import {
+  type Channels,
+  type Line,
+  lineZ,
+  type Ranges,
+  X_AXIS_KEYS,
+  type XAxisKey,
+  Y_AXIS_KEYS,
+  type YAxisKey,
+} from "@/lineplot/types.gen";
+
+// LineKeyParts is the structured identity of a plotted line: a y-channel on a y-axis
+// plotted against an x-channel/x-axis over a range. It is the decoded form of Line.key.
+export interface LineKeyParts {
+  yAxis: YAxisKey;
+  xAxis: XAxisKey;
+  range: string;
+  xChannel: channel.Key;
+  yChannel: channel.Key;
+}
+
+const SEPARATOR = "---";
+
+// lineKey encodes the identity of a line into the stable string stored as
+// Line.key. This is the only place the key format is defined.
+export const lineKey = (parts: LineKeyParts): string =>
+  [parts.yAxis, parts.xAxis, parts.range, parts.xChannel, parts.yChannel].join(
+    SEPARATOR,
+  );
+
+export const parseLineKey = (key: string): LineKeyParts => {
+  const [yAxis, xAxis, range, xChannel, yChannel] = key.split(SEPARATOR);
+  return {
+    yAxis: yAxis as YAxisKey,
+    xAxis: xAxis as XAxisKey,
+    range,
+    xChannel: Number(xChannel),
+    yChannel: Number(yChannel),
+  };
+};
+
+// reconcileLines rebuilds the complete set of lines implied by the channel and
+// range bindings: one line per (x-axis, range, y-axis, y-channel) combination.
+// Existing lines are preserved by key so user styling survives, missing ones
+// are created with default styling, and lines whose combination no longer
+// exists are returned in `dropped` (so callers can restore them on undo).
+export const reconcileLines = (
+  channels: Channels,
+  ranges: Ranges,
+  existing: Line[],
+): { lines: Line[]; dropped: Line[] } => {
+  const byKey = new Map(existing.map((l) => [l.key, l]));
+  const kept = new Set<string>();
+  const lines: Line[] = [];
+  for (const xAxis of X_AXIS_KEYS) {
+    const xChannel = channels[xAxis];
+    for (const range of ranges[xAxis])
+      for (const yAxis of Y_AXIS_KEYS)
+        for (const yChannel of channels[yAxis]) {
+          const key = lineKey({ yAxis, xAxis, range, xChannel, yChannel });
+          if (kept.has(key)) continue;
+          kept.add(key);
+          // A new line takes Oracle schema defaults (stroke width, downsample);
+          // label and color stay unset so they resolve at render time.
+          lines.push(byKey.get(key) ?? lineZ.parse({ key }));
+        }
+  }
+  const dropped = existing.filter((l) => !kept.has(l.key));
+  return { lines, dropped };
+};

package/src/lineplot/types.gen.ts

@@ -9,34 +9,247 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { caseconv, record } from "@synnaxlabs/x";
+import { color, spatial, text, uuid } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { channel } from "@/channel";
 import { ontology } from "@/ontology";
 
+export const AXIS_KEYS = ["x1", "x2", "y1", "y2", "y3", "y4"] as const;
+export const axisKeyZ = z.enum(AXIS_KEYS);
+export type AxisKey = z.infer<typeof axisKeyZ>;
+
+export const TICK_TYPES = ["linear", "time"] as const;
+export const tickTypeZ = z.enum(TICK_TYPES);
+export type TickType = z.infer<typeof tickTypeZ>;
+
+export const DOWNSAMPLE_MODES = ["average", "decimate"] as const;
+export const downsampleModeZ = z.enum(DOWNSAMPLE_MODES);
+export type DownsampleMode = z.infer<typeof downsampleModeZ>;
+
+export const X_AXIS_KEYS = ["x1", "x2"] as const;
+export const xAxisKeyZ = z.enum(X_AXIS_KEYS);
+export type XAxisKey = z.infer<typeof xAxisKeyZ>;
+
+export const Y_AXIS_KEYS = ["y1", "y2", "y3", "y4"] as const;
+export const yAxisKeyZ = z.enum(Y_AXIS_KEYS);
+export type YAxisKey = z.infer<typeof yAxisKeyZ>;
+
+/** Title is the plot title configuration. */
+export const titleZ = z.object({
+  /** level is the typography level of the title text. */
+  level: text.levelZ.default("h4"),
+  /** visible is whether the title is shown above the plot. */
+  visible: z.boolean().default(false),
+});
+export interface Title extends z.infer<typeof titleZ> {}
+
+/** Legend is the plot legend configuration. */
+export const legendZ = z.object({
+  /**
+   * hidden is whether the legend is hidden. When false (the default), the legend is
+   * shown.
+   */
+  hidden: z.boolean().default(false),
+  /** position is the anchor position of the legend within the plot container. */
+  position: spatial.stickyXYZ.prefault({
+    x: 50,
+    y: 50,
+    root: { x: "left", y: "top" },
+    units: { x: "px", y: "px" },
+  }),
+});
+export interface Legend extends z.infer<typeof legendZ> {}
+
+/**
+ * Channels binds channel keys to each axis. x1 and x2 are single-channel; y1 through y4
+ * carry zero or more channels each.
+ */
+export const channelsZ = z.object({
+  /** x1 is the channel rendered on the x1 axis. */
+  x1: channel.keyZ.default(0),
+  /** x2 is the channel rendered on the x2 axis. */
+  x2: channel.keyZ.default(0),
+  /** y1 are the channels rendered on the y1 axis. */
+  y1: channel.keyZ.array().default(() => []),
+  /** y2 are the channels rendered on the y2 axis. */
+  y2: channel.keyZ.array().default(() => []),
+  /** y3 are the channels rendered on the y3 axis. */
+  y3: channel.keyZ.array().default(() => []),
+  /** y4 are the channels rendered on the y4 axis. */
+  y4: channel.keyZ.array().default(() => []),
+});
+export interface Channels extends z.infer<typeof channelsZ> {}
+
+/** Ranges binds range keys to each x-axis. */
+export const rangesZ = z.object({
+  /**
+   * x1 are the range keys plotted against the x1 axis. Range keys are opaque strings
+   * rather than UUIDs because the console layers synthetic rolling-window ranges (e.g.
+   * "recent", "rolling1m") alongside persisted ranges; the server stores whatever the
+   * client sends.
+   */
+  x1: z
+    .string()
+    .array()
+    .default(() => []),
+  /** x2 are the range keys plotted against the x2 axis. */
+  x2: z
+    .string()
+    .array()
+    .default(() => []),
+});
+export interface Ranges extends z.infer<typeof rangesZ> {}
+
+/**
+ * ManualBounds controls whether an axis uses a manually-set bound on each side
+ * independently. When a side is false (the default), the corresponding entry in
+ * Axis.bounds is recomputed locally from the rendered data window and never broadcast
+ * to the server; when true, Axis.bounds holds the user-set value.
+ */
+export const manualBoundsZ = z.object({
+  /**
+   * lower is whether the lower bound is set manually rather than computed from data.
+   */
+  lower: z.boolean().default(false),
+  /**
+   * upper is whether the upper bound is set manually rather than computed from data.
+   */
+  upper: z.boolean().default(false),
+});
+export interface ManualBounds extends z.infer<typeof manualBoundsZ> {}
+
+/** Line is the per-line styling and downsampling configuration. */
+export const lineZ = z.object({
+  /**
+   * key is the line identifier derived from its channel and range assignment. Format is
+   * internal to the client and stable across re-renders so styling overrides persist.
+   */
+  key: z.string(),
+  /**
+   * label is the user-specified line label. Null means derive from the channel name at
+   * render time; non-null is an override.
+   */
+  label: z.string().optional(),
+  /**
+   * color is the line color. When null, the Console assigns one from the visualization
+   * palette at render time.
+   */
+  color: color.colorZ.optional(),
+  /** strokeWidth is the line stroke width in pixels. */
+  strokeWidth: z.number().default(2),
+  /**
+   * downsample is the downsample factor applied before rendering. 1 means render every
+   * sample; higher values render every Nth sample.
+   */
+  downsample: z.uint32().default(1),
+  /** downsampleMode selects how the downsample factor is applied. */
+  downsampleMode: downsampleModeZ.default("decimate"),
+});
+export interface Line extends z.infer<typeof lineZ> {}
+
+/** Rule is a horizontal or vertical annotation line drawn over the plot. */
+export const ruleZ = z.object({
+  /** key is the unique rule identifier within the line plot. */
+  key: z.string(),
+  /** label is the human-readable label rendered alongside the rule. */
+  label: z.string(),
+  /**
+   * color is the display color of the rule. When null, the Console assigns a default at
+   * render time.
+   */
+  color: color.colorZ.optional(),
+  /** axis is the axis the rule is anchored to. */
+  axis: axisKeyZ,
+  /** lineWidth is the rule line width in pixels. */
+  lineWidth: z.number().default(1),
+  /** lineDash is the dash length in pixels; 0 renders a solid line. */
+  lineDash: z.number().default(0),
+  /** units is the unit label displayed next to the position value. */
+  units: z.string().default(""),
+  /** position is the value-space position of the rule along its anchored axis. */
+  position: z.number(),
+});
+export interface Rule extends z.infer<typeof ruleZ> {}
+
 export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
+/** Axis is the configuration for a single plot axis. */
+export const axisZ = z.object({
+  /** key identifies which of the six axes this configuration applies to. */
+  key: axisKeyZ,
+  /** label is the human-readable label rendered along the axis. */
+  label: z.string().default(""),
+  /** labelDirection is the orientation in which the label text is laid out. */
+  labelDirection: spatial.directionZ.default("x"),
+  /** labelLevel is the typography level of the label. */
+  labelLevel: text.levelZ.default("small"),
+  /**
+   * bounds is the value-space window of the axis. When the matching entry in
+   * manual_bounds is false the field is overwritten locally on every render; otherwise
+   * it is the user-set fixed bound.
+   */
+  bounds: spatial.boundsZ().prefault({ lower: 0, upper: 0 }),
+  /** manualBounds controls per-edge manual bound override. */
+  manualBounds: manualBoundsZ.prefault({}),
+  /** tickSpacing is the target pixel distance between adjacent tick marks. */
+  tickSpacing: z.number().default(75),
+  /**
+   * type selects the tick label style. Null means default (linear). X-axes typically
+   * carry "time" when bound to a timestamp channel.
+   */
+  type: tickTypeZ.optional(),
+});
+export interface Axis extends z.infer<typeof axisZ> {}
+
+/** Axes bundles configuration for all six fixed plot axes. */
+export const axesZ = z.object({
+  /** x1 is the x1 axis configuration. */
+  x1: axisZ.prefault({ key: "x1" }),
+  /** x2 is the x2 axis configuration. */
+  x2: axisZ.prefault({ key: "x2" }),
+  /** y1 is the y1 axis configuration. */
+  y1: axisZ.prefault({ key: "y1", labelDirection: "y" }),
+  /** y2 is the y2 axis configuration. */
+  y2: axisZ.prefault({ key: "y2", labelDirection: "y" }),
+  /** y3 is the y3 axis configuration. */
+  y3: axisZ.prefault({ key: "y3", labelDirection: "y" }),
+  /** y4 is the y4 axis configuration. */
+  y4: axisZ.prefault({ key: "y4", labelDirection: "y" }),
+});
+export interface Axes extends z.infer<typeof axesZ> {}
+
 /**
- * LinePlot is a time-series visualization component for plotting telemetry data.
- * Line plots support multiple channels, real-time streaming, and historical
- * data display with zoom and pan capabilities.
+ * LinePlot is a time-series visualization component for plotting telemetry data. Line
+ * plots support multiple channels, real-time streaming, and historical data display
+ * with zoom and pan capabilities.
  */
 export const linePlotZ = z.object({
   /** key is the unique identifier for this line plot. */
-  key: keyZ,
+  key: keyZ.default(uuid.create),
   /** name is a human-readable name for the line plot. */
-  name: z.string(),
+  name: z.string().min(1, "name is required"),
+  /** title is the plot title configuration. */
+  title: titleZ.prefault({}),
+  /** legend is the plot legend configuration. */
+  legend: legendZ.prefault({}),
+  /** channels binds channel keys to each axis. */
+  channels: channelsZ.prefault({}),
+  /** ranges binds range keys to each x-axis. */
+  ranges: rangesZ.prefault({}),
+  /** axes bundles per-axis configuration. */
+  axes: axesZ.prefault({}),
   /**
-   * data is the line plot configuration including channel references, axis
-   * settings, and display options.
+   * lines holds per-line styling and downsampling configuration. Each entry corresponds
+   * to one channel and range combination produced by the channels and ranges bindings.
    */
-  data: caseconv.preserveCase(record.nullishToEmpty()),
+  lines: lineZ.array().default(() => []),
+  /** rules holds annotation rules drawn over the plot. */
+  rules: ruleZ.array().default(() => []),
 });
 export interface LinePlot extends z.infer<typeof linePlotZ> {}
-
-export const newZ = linePlotZ.partial({ key: true });
-export interface New extends z.input<typeof newZ> {}
+export interface New extends z.input<typeof linePlotZ> {}
 
 export const ontologyID = ontology.createIDFactory<Key>("lineplot");
 export const TYPE_ONTOLOGY_ID = ontologyID("");