@synnaxlabs/client 0.54.2 → 0.56.0

package/src/actions/actions.spec.ts

@@ -0,0 +1,229 @@
+// 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 Draft, produce } from "immer";
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+
+import { actions } from "@/actions";
+
+interface DemoState {
+  name: string;
+  items: { key: string; value: number }[];
+}
+
+type DemoAction =
+  | { type: "rename"; payload: { name: string } }
+  | { type: "set_item"; payload: { key: string; value: number } }
+  | { type: "remove_item"; payload: { key: string } };
+
+const renameAction = (name: string): DemoAction => ({
+  type: "rename",
+  payload: { name },
+});
+const setItemAction = (key: string, value: number): DemoAction => ({
+  type: "set_item",
+  payload: { key, value },
+});
+const removeItemAction = (key: string): DemoAction => ({
+  type: "remove_item",
+  payload: { key },
+});
+
+const reduceOne = (
+  draft: Draft<DemoState>,
+  action: DemoAction,
+): actions.HandlerResult<DemoAction> => {
+  switch (action.type) {
+    case "rename": {
+      const prev = draft.name;
+      draft.name = action.payload.name;
+      return { inverse: [renameAction(prev)], targets: ["name"] };
+    }
+    case "set_item": {
+      const idx = draft.items.findIndex((i) => i.key === action.payload.key);
+      if (idx === -1) {
+        draft.items.push(action.payload);
+        return {
+          inverse: [removeItemAction(action.payload.key)],
+          targets: [action.payload.key],
+        };
+      }
+      const prevValue = draft.items[idx].value;
+      draft.items[idx].value = action.payload.value;
+      return {
+        inverse: [setItemAction(action.payload.key, prevValue)],
+        targets: [action.payload.key],
+      };
+    }
+    case "remove_item": {
+      const idx = draft.items.findIndex((i) => i.key === action.payload.key);
+      if (idx === -1) return actions.NO_OP_RESULT;
+      const removed = draft.items[idx];
+      draft.items.splice(idx, 1);
+      return {
+        inverse: [setItemAction(removed.key, removed.value)],
+        targets: [removed.key],
+      };
+    }
+  }
+};
+
+const reduceAll = actions.createReduceAll(reduceOne);
+
+describe("snapshotDraft", () => {
+  it("Should return plain values unchanged", () => {
+    const v = { a: 1, b: [2, 3] };
+    expect(actions.snapshotDraft(v)).toBe(v);
+  });
+
+  it("Should freeze a draft into a plain object that survives the produce closure", () => {
+    const original = { items: [{ key: "a", value: 1 }] };
+    let captured: typeof original | undefined;
+    const next = produce(original, (draft) => {
+      captured = actions.snapshotDraft(draft.items[0]) as unknown as typeof original;
+      draft.items[0].value = 99;
+    });
+    expect(next.items[0].value).toBe(99);
+    expect(captured).toEqual({ key: "a", value: 1 });
+  });
+
+  it("Should preserve primitive values without wrapping", () => {
+    expect(actions.snapshotDraft(42)).toBe(42);
+    expect(actions.snapshotDraft("hello")).toBe("hello");
+    expect(actions.snapshotDraft(null)).toBe(null);
+  });
+});
+
+describe("NO_OP_RESULT", () => {
+  it("Should expose empty inverse and targets", () => {
+    expect(actions.NO_OP_RESULT.inverse).toHaveLength(0);
+    expect(actions.NO_OP_RESULT.targets).toHaveLength(0);
+  });
+});
+
+describe("createReduceAll", () => {
+  const initial: DemoState = { name: "before", items: [{ key: "a", value: 1 }] };
+
+  it("Should apply a single action and return the new state", () => {
+    const { next } = reduceAll(initial, [renameAction("after")]);
+    expect(next.name).toBe("after");
+    expect(initial.name).toBe("before");
+  });
+
+  it("Should accumulate inverses in reverse application order", () => {
+    const { inverse } = reduceAll(initial, [
+      renameAction("step-1"),
+      setItemAction("a", 2),
+      setItemAction("b", 7),
+    ]);
+    expect(inverse).toEqual([
+      removeItemAction("b"),
+      setItemAction("a", 1),
+      renameAction("before"),
+    ]);
+  });
+
+  it("Should round-trip state through forward then inverse application", () => {
+    const forward = [
+      renameAction("after"),
+      setItemAction("a", 2),
+      setItemAction("b", 7),
+    ];
+    const { next, inverse } = reduceAll(initial, forward);
+    const { next: roundtripped } = reduceAll(next, inverse);
+    expect(roundtripped).toEqual(initial);
+  });
+
+  it("Should de-duplicate targets across actions", () => {
+    const { targets } = reduceAll(initial, [
+      setItemAction("a", 5),
+      setItemAction("a", 6),
+      setItemAction("b", 7),
+    ]);
+    expect(targets).toHaveLength(2);
+    expect(targets).toEqual(expect.arrayContaining(["a", "b"]));
+  });
+
+  it("Should drop NO_OP_RESULT entries from the inverse list", () => {
+    const { inverse } = reduceAll(initial, [removeItemAction("missing")]);
+    expect(inverse).toHaveLength(0);
+  });
+
+  it("Should leave the source state untouched after produce", () => {
+    const before = JSON.parse(JSON.stringify(initial));
+    reduceAll(initial, [
+      renameAction("x"),
+      setItemAction("a", 99),
+      setItemAction("c", 3),
+    ]);
+    expect(initial).toEqual(before);
+  });
+});
+
+describe("scopedZ", () => {
+  const schema = actions.scopedZ(z.string(), z.object({ kind: z.string() }));
+
+  it("Should parse a fully-populated envelope", () => {
+    const parsed = schema.parse({
+      key: "abc",
+      dispatchKey: "dk",
+      seq: 42,
+      actions: [{ kind: "rename" }],
+    });
+    expect(parsed.key).toBe("abc");
+    expect(parsed.seq).toBe(42);
+    expect(parsed.actions).toEqual([{ kind: "rename" }]);
+  });
+
+  it("Should default seq to 0 when missing", () => {
+    const parsed = schema.parse({ key: "abc", dispatchKey: "dk", actions: [] });
+    expect(parsed.seq).toBe(0);
+  });
+
+  it("Should reject negative seq", () => {
+    expect(() =>
+      schema.parse({ key: "abc", dispatchKey: "dk", seq: -1, actions: [] }),
+    ).toThrow();
+  });
+
+  it("Should reject non-integer seq", () => {
+    expect(() =>
+      schema.parse({ key: "abc", dispatchKey: "dk", seq: 1.5, actions: [] }),
+    ).toThrow();
+  });
+
+  it("Should reject envelopes whose actions fail the inner schema", () => {
+    expect(() =>
+      schema.parse({
+        key: "abc",
+        dispatchKey: "dk",
+        actions: [{ kind: 7 }],
+      }),
+    ).toThrow();
+  });
+});
+
+describe("dispatchReqZ", () => {
+  const schema = actions.dispatchReqZ(z.string(), z.object({ kind: z.string() }));
+
+  it("Should parse a camelCase dispatchKey body", () => {
+    const parsed = schema.parse({
+      key: "abc",
+      dispatchKey: "dk",
+      actions: [{ kind: "x" }],
+    });
+    expect(parsed.dispatchKey).toBe("dk");
+    expect(parsed.actions).toEqual([{ kind: "x" }]);
+  });
+
+  it("Should reject a body missing dispatchKey", () => {
+    expect(() => schema.parse({ key: "abc", actions: [] })).toThrow();
+  });
+});

package/src/actions/actions.ts

@@ -0,0 +1,104 @@
+// 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 { current, type Draft, isDraft, produce } from "immer";
+import { z } from "zod";
+
+/**
+ * Result returned by a single per-variant action handler. `inverse` is the
+ * action sequence the undo stack should replay to revert the handler's effect.
+ * `targets` is the set of document keys the handler touched, used by consumers
+ * to invalidate undoables targeting overlapping resources when a remote
+ * session emits a competing action.
+ */
+export interface HandlerResult<A> {
+  inverse: A[];
+  targets: readonly string[];
+}
+
+/**
+ * NO_OP_RESULT is the zero-value HandlerResult. Return it from a handler that
+ * declined to mutate state (e.g. lookup miss) so it neither contributes to the
+ * undo stack nor invalidates undoables targeting the same resource.
+ */
+export const NO_OP_RESULT: HandlerResult<never> = { inverse: [], targets: [] };
+
+/**
+ * Result returned by a reduceAll application: the new state, the inverse
+ * sequence that reverts the whole batch, and the union of all targets touched.
+ */
+export interface ReduceAllResult<S, A> {
+  next: S;
+  inverse: A[];
+  targets: readonly string[];
+}
+
+/**
+ * Returns a plain-object snapshot of an Immer draft so the result is safe to
+ * embed in an action stored on the undo stack. Returns non-draft inputs
+ * unchanged. The non-draft passthrough exists because when a reducer applies
+ * multiple actions in one produce(), an earlier action's wholesale
+ * assignment leaves the slot as a plain object, so the next action would
+ * crash if it called `current` unconditionally.
+ */
+export const snapshotDraft = <T>(v: T): T => (isDraft(v) ? current(v as Draft<T>) : v);
+
+/**
+ * createReduceAll lifts a per-variant `reduceOne` switch into a batched
+ * reducer. The returned function applies each action against an Immer draft of
+ * `state` in order, accumulates the inverses in reverse application order so a
+ * single undo replays them correctly, and unions the touched targets.
+ */
+export const createReduceAll =
+  <S, A>(reduceOne: (draft: Draft<S>, action: A) => HandlerResult<A>) =>
+  (state: S, actions: A[]): ReduceAllResult<S, A> => {
+    const inverse: A[] = [];
+    const targetsSet = new Set<string>();
+    const next = produce(state, (draft) => {
+      for (const action of actions) {
+        const result = reduceOne(draft, action);
+        if (result.inverse.length > 0) inverse.unshift(...result.inverse);
+        for (const t of result.targets) targetsSet.add(t);
+      }
+    });
+    return { next, inverse, targets: Array.from(targetsSet) };
+  };
+
+/**
+ * scopedZ builds the schema for envelopes broadcast on the sy_<service>_set
+ * cluster signals channel. The framer's JSON codec runs snakeToCamel before
+ * handing the value to the schema, so `dispatchKey` and `seq` are camelCase
+ * here even though the server emits them as snake_case. `seq` defaults to 0 so
+ * frames from servers that predate the field stay parseable.
+ */
+export const scopedZ = <K extends z.ZodType, A extends z.ZodType>(
+  keyZ: K,
+  actionZ: A,
+) =>
+  z.object({
+    key: keyZ,
+    dispatchKey: z.string(),
+    seq: z.number().int().nonnegative().default(0),
+    actions: actionZ.array(),
+  });
+
+/**
+ * dispatchReqZ builds the request body schema for the per-service dispatch
+ * endpoint. Stays camelCase; the JSON codec runs camelToSnake on encode so the
+ * wire ends up snake_case without per-field conversion here.
+ */
+export const dispatchReqZ = <K extends z.ZodType, A extends z.ZodType>(
+  keyZ: K,
+  actionZ: A,
+) =>
+  z.object({
+    key: keyZ,
+    dispatchKey: z.string(),
+    actions: actionZ.array(),
+  });

package/src/actions/external.ts

@@ -0,0 +1,10 @@
+// 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 "@/actions/actions";

package/src/actions/index.ts

@@ -0,0 +1,10 @@
+// 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 * as actions from "@/actions/external";

package/src/arc/arc.spec.ts

@@ -0,0 +1,44 @@
+// 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 { describe, expect, it } from "vitest";
+
+import { type arc } from "@/arc";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+const newTextArc = (name: string): arc.New => ({
+  name,
+  mode: "text",
+  graph: {
+    nodes: [],
+    edges: [],
+    viewport: { position: { x: 0, y: 0 }, zoom: 1 },
+    functions: [],
+  },
+  text: { raw: "" },
+});
+
+describe("arc", () => {
+  describe("retrieve", () => {
+    it("should retrieve arcs by search term", async () => {
+      const prefix = `searchable-arc-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.arcs.create(names.map((name) => newTextArc(name)));
+      await expect
+        .poll(async () => {
+          const results = await client.arcs.retrieve({ searchTerm: prefix });
+          return results.map((a) => a.name).sort();
+        })
+        .toEqual(names);
+    });
+  });
+});

package/src/arc/client.ts

@@ -8,7 +8,6 @@
 // included in the file licenses/APL.txt.
 
 import {
-  sendRequired,
   type Stream,
   type StreamClient,
   type UnaryClient,
@@ -77,8 +76,7 @@ export class Client {
   async create(arcs: New[]): Promise<Arc[]>;
   async create(arcs: New | New[]): Promise<Arc | Arc[]> {
     const isMany = Array.isArray(arcs);
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/arc/create",
       { arcs: array.toArray(arcs) },
       createReqZ,
@@ -91,8 +89,7 @@ export class Client {
   async retrieve(args: RetrieveArgs): Promise<Arc[]>;
   async retrieve(args: RetrieveArgs): Promise<Arc | Arc[]> {
     const isSingle = "key" in args || "name" in args;
-    const res = await sendRequired(
-      this.client,
+    const res = await this.client.send(
       "/arc/retrieve",
       args,
       retrieveArgsZ,
@@ -103,8 +100,7 @@ export class Client {
   }
 
   async delete(keys: Key | Key[]): Promise<void> {
-    await sendRequired(
-      this.client,
+    await this.client.send(
       "/arc/delete",
       { keys: array.toArray(keys) },
       deleteReqZ,

package/src/arc/compiler/types.gen.ts

@@ -9,6 +9,7 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
+import { record } from "@synnaxlabs/x";
 import { z } from "zod";
 
 /**
@@ -22,6 +23,6 @@ export const outputZ = z.object({
    * outputMemoryBases contains memory base addresses for multi-output functions, mapping
    * function keys to their base addresses.
    */
-  outputMemoryBases: z.record(z.string(), z.uint32()),
+  outputMemoryBases: record.nullishToEmpty(z.string(), z.uint32()),
 });
 export interface Output extends z.infer<typeof outputZ> {}

package/src/arc/ir/types.gen.ts

@@ -9,7 +9,7 @@
 
 // Code generated by Oracle. DO NOT EDIT.
 
-import { array, zod } from "@synnaxlabs/x";
+import { array, record, zod } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { types } from "@/arc/types";
@@ -21,6 +21,20 @@ export enum EdgeKind {
 }
 export const edgeKindZ = z.enum(EdgeKind);
 
+export enum ScopeMode {
+  unspecified = 0,
+  parallel = 1,
+  sequential = 2,
+}
+export const scopeModeZ = z.enum(ScopeMode);
+
+export enum Liveness {
+  unspecified = 0,
+  always = 1,
+  gated = 2,
+}
+export const livenessZ = z.enum(Liveness);
+
 /** Handle is a reference to a specific parameter on a specific node in the dataflow graph. */
 export const handleZ = z.object({
   /** node is the node identifier. */
@@ -47,13 +61,13 @@ export const nodeZ = z.object({
   /** type is the function type being instantiated. */
   type: z.string(),
   /** config contains configuration parameter values. */
-  config: types.paramsZ.optional(),
+  config: types.paramsZ,
   /** inputs contains input parameter type signatures. */
-  inputs: types.paramsZ.optional(),
+  inputs: types.paramsZ,
   /** outputs contains output parameter type signatures. */
-  outputs: types.paramsZ.optional(),
+  outputs: types.paramsZ,
   /** channels contains channel read/write mappings. */
-  channels: types.channelsZ.optional(),
+  channels: types.channelsZ,
 });
 export interface Node extends z.infer<typeof nodeZ> {}
 
@@ -62,13 +76,10 @@ export const authoritiesZ = z.object({
   /** default is the default authority for all write channels not explicitly listed. */
   default: zod.uint8.optional(),
   /** channels maps channel keys to their specific authority values. */
-  channels: z.record(z.uint32(), zod.uint8).optional(),
+  channels: record.nullishToEmpty(z.uint32(), zod.uint8),
 });
 export interface Authorities extends z.infer<typeof authoritiesZ> {}
 
-export const stratumZ = array.nullishToEmpty(z.string());
-export type Stratum = z.infer<typeof stratumZ>;
-
 /** Edge is a dataflow connection between node parameters in the Arc graph. */
 export const edgeZ = z.object({
   /** source is the source node parameter producing data. */
@@ -76,10 +87,22 @@ export const edgeZ = z.object({
   /** target is the target node parameter consuming data. */
   target: handleZ,
   /** kind defines execution semantics for this connection. */
-  kind: edgeKindZ.optional(),
+  kind: edgeKindZ,
 });
 export interface Edge extends z.infer<typeof edgeZ> {}
 
+/** Transition is a declarative state-transition rule on a sequential Scope. */
+export const transitionZ = z.object({
+  /** on is the dataflow handle whose truthy value fires this transition. */
+  on: handleZ,
+  /**
+   * targetKey is the sibling step key to activate. Null when the transition
+   * exits the scope, yielding to the parent.
+   */
+  targetKey: z.string().optional(),
+});
+export interface Transition extends z.infer<typeof transitionZ> {}
+
 /**
  * Function is a function template definition with typed parameters, serving as a
  * blueprint for node instantiation.
@@ -90,22 +113,19 @@ export const functionZ = z.object({
   /** body is raw source code for user-defined functions. */
   body: bodyZ.optional(),
   /** config contains configuration parameter definitions. */
-  config: types.paramsZ.optional(),
+  config: types.paramsZ,
   /** inputs contains input parameter definitions. */
-  inputs: types.paramsZ.optional(),
+  inputs: types.paramsZ,
   /** outputs contains output parameter definitions. */
-  outputs: types.paramsZ.optional(),
+  outputs: types.paramsZ,
   /** channels contains channel read/write declarations. */
-  channels: types.channelsZ.optional(),
+  channels: types.channelsZ,
 });
 export interface Function extends z.infer<typeof functionZ> {}
 
 export const nodesZ = array.nullishToEmpty(nodeZ);
 export type Nodes = z.infer<typeof nodesZ>;
 
-export const strataZ = array.nullishToEmpty(stratumZ);
-export type Strata = z.infer<typeof strataZ>;
-
 export const edgesZ = array.nullishToEmpty(edgeZ);
 export type Edges = z.infer<typeof edgesZ>;
 
@@ -113,36 +133,65 @@ export const functionsZ = array.nullishToEmpty(functionZ);
 export type Functions = z.infer<typeof functionsZ>;
 
 /**
- * Stage is a stage in a sequence state machine, containing active nodes and their
- * execution stratification.
+ * Member is a tagged union representing a single child of a Scope. Exactly one
+ * of nodeKey or scope is set. The member's lookup key (used as the
+ * target of `=> name` transitions) is derived from the set variant via
+ * Member.key().
  */
-export const stageZ = z.object({
-  /** key is the stage identifier. */
-  key: z.string(),
-  /** nodes contains node keys active in this stage. */
-  nodes: array.nullishToEmpty(z.string()),
-  /** strata contains execution stratification for nodes in this stage. */
-  strata: strataZ,
+export interface Member {
+  nodeKey?: string;
+  scope?: Scope;
+}
+export const memberZ: z.ZodType<Member> = z.object({
+  /**
+   * nodeKey is the key of the referenced node in IR.nodes. Null when this
+   * member is a nested scope.
+   */
+  nodeKey: z.string().optional(),
+  /** scope is set when this member is a nested scope. */
+  get scope() {
+    return scopeZ.optional();
+  },
 });
-export interface Stage extends z.infer<typeof stageZ> {}
 
 /**
- * Sequence is a state machine defining ordered stages of execution, where entry point
- * is always the first stage.
+ * Scope is the unified Layer 2 execution primitive. Parameterized by mode
+ * (parallel or sequential) and liveness (always-live or gated). Parallel
+ * scopes organize members into strata; sequential scopes run one step
+ * at a time and advance via transitions.
  */
-export const sequenceZ = z.object({
-  /** key is the sequence identifier. */
+export interface Scope {
+  key: string;
+  mode: ScopeMode;
+  liveness: Liveness;
+  activation?: Handle;
+  strata: Members[];
+  steps: Members;
+  transitions: Transition[];
+}
+export const scopeZ: z.ZodType<Scope> = z.object({
+  /** key is the scope identifier. */
   key: z.string(),
-  /** stages contains ordered stages in this sequence. */
-  stages: array.nullishToEmpty(stageZ),
+  /** mode defines whether this scope runs steps in parallel or sequentially. */
+  mode: scopeModeZ,
+  /** liveness defines whether this scope is continuously active or must be activated. */
+  liveness: livenessZ,
+  /** activation is the handle whose truthy value activates a gated scope. Unset for always-live scopes. */
+  activation: handleZ.optional(),
+  /**
+   * strata contains stratified execution layers for parallel scopes. Empty
+   * for sequential scopes. Stratum N depends only on strata 0 to N-1.
+   */
+  get strata() {
+    return array.nullishToEmpty(membersZ);
+  },
+  /** steps contains ordered steps for sequential scopes. Empty for parallel scopes. */
+  get steps() {
+    return membersZ;
+  },
+  /** transitions contains state-transition rules for sequential scopes. Empty for parallel scopes. */
+  transitions: array.nullishToEmpty(transitionZ),
 });
-export interface Sequence extends z.infer<typeof sequenceZ> {}
-
-export const stagesZ = array.nullishToEmpty(stageZ);
-export type Stages = z.infer<typeof stagesZ>;
-
-export const sequencesZ = array.nullishToEmpty(sequenceZ);
-export type Sequences = z.infer<typeof sequencesZ>;
 
 /**
  * IR is the intermediate representation of an Arc program as a dataflow graph
@@ -151,16 +200,21 @@ export type Sequences = z.infer<typeof sequencesZ>;
  */
 export const irZ = z.object({
   /** functions contains function template definitions. */
-  functions: functionsZ.optional(),
+  functions: functionsZ,
   /** nodes contains node instantiations. */
-  nodes: nodesZ.optional(),
+  nodes: nodesZ,
   /** edges contains dataflow connections. */
-  edges: edgesZ.optional(),
-  /** strata contains execution stratification layers. */
-  strata: strataZ.optional(),
-  /** sequences contains state machine definitions. */
-  sequences: sequencesZ.optional(),
+  edges: edgesZ,
   /** authorities contains the static authority declarations for this program. */
-  authorities: authoritiesZ.optional(),
+  authorities: authoritiesZ,
+  /**
+   * root is the top-level execution context. The root is always a
+   * parallel, always-live Scope whose strata mix module-scope
+   * reactive flow with top-level gated scopes.
+   */
+  root: scopeZ,
 });
 export interface IR extends z.infer<typeof irZ> {}
+
+export const membersZ = array.nullishToEmpty(memberZ);
+export type Members = z.infer<typeof membersZ>;