@synnaxlabs/client 0.56.2 → 0.57.1

package/src/task/types.gen.ts

@@ -9,20 +9,41 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { caseconv, type optional, record, status, zod } from "@synnaxlabs/x";
+import { caseconv, type optional, record, uuid } from "@synnaxlabs/x";
 import { z } from "zod";
 
+import { device } from "@/device";
 import { ontology } from "@/ontology";
+import { rack } from "@/rack";
+import { status } from "@/status";
 
-export const keyZ = z
-  .string()
-  .or(z.number().transform(String).or(z.bigint().transform(String)));
+/** KeyedConfig is the base for every stored task configuration record. */
+export const keyedConfigZ = z.object({
+  /** key is the unique identifier for the stored configuration record. */
+  key: z.uuid().default(uuid.create),
+});
+export interface KeyedConfig extends z.infer<typeof keyedConfigZ> {}
+
+export const keyZ = z.uuid();
 export type Key = z.infer<typeof keyZ>;
 
+export const startConfigZ = keyedConfigZ.extend({
+  autoStart: z.boolean().default(false),
+});
+export interface StartConfig extends z.infer<typeof startConfigZ> {}
+
+export const scanConfigZ = keyedConfigZ.extend({
+  rate: z.number().default(0.2),
+  disabled: z.boolean().default(false),
+});
+export interface ScanConfig extends z.infer<typeof scanConfigZ> {}
+
 export type StatusDetailsZodObject<Data extends z.ZodType = z.ZodNever> = z.ZodObject<{
   task: typeof keyZ;
   running: z.ZodBoolean;
-  cmd: z.ZodOptional<z.ZodString>;
+  cmd: z.ZodDefault<z.ZodString>;
+  configHash: z.ZodDefault<z.ZodString>;
+  rack: z.ZodDefault<typeof rack.keyZ>;
   data: [Data] extends [z.ZodNever] ? z.ZodOptional<z.ZodUnknown> : z.ZodOptional<Data>;
 }>;
 
@@ -37,43 +58,17 @@ export const statusDetailsZ: StatusDetailsZFunction = <Data extends z.ZodType>(
   z.object({
     task: keyZ,
     running: z.boolean(),
-    cmd: z.string().optional(),
+    cmd: z.string().default(""),
+    configHash: z.string().default(""),
+    rack: rack.keyZ.default(0),
     data: (data ?? z.unknown()).optional(),
   });
 export type StatusDetails<Data extends z.ZodType = z.ZodNever> = {
   task: Key;
   running: boolean;
-  cmd?: string;
-} & ([Data] extends [z.ZodNever] ? {} : { data?: z.infer<Data> });
-
-export type NewStatusDetailsZodObject<Data extends z.ZodType = z.ZodNever> =
-  z.ZodObject<{
-    task: z.ZodOptional<typeof keyZ>;
-    running: z.ZodBoolean;
-    cmd: z.ZodOptional<z.ZodString>;
-    data: [Data] extends [z.ZodNever]
-      ? z.ZodOptional<z.ZodUnknown>
-      : z.ZodOptional<Data>;
-  }>;
-
-export interface NewStatusDetailsZFunction {
-  <Data extends z.ZodType>(data: Data): NewStatusDetailsZodObject<Data>;
-  <Data extends z.ZodType = z.ZodNever>(data?: Data): NewStatusDetailsZodObject<Data>;
-}
-
-export const newStatusDetailsZ: NewStatusDetailsZFunction = <Data extends z.ZodType>(
-  data?: Data,
-) =>
-  z.object({
-    task: keyZ.optional(),
-    running: z.boolean(),
-    cmd: z.string().optional(),
-    data: (data ?? z.unknown()).optional(),
-  });
-export type NewStatusDetails<Data extends z.ZodType = z.ZodNever> = {
-  task?: Key;
-  running: boolean;
-  cmd?: string;
+  cmd: string;
+  configHash: string;
+  rack: rack.Key;
 } & ([Data] extends [z.ZodNever] ? {} : { data?: z.infer<Data> });
 
 /** Command is a command to execute on a task in the Driver system. */
@@ -84,22 +79,38 @@ export const commandZ = z.object({
   type: z.string(),
   /** key is a unique identifier for this command instance. */
   key: z.string(),
+  /**
+   * configHash is the config hash the sender wants running. Empty when the sender does
+   * not know it. The Driver reuses its live instance when the hash matches and
+   * redeploys when it differs.
+   */
+  configHash: z.string().default(""),
   /** args contains optional arguments for the command. */
-  args: caseconv.preserveCase(zod.nullToUndefined(record.unknownZ())),
+  args: caseconv.preserveCase(record.unknownZ().default(() => ({}))),
 });
 export interface Command extends z.infer<typeof commandZ> {}
 
+export const persistConfigZ = startConfigZ.extend({
+  dataSavingDisabled: z.boolean().default(false),
+});
+export interface PersistConfig extends z.infer<typeof persistConfigZ> {}
+
 export const statusZ = <Data extends z.ZodType = z.ZodNever>(data?: Data) =>
   status.statusZ({ details: statusDetailsZ(data) });
 export type Status<Data extends z.ZodType = z.ZodNever> = z.infer<
   ReturnType<typeof statusZ<Data>>
 >;
 
-export const newStatusZ = <Data extends z.ZodType = z.ZodNever>(data?: Data) =>
-  status.newZ({ details: newStatusDetailsZ(data) });
-export type NewStatus<Data extends z.ZodType = z.ZodNever> = z.infer<
-  ReturnType<typeof newStatusZ<Data>>
->;
+export const readConfigZ = persistConfigZ.extend({
+  sampleRate: z.number().default(10),
+  streamRate: z.number().default(5),
+});
+export interface ReadConfig extends z.infer<typeof readConfigZ> {}
+
+export const writeConfigZ = persistConfigZ.extend({
+  device: device.keyZ.default(""),
+});
+export interface WriteConfig extends z.infer<typeof writeConfigZ> {}
 
 export interface PayloadSchemas<
   Type extends z.ZodType<string> = z.ZodType<string>,
@@ -121,50 +132,32 @@ export const payloadZ = <
   statusData,
 }: Partial<PayloadSchemas<Type, Config, StatusData>> = {}) =>
   z.object({
-    key: keyZ,
+    key: keyZ.default(uuid.create),
+    rack: rack.keyZ.default(0),
     name: z.string(),
     type: type ?? z.string(),
-    config: config ?? record.nullishToEmpty(),
-    internal: z.boolean().optional(),
-    snapshot: z.boolean().optional(),
+    config: config ?? record.unknownZ().default(() => ({})),
+    configHash: z.string().default(""),
+    internal: z.boolean().default(false),
+    snapshot: z.boolean().default(false),
     status: status.statusZ({ details: statusDetailsZ(statusData) }).optional(),
   });
 export interface Payload<S extends PayloadSchemas = PayloadSchemas> {
   key: Key;
+  rack: rack.Key;
   name: string;
   type: z.infer<S["type"]>;
   config: z.infer<S["config"]>;
-  internal?: boolean;
-  snapshot?: boolean;
+  configHash: string;
+  internal: boolean;
+  snapshot: boolean;
   status?: Status<S["statusData"]>;
 }
-
-export interface NewSchemas<
-  Type extends z.ZodType<string> = z.ZodType<string>,
-  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
-  StatusData extends z.ZodType = z.ZodType,
-> {
-  type: Type;
-  config: Config;
-  statusData: StatusData;
-}
-
-export const newZ = <
-  Type extends z.ZodType<string> = z.ZodString,
-  Config extends z.ZodType<record.Unknown> = z.ZodType<record.Unknown>,
-  StatusData extends z.ZodType = z.ZodNever,
->({ type, config, statusData }: Partial<NewSchemas<Type, Config, StatusData>> = {}) =>
-  payloadZ({ type, config, statusData })
-    .omit({ internal: true, snapshot: true, status: true })
-    .partial({ key: true })
-    .extend({
-      status: status.newZ({ details: newStatusDetailsZ(statusData) }).optional(),
-    });
-export type New<S extends NewSchemas = NewSchemas> = optional.Optional<
-  Omit<Payload<S>, "internal" | "snapshot" | "status">,
-  "key"
+export type New<S extends PayloadSchemas = PayloadSchemas> = optional.Optional<
+  Omit<Payload<S>, "status">,
+  "key" | "rack" | "configHash" | "internal" | "snapshot"
 > & {
-  status?: NewStatus<S["statusData"]>;
+  status?: status.New<ReturnType<typeof statusDetailsZ>>;
 };
 
 export const ontologyID = ontology.createIDFactory<Key>("task");

package/src/testutil/access.ts

@@ -7,14 +7,42 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { id } from "@synnaxlabs/x";
+import { array, errors, id } from "@synnaxlabs/x";
 
 import { policy } from "@/access/policy";
 import { role } from "@/access/role";
 import type Synnax from "@/client";
+import { AccessDeniedError, NotFoundError } from "@/errors";
 import { createTestClient } from "@/testutil/client";
+import { user } from "@/user";
 
-export const createTestClientWithPolicy = async (client: Synnax, pol: policy.New) => {
+/** Reports whether the error, or any error in its cause chain, is an access denial. */
+const isDenial = (err: unknown): boolean =>
+  AccessDeniedError.matches(err) ||
+  (err instanceof Error && err.cause != null && isDenial(err.cause));
+
+/**
+ * Connects as a new user and primes its policy cache. Denials are tolerated: the Core
+ * refuses restricted subjects by design, and the change-stream refusal logs after
+ * teardown, which vitest counts as an unhandled error.
+ */
+const connectAs = async (username: string, key: user.Key) => {
+  const client = createTestClient({
+    username,
+    password: "test",
+    onInternalError: (err) => {
+      if (!isDenial(err)) console.error(err);
+    },
+  });
+  try {
+    await client.access.policies.retrieveForSubject(user.ontologyID(key));
+  } catch (err) {
+    if (!isDenial(err)) throw errors.fromUnknown(err);
+  }
+  return client;
+};
+
+const createUser = async (client: Synnax) => {
   const username = id.create();
   const u = await client.users.create({
     username,
@@ -22,13 +50,81 @@ export const createTestClientWithPolicy = async (client: Synnax, pol: policy.New
     firstName: "test",
     lastName: "test",
   });
-  const p = await client.access.policies.create(pol);
+  return { username, key: u.key };
+};
+
+/**
+ * Creates a client authenticated as a new user holding a role that carries the
+ * policies. Pass several to grant different actions on different objects, which one
+ * policy cannot express.
+ */
+export const createTestClientWithPolicy = async (
+  client: Synnax,
+  pol: policy.New | policy.New[],
+) => {
+  const u = await createUser(client);
+  const policies = await Promise.all(
+    array.toArray(pol).map(async (p) => await client.access.policies.create(p)),
+  );
   const r = await client.access.roles.create({
     name: "test",
     description: "test",
   });
-  await client.ontology.addChildren(role.ontologyID(r.key), policy.ontologyID(p.key));
+  await client.ontology.addChildren(
+    role.ontologyID(r.key),
+    ...policies.map(({ key }) => policy.ontologyID(key)),
+  );
   await client.access.roles.assign({ user: u.key, role: r.key });
-  const userClient = createTestClient({ username, password: "test" });
-  return userClient;
+  return await connectAs(u.username, u.key);
 };
+
+/** The roles the Core provisions on startup. */
+export const BUILT_IN_ROLES = [
+  "Owner",
+  "Engineer",
+  "Host",
+  "Operator",
+  "Viewer",
+] as const;
+
+export type BuiltInRole = (typeof BUILT_IN_ROLES)[number];
+
+/**
+ * Creates a client authenticated as a new user holding one of the Core's built-in
+ * roles, for exercising a real role's permission set instead of a synthetic policy.
+ * @param name - The built-in role to assign.
+ * @throws {NotFoundError} if the Core provisions no role under the name.
+ */
+export const createTestClientWithRole = async (
+  client: Synnax,
+  name: BuiltInRole,
+): Promise<Synnax> => {
+  const roles = await client.access.roles.retrieve({});
+  const r = roles.find((r) => r.name === name);
+  if (r == null) throw new NotFoundError(`no built-in role named ${name}`);
+  const u = await createUser(client);
+  await client.access.roles.assign({ user: u.key, role: r.key });
+  return await connectAs(u.username, u.key);
+};
+
+/**
+ * Caches one client per built-in role, so a spec covering many roles pays the user
+ * creation cost once each. Construct one per spec file.
+ */
+export class RoleClients {
+  private readonly client: Synnax;
+  private readonly byRole = new Map<BuiltInRole, Promise<Synnax>>();
+
+  constructor(client: Synnax) {
+    this.client = client;
+  }
+
+  /** Returns a client authenticated as a user holding the role. */
+  async get(name: BuiltInRole): Promise<Synnax> {
+    const existing = this.byRole.get(name);
+    if (existing != null) return await existing;
+    const created = createTestClientWithRole(this.client, name);
+    this.byRole.set(name, created);
+    return await created;
+  }
+}

package/src/testutil/channels.ts

@@ -30,6 +30,24 @@ export const newIndexedPair = async (
   return [index, data];
 };
 
+export const newIndexedBoolPair = async (
+  client: Synnax,
+): Promise<[channel.Channel, channel.Channel]> => {
+  const index = await client.channels.create({
+    leaseholder: 1,
+    name: id.create(),
+    dataType: DataType.TIMESTAMP,
+    isIndex: true,
+  });
+  const data = await client.channels.create({
+    leaseholder: 1,
+    name: id.create(),
+    dataType: DataType.BOOLEAN,
+    index: index.key,
+  });
+  return [index, data];
+};
+
 export const newVirtualChannel = async (client: Synnax): Promise<channel.Channel> => {
   const ch = await client.channels.create({
     name: id.create(),
@@ -38,3 +56,14 @@ export const newVirtualChannel = async (client: Synnax): Promise<channel.Channel
   });
   return ch;
 };
+
+export const newVirtualBoolChannel = async (
+  client: Synnax,
+): Promise<channel.Channel> => {
+  const ch = await client.channels.create({
+    name: id.create(),
+    dataType: DataType.BOOLEAN,
+    virtual: true,
+  });
+  return ch;
+};

package/src/testutil/client.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { TimeSpan } from "@synnaxlabs/x";
+import { afterAll } from "vitest";
 
 import Synnax, { type SynnaxParams } from "@/client";
 
@@ -23,5 +24,29 @@ export const TEST_CLIENT_PARAMS: SynnaxParams = {
   },
 };
 
-export const createTestClient = (params?: Partial<SynnaxParams>): Synnax =>
-  new Synnax({ ...TEST_CLIENT_PARAMS, ...params });
+// A hook registered mid-test is silently dropped by vitest, so per-client afterAll
+// calls leak clients created inside test bodies. This module-level hook registers
+// during spec collection (import time) and covers every call site.
+const openClients: Synnax[] = [];
+// Awaited so every close finishes before vitest tears down the worker; a close
+// still in flight at teardown races its logging against the closing RPC channel.
+afterAll(async () => {
+  const results = await Promise.allSettled(openClients.map((client) => client.close()));
+  const failures = results.filter((result) => result.status === "rejected");
+  if (failures.length > 0)
+    throw new AggregateError(
+      failures.map((failure) => failure.reason),
+      "failed to close test clients",
+    );
+});
+
+/**
+ * Creates a client connected to the local test cluster. The client is closed
+ * automatically once every test in the current spec file has finished, so callers do
+ * not need to close it themselves.
+ */
+export const createTestClient = (params?: Partial<SynnaxParams>): Synnax => {
+  const client = new Synnax({ ...TEST_CLIENT_PARAMS, ...params });
+  openClients.push(client);
+  return client;
+};

package/src/testutil/connection.ts

@@ -0,0 +1,47 @@
+// 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 { TimeSpan } from "@synnaxlabs/x";
+
+import { type connection } from "@/connection";
+
+/** Resolves once the handle's status satisfies the predicate. */
+export const waitForStatus = async (
+  handle: connection.Handle,
+  predicate: (status: connection.Status) => boolean,
+  timeout: TimeSpan = TimeSpan.seconds(5),
+): Promise<connection.Status> => {
+  if (predicate(handle.status)) return handle.status;
+  return await new Promise<connection.Status>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      detach();
+      reject(new Error("timed out waiting for connection status"));
+    }, timeout.milliseconds);
+    const detach = handle.onChange((status) => {
+      if (!predicate(status)) return;
+      clearTimeout(timer);
+      detach();
+      resolve(status);
+    });
+  });
+};
+
+/**
+ * Resolves once the handle's change stream is live, so every later cluster write
+ * reaches the client's cache.
+ */
+export const waitForStreamLive = async (
+  handle: connection.Handle,
+  timeout?: TimeSpan,
+): Promise<connection.Status> =>
+  await waitForStatus(
+    handle,
+    ({ variant, details }) => variant === "success" && details.streamLive,
+    timeout,
+  );

package/src/testutil/index.ts

@@ -0,0 +1,17 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * from "@/testutil/access";
+export * from "@/testutil/channels";
+export * from "@/testutil/client";
+export * from "@/testutil/connection";
+export * from "@/testutil/panels";
+export * from "@/testutil/proxy";
+export * from "@/testutil/query";
+export * from "@/testutil/telem";

package/src/testutil/panels.ts

@@ -0,0 +1,26 @@
+// 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 { id } from "@synnaxlabs/x";
+
+import type Synnax from "@/client";
+import { type ontology } from "@/ontology";
+import { project } from "@/project";
+
+/**
+ * Creates a throwaway project and returns its ontology ID. Panel creation requires a
+ * parent, so tests that mint panels directly parent them here.
+ */
+export const createPanelParent = async (client: Synnax): Promise<ontology.ID> => {
+  const proj = await client.projects.create({
+    name: `project-${id.create()}`,
+    layout: {},
+  });
+  return project.ontologyID(proj.key);
+};

package/src/testutil/proxy.ts

@@ -0,0 +1,106 @@
+// 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 { connect, createServer, type Socket } from "node:net";
+
+import { type breaker, TimeSpan } from "@synnaxlabs/x";
+
+const DEFAULT_TARGET = { host: "localhost", port: 9090 };
+
+/**
+ * Retry policy for a client pointed at a severable proxy. A spec drives its own
+ * retries, so the client's must finish well inside one assertion budget: the
+ * default policy waits seconds per request and outlasts a single `expect.poll`
+ * attempt, which reports as a timeout rather than the real answer.
+ */
+export const FAST_RETRY: breaker.Config = {
+  baseInterval: TimeSpan.milliseconds(10),
+  maxInterval: TimeSpan.milliseconds(50),
+  scale: 1.5,
+};
+
+export interface SeverableProxyTarget {
+  host?: string;
+  port?: number;
+}
+
+export interface SeverableProxy {
+  /** Port the proxy accepts connections on. Point the client here. */
+  port: number;
+  /** Drops every live connection and refuses new ones, as if the cluster died. */
+  sever: () => Promise<void>;
+  /** Accepts connections again on the same port. */
+  restore: () => Promise<void>;
+  /** Shuts the proxy down for good. */
+  close: () => Promise<void>;
+}
+
+/**
+ * Creates a TCP proxy in front of the live test cluster so specs can simulate
+ * cluster downtime without touching the cluster itself. Connect a client to
+ * the returned port, then sever() and restore() the link.
+ */
+export const createSeverableProxy = async (
+  target: SeverableProxyTarget = {},
+): Promise<SeverableProxy> => {
+  const { host, port } = { ...DEFAULT_TARGET, ...target };
+  const sockets = new Set<Socket>();
+  let severed = false;
+  const server = createServer((downstream) => {
+    // A connection the kernel accepted before the sever is still delivered after it,
+    // and forwarding it would let a request through a severed link.
+    if (severed) {
+      downstream.destroy();
+      return;
+    }
+    const upstream = connect(port, host);
+    sockets.add(downstream).add(upstream);
+    const destroy = (): void => {
+      sockets.delete(downstream);
+      sockets.delete(upstream);
+      downstream.destroy();
+      upstream.destroy();
+    };
+    downstream.on("error", destroy);
+    upstream.on("error", destroy);
+    downstream.on("close", destroy);
+    upstream.on("close", destroy);
+    downstream.pipe(upstream);
+    upstream.pipe(downstream);
+  });
+  const listen = async (listenPort: number): Promise<void> =>
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(listenPort, () => {
+        server.removeListener("error", reject);
+        resolve();
+      });
+    });
+  await listen(0);
+  const address = server.address();
+  if (address == null || typeof address === "string")
+    throw new Error("proxy failed to bind a port");
+  const boundPort = address.port;
+  const sever = async (): Promise<void> => {
+    severed = true;
+    const closed = new Promise<void>((resolve) => server.close(() => resolve()));
+    sockets.forEach((socket) => socket.destroy());
+    sockets.clear();
+    await closed;
+  };
+  return {
+    port: boundPort,
+    sever,
+    restore: async () => {
+      severed = false;
+      await listen(boundPort);
+    },
+    close: sever,
+  };
+};

package/src/testutil/query.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.
+
+import { query } from "@/query";
+
+export { isLive } from "@/query/query";
+
+/** Asserts the cached answer is live (present and not deleted) and returns it. */
+export const expectLive = <D extends query.Data>(
+  value: query.Cached<D> | undefined,
+): D => {
+  if (!query.isLive<D>(value)) throw new Error("expected a live cached answer");
+  return value;
+};
+
+/** Asserts the cached answer is a deletion and returns it. */
+export const expectDeleted = <D extends query.Data>(
+  value: query.Cached<D> | undefined,
+): query.Deleted<D> => {
+  if (!query.Deleted.matches<D>(value)) throw new Error("expected a deleted answer");
+  return value;
+};

package/src/testutil/telem.ts

@@ -7,7 +7,23 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { TimeStamp } from "@synnaxlabs/x";
+import { DataType, type Series, TimeStamp } from "@synnaxlabs/x";
+
+import { type framer } from "@/framer";
 
 export const secondsLinspace = (start: number, n: number): TimeStamp[] =>
   Array.from({ length: n }, (_, i) => start + i).map((n) => TimeStamp.seconds(n));
+
+const isRaw = (dt: DataType): boolean => dt.isVariable || dt.equals(DataType.UINT8);
+
+/** Narrows every numeric series to float32, anchoring bigints on an offset. Mirrors
+ * the transform the visualization layer injects for WebGL rendering. */
+export const glTransform: framer.Transform = {
+  resolveDataType: (dt: DataType) => (isRaw(dt) ? dt : DataType.FLOAT32),
+  convert: (series: Series, offset) => {
+    if (isRaw(series.dataType)) return series;
+    if (offset == null && series.dataType.usesBigInt && series.length > 0)
+      offset = BigInt(series.data[0]);
+    return series.convert(DataType.FLOAT32, offset);
+  },
+};