@snaptrude/plugin-core 0.9.17 → 0.9.18-edgesetbacks-20261021.1

package/src/host-utils.ts

@@ -1,68 +1,68 @@
-import type { PluginApi } from "./api"
-import type { ErrorEnvelope } from "./errors"
-
-// -- Type Utilities for inferring method paths from the class hierarchy ------
-
-/**
- * UnionToIntersection is a type utility that converts a union type to an intersection type.
- */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I,
-) => void
-  ? I
-  : never
-
-type Flatten<T> = { [K in keyof T]: T[K] }
-
-/**
- * The full parameter tuple of a method — the positional-args transport forwards
- * the whole argument list (`[]` for no-arg methods).
- */
-type MethodArgs<F extends (...args: any[]) => any> = Parameters<F>
-
-type MethodReturn<F extends (...args: any[]) => any> = Awaited<ReturnType<F>>
-
-/**
- * Recursively walks a type tree and produces a union of single-key Records
- * for every leaf method, using dot-separated paths as keys.
- */
-type ExtractMethodPaths<T, Prefix extends string = ""> = {
-  [K in keyof T & string]: T[K] extends (...args: any[]) => any
-    ? Record<
-        `${Prefix}${K}`,
-        { args: MethodArgs<T[K]>; return: MethodReturn<T[K]> }
-      >
-    : T[K] extends object
-      ? ExtractMethodPaths<T[K], `${Prefix}${K}.`>
-      : never
-}[keyof T & string]
-
-// -- Plugin API method map ---------------------------------------------------
-
-/**
- * Maps every plugin API method path to its argument and return types.
- * Automatically inferred from the PluginApi abstract class hierarchy.
- */
-export type PluginApiMethodMap = Flatten<
-  UnionToIntersection<ExtractMethodPaths<PluginApi>>
->
-
-export type PluginApiMethod = keyof PluginApiMethodMap
-
-export type PluginApiCallPayload<M extends PluginApiMethod = PluginApiMethod> = {
-  method: M
-  /** Positional argument tuple, spread back into the method host-side. */
-  args: PluginApiMethodMap[M]["args"]
-}
-
-export type PluginApiCallResult<M extends PluginApiMethod> =
-  PluginApiMethodMap[M]["return"]
-
-export type PluginApiCallWrappedResult<M extends PluginApiMethod> = {
-  success: boolean;
-  data?: PluginApiCallResult<M>;
-  /** Legacy failure message — kept verbatim for already-published plugins. */
-  error?: string;
-  /** Structured failure (hosts ≥ error-envelope rollout). Present iff `success` is false. */
-  errorInfo?: ErrorEnvelope;
+import type { PluginApi } from "./api"
+import type { ErrorEnvelope } from "./errors"
+
+// -- Type Utilities for inferring method paths from the class hierarchy ------
+
+/**
+ * UnionToIntersection is a type utility that converts a union type to an intersection type.
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never
+
+type Flatten<T> = { [K in keyof T]: T[K] }
+
+/**
+ * The full parameter tuple of a method — the positional-args transport forwards
+ * the whole argument list (`[]` for no-arg methods).
+ */
+type MethodArgs<F extends (...args: any[]) => any> = Parameters<F>
+
+type MethodReturn<F extends (...args: any[]) => any> = Awaited<ReturnType<F>>
+
+/**
+ * Recursively walks a type tree and produces a union of single-key Records
+ * for every leaf method, using dot-separated paths as keys.
+ */
+type ExtractMethodPaths<T, Prefix extends string = ""> = {
+  [K in keyof T & string]: T[K] extends (...args: any[]) => any
+    ? Record<
+        `${Prefix}${K}`,
+        { args: MethodArgs<T[K]>; return: MethodReturn<T[K]> }
+      >
+    : T[K] extends object
+      ? ExtractMethodPaths<T[K], `${Prefix}${K}.`>
+      : never
+}[keyof T & string]
+
+// -- Plugin API method map ---------------------------------------------------
+
+/**
+ * Maps every plugin API method path to its argument and return types.
+ * Automatically inferred from the PluginApi abstract class hierarchy.
+ */
+export type PluginApiMethodMap = Flatten<
+  UnionToIntersection<ExtractMethodPaths<PluginApi>>
+>
+
+export type PluginApiMethod = keyof PluginApiMethodMap
+
+export type PluginApiCallPayload<M extends PluginApiMethod = PluginApiMethod> = {
+  method: M
+  /** Positional argument tuple, spread back into the method host-side. */
+  args: PluginApiMethodMap[M]["args"]
+}
+
+export type PluginApiCallResult<M extends PluginApiMethod> =
+  PluginApiMethodMap[M]["return"]
+
+export type PluginApiCallWrappedResult<M extends PluginApiMethod> = {
+  success: boolean;
+  data?: PluginApiCallResult<M>;
+  /** Legacy failure message — kept verbatim for already-published plugins. */
+  error?: string;
+  /** Structured failure (hosts ≥ error-envelope rollout). Present iff `success` is false. */
+  errorInfo?: ErrorEnvelope;
 }

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from "./api"
-export * from "./types"
-export * from "./host-utils"
-export * from "./handles"
-export * from "./massParameters"
-export * from "./massParameters.ops"
-export * from "./errors"
+export * from "./api"
+export * from "./types"
+export * from "./host-utils"
+export * from "./handles"
+export * from "./massParameters"
+export * from "./massParameters.ops"
+export * from "./errors"

package/src/massParameters.ops.ts

@@ -1,246 +1,246 @@
-import * as z from "zod"
-import {
-  ContourRecord,
-  CurveRecord,
-  LoftOptions,
-  MAX_LOFT_SECTIONS,
-  MAX_PATH_CURVES,
-  MAX_SWEEP_PATH_POINTS,
-  SweepAlongCurveRecordOptions,
-  SweepOptions,
-  XYZ,
-} from "./massParameters"
-import type { CurveKind, SurfaceKind } from "./massParameters"
-
-/**
- * The **operation half** of a mass creation-parameter record: which edge or
- * face of the recipe's solid a kernel step used, the step itself, and the
- * values a `design.update.parameters` patch may carry.
- *
- * Split out of `massParameters.ts` so that each file stays under the size limit
- * at which the agent runtime still serves a type module in ONE whole read (the
- * record module alone had grown past it). Do not merge the two back. It is
- * re-exported from there and from the package root, so every import path keeps
- * working.
- *
- * Everything here is **pure JSON** by construction, exactly as in
- * {@linkcode MassParametersRecord}: plain objects, numbers and arrays only, one
- * `{x, y, z}` point shape, no class instances.
- */
-
-/** Maximum kernel operations chained onto one recipe. */
-export const MAX_OPERATIONS = 8
-/** Maximum edges one fillet/chamfer operation may select. */
-export const MAX_OPERATION_EDGES = 64
-/** Maximum faces one shell operation may open. */
-export const MAX_OPERATION_FACES = 32
-/** Maximum rows in a variable-fillet radius law. */
-export const MAX_FILLET_LAW_SAMPLES = 32
-
-// `XYZ` and the record schemas below are resolved through `z.lazy`: this module
-// and `massParameters.ts` re-export each other, and this one is evaluated first,
-// so their consts are not yet initialised while these schemas are built. The
-// closures run at parse time, when both modules are live.
-const At: z.ZodType<XYZ, XYZ> = z.lazy(() => XYZ)
-
-/**
- * Which EDGE of the input solid an operation used: its index in
- * `core.geom.query.brep.listEdges` order at authoring time, the indices of the
- * two faces it lies between, and its curve kind. This is topology, not
- * coordinates — it survives a scalar edit of the base recipe (which moves every
- * edge) and trips on a reorder or a topology change. Read-only: to blend a
- * different edge, re-select it on the new shape and re-apply the operation.
- */
-export type EdgeSelector = {
-  index: number
-  faces: [number, number]
-  curve: CurveKind
-  /** Where the edge sits INSIDE its solid: its midpoint in the record's own
-   *  frame, divided by the solid's bounding-box extent — a ratio per axis,
-   *  never a length, so it survives a scalar edit that scales the whole shape.
-   *  Written only when the discriminators above cannot tell two edges apart. A
-   *  tiebreak, never a coordinate fingerprint: a replay checks it within 0.02 of
-   *  the solid's own box and refuses on a miss — it never searches for a better
-   *  candidate. */
-  at?: XYZ
-}
-
-/**
- * Which FACE of the input solid an operation used: its index in
- * `core.geom.query.brep.listFaces` order, its surface kind, and the number of
- * edges in its outer loop. Read-only, like {@linkcode EdgeSelector}.
- */
-export type FaceSelector = {
-  index: number
-  kind: SurfaceKind
-  edgeCount: number
-  /** The face's centroid under the same normalisation and the same tiebreak
-   *  rule as {@linkcode EdgeSelector}'s `at` — written only where the
-   *  discriminators above cannot separate two faces, which on a freeform solid
-   *  (every face answers `"spline"`) is the common case. */
-  at?: XYZ
-}
-
-/** The input solid's topology at authoring time — the counts a replay checks first. */
-export type TopologyCounts = { faceCount: number; edgeCount: number }
-
-/**
- * One kernel operation applied to the base recipe's solid, in order. `input`
- * pins the topology the operation was authored against, so a base edit that
- * changes the topology is refused rather than mis-applied.
- *
- * Edit one by patching the whole list back:
- * `design.update.parameters(mass, { operations })`.
- */
-export type OperationRecord =
-  | {
-      op: "fillet"
-      edges: EdgeSelector[]
-      radius: number
-      /** Radius at the far end of the blend contour, internal length units — a
-       *  linear variable blend from `radius`. One edge, and never with `radii`. */
-      endRadius?: number
-      /** The blend's radius law instead: `position` is normalised arc length
-       *  along the blend contour (a ratio 0..1, never converted), `radius` is
-       *  internal length units. 2..32 rows, strictly increasing `position`.
-       *  One edge, and never with `endRadius`. */
-      radii?: { position: number; radius: number }[]
-      input: TopologyCounts
-    }
-  | { op: "chamfer"; edges: EdgeSelector[]; distance: number; input: TopologyCounts }
-  | { op: "shell"; openFaces: FaceSelector[]; thickness: number; input: TopologyCounts }
-  | { op: "offset"; distance: number; input: TopologyCounts }
-
-/**
- * One value of a `MassParametersPatch` — whatever a record's `values` key (or
- * `operations`) may hold. Each key you send replaces that value whole — a
- * scalar, a point, a list or a record (`contour`, `profile`, `sections`,
- * `path`, `options`, `operations`) alike — so send the complete value you read.
- */
-export type ParameterPatchValue =
-  | number
-  | XYZ
-  | XYZ[]
-  | ContourRecord
-  | ContourRecord[]
-  | CurveRecord[]
-  | LoftOptions
-  | SweepOptions
-  | SweepAlongCurveRecordOptions
-  | OperationRecord[]
-
-const FaceIndex = z.number().int().nonnegative()
-
-/** See {@linkcode EdgeSelector}. */
-export const EdgeSelector: z.ZodType<EdgeSelector, EdgeSelector> = z.strictObject({
-  index: FaceIndex,
-  faces: z.tuple([FaceIndex, FaceIndex]),
-  curve: z.enum(["line", "arc", "circle", "spline"]),
-  at: At.optional(),
-})
-
-/** See {@linkcode FaceSelector}. */
-export const FaceSelector: z.ZodType<FaceSelector, FaceSelector> = z.strictObject({
-  index: FaceIndex,
-  kind: z.enum(["plane", "cylinder", "cone", "sphere", "torus", "spline"]),
-  edgeCount: z.number().int().positive(),
-  at: At.optional(),
-})
-
-/** See {@linkcode TopologyCounts}. */
-export const TopologyCounts: z.ZodType<TopologyCounts, TopologyCounts> = z.strictObject({
-  faceCount: z.number().int().positive(),
-  edgeCount: z.number().int().positive(),
-})
-
-/** One row of a variable fillet's radius law. See {@linkcode OperationRecord}. */
-const FilletLawRow = z.strictObject({
-  position: z.number().finite().min(0).max(1),
-  radius: z.number().finite().positive(),
-})
-
-/**
- * See {@linkcode OperationRecord}.
- *
- * A variable fillet — `endRadius` or `radii` — names ONE edge: the law is a
- * property of the blend contour that edge belongs to, and `position` is measured
- * from that edge's start, so a second edge would have no origin. The two forms
- * are mutually exclusive and `radii` rows run strictly forward.
- */
-export const OperationRecord: z.ZodType<OperationRecord, OperationRecord> = z
-  .discriminatedUnion("op", [
-    z.strictObject({
-      op: z.literal("fillet"),
-      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
-      radius: z.number().finite().positive(),
-      endRadius: z.number().finite().positive().optional(),
-      radii: z.array(FilletLawRow).min(2).max(MAX_FILLET_LAW_SAMPLES).optional(),
-      input: TopologyCounts,
-    }),
-    z.strictObject({
-      op: z.literal("chamfer"),
-      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
-      distance: z.number().finite().positive(),
-      input: TopologyCounts,
-    }),
-    z.strictObject({
-      op: z.literal("shell"),
-      openFaces: z.array(FaceSelector).min(1).max(MAX_OPERATION_FACES),
-      thickness: z.number().finite().positive(),
-      input: TopologyCounts,
-    }),
-    z.strictObject({
-      op: z.literal("offset"),
-      distance: z
-        .number()
-        .finite()
-        .refine((value) => value !== 0, { message: "distance must be non-zero" }),
-      input: TopologyCounts,
-    }),
-  ])
-  .superRefine((operation, ctx) => {
-    if (operation.op !== "fillet") return
-    const { edges, endRadius, radii } = operation
-    if (endRadius === undefined && radii === undefined) return
-    if (endRadius !== undefined && radii !== undefined) {
-      ctx.addIssue({
-        code: "custom",
-        message: "endRadius is mutually exclusive with radii",
-      })
-    }
-    if (edges.length !== 1) {
-      ctx.addIssue({
-        code: "custom",
-        message: "a variable fillet names exactly one edge — the blend contour it runs along",
-      })
-    }
-    if (radii?.some((row, i) => i > 0 && row.position <= radii[i - 1].position)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "radii positions must strictly increase",
-      })
-    }
-  })
-
-/**
- * One value of a parameter patch. See {@linkcode ParameterPatchValue}.
- *
- * Deliberately a CLOSED union of the shapes a record's `values` actually hold —
- * no `z.unknown()`, nothing recursive: an unrecognised value is a VALIDATION at
- * the wire, not a silent write of nonsense onto a mass. It only ever widens, so
- * every value it accepted before it still accepts.
- */
-export const ParameterPatchValue: z.ZodType<ParameterPatchValue, ParameterPatchValue> = z.lazy(() =>
-  z.union([
-    z.number().finite(),
-    XYZ,
-    z.array(XYZ).max(MAX_SWEEP_PATH_POINTS),
-    ContourRecord,
-    z.array(ContourRecord).max(MAX_LOFT_SECTIONS),
-    z.array(CurveRecord).max(MAX_PATH_CURVES),
-    LoftOptions,
-    SweepOptions,
-    SweepAlongCurveRecordOptions,
-    z.array(OperationRecord).max(MAX_OPERATIONS),
-  ]),
-)
+import * as z from "zod"
+import {
+  ContourRecord,
+  CurveRecord,
+  LoftOptions,
+  MAX_LOFT_SECTIONS,
+  MAX_PATH_CURVES,
+  MAX_SWEEP_PATH_POINTS,
+  SweepAlongCurveRecordOptions,
+  SweepOptions,
+  XYZ,
+} from "./massParameters"
+import type { CurveKind, SurfaceKind } from "./massParameters"
+
+/**
+ * The **operation half** of a mass creation-parameter record: which edge or
+ * face of the recipe's solid a kernel step used, the step itself, and the
+ * values a `design.update.parameters` patch may carry.
+ *
+ * Split out of `massParameters.ts` so that each file stays under the size limit
+ * at which the agent runtime still serves a type module in ONE whole read (the
+ * record module alone had grown past it). Do not merge the two back. It is
+ * re-exported from there and from the package root, so every import path keeps
+ * working.
+ *
+ * Everything here is **pure JSON** by construction, exactly as in
+ * {@linkcode MassParametersRecord}: plain objects, numbers and arrays only, one
+ * `{x, y, z}` point shape, no class instances.
+ */
+
+/** Maximum kernel operations chained onto one recipe. */
+export const MAX_OPERATIONS = 8
+/** Maximum edges one fillet/chamfer operation may select. */
+export const MAX_OPERATION_EDGES = 64
+/** Maximum faces one shell operation may open. */
+export const MAX_OPERATION_FACES = 32
+/** Maximum rows in a variable-fillet radius law. */
+export const MAX_FILLET_LAW_SAMPLES = 32
+
+// `XYZ` and the record schemas below are resolved through `z.lazy`: this module
+// and `massParameters.ts` re-export each other, and this one is evaluated first,
+// so their consts are not yet initialised while these schemas are built. The
+// closures run at parse time, when both modules are live.
+const At: z.ZodType<XYZ, XYZ> = z.lazy(() => XYZ)
+
+/**
+ * Which EDGE of the input solid an operation used: its index in
+ * `core.geom.query.brep.listEdges` order at authoring time, the indices of the
+ * two faces it lies between, and its curve kind. This is topology, not
+ * coordinates — it survives a scalar edit of the base recipe (which moves every
+ * edge) and trips on a reorder or a topology change. Read-only: to blend a
+ * different edge, re-select it on the new shape and re-apply the operation.
+ */
+export type EdgeSelector = {
+  index: number
+  faces: [number, number]
+  curve: CurveKind
+  /** Where the edge sits INSIDE its solid: its midpoint in the record's own
+   *  frame, divided by the solid's bounding-box extent — a ratio per axis,
+   *  never a length, so it survives a scalar edit that scales the whole shape.
+   *  Written only when the discriminators above cannot tell two edges apart. A
+   *  tiebreak, never a coordinate fingerprint: a replay checks it within 0.02 of
+   *  the solid's own box and refuses on a miss — it never searches for a better
+   *  candidate. */
+  at?: XYZ
+}
+
+/**
+ * Which FACE of the input solid an operation used: its index in
+ * `core.geom.query.brep.listFaces` order, its surface kind, and the number of
+ * edges in its outer loop. Read-only, like {@linkcode EdgeSelector}.
+ */
+export type FaceSelector = {
+  index: number
+  kind: SurfaceKind
+  edgeCount: number
+  /** The face's centroid under the same normalisation and the same tiebreak
+   *  rule as {@linkcode EdgeSelector}'s `at` — written only where the
+   *  discriminators above cannot separate two faces, which on a freeform solid
+   *  (every face answers `"spline"`) is the common case. */
+  at?: XYZ
+}
+
+/** The input solid's topology at authoring time — the counts a replay checks first. */
+export type TopologyCounts = { faceCount: number; edgeCount: number }
+
+/**
+ * One kernel operation applied to the base recipe's solid, in order. `input`
+ * pins the topology the operation was authored against, so a base edit that
+ * changes the topology is refused rather than mis-applied.
+ *
+ * Edit one by patching the whole list back:
+ * `design.update.parameters(mass, { operations })`.
+ */
+export type OperationRecord =
+  | {
+      op: "fillet"
+      edges: EdgeSelector[]
+      radius: number
+      /** Radius at the far end of the blend contour, internal length units — a
+       *  linear variable blend from `radius`. One edge, and never with `radii`. */
+      endRadius?: number
+      /** The blend's radius law instead: `position` is normalised arc length
+       *  along the blend contour (a ratio 0..1, never converted), `radius` is
+       *  internal length units. 2..32 rows, strictly increasing `position`.
+       *  One edge, and never with `endRadius`. */
+      radii?: { position: number; radius: number }[]
+      input: TopologyCounts
+    }
+  | { op: "chamfer"; edges: EdgeSelector[]; distance: number; input: TopologyCounts }
+  | { op: "shell"; openFaces: FaceSelector[]; thickness: number; input: TopologyCounts }
+  | { op: "offset"; distance: number; input: TopologyCounts }
+
+/**
+ * One value of a `MassParametersPatch` — whatever a record's `values` key (or
+ * `operations`) may hold. Each key you send replaces that value whole — a
+ * scalar, a point, a list or a record (`contour`, `profile`, `sections`,
+ * `path`, `options`, `operations`) alike — so send the complete value you read.
+ */
+export type ParameterPatchValue =
+  | number
+  | XYZ
+  | XYZ[]
+  | ContourRecord
+  | ContourRecord[]
+  | CurveRecord[]
+  | LoftOptions
+  | SweepOptions
+  | SweepAlongCurveRecordOptions
+  | OperationRecord[]
+
+const FaceIndex = z.number().int().nonnegative()
+
+/** See {@linkcode EdgeSelector}. */
+export const EdgeSelector: z.ZodType<EdgeSelector, EdgeSelector> = z.strictObject({
+  index: FaceIndex,
+  faces: z.tuple([FaceIndex, FaceIndex]),
+  curve: z.enum(["line", "arc", "circle", "spline"]),
+  at: At.optional(),
+})
+
+/** See {@linkcode FaceSelector}. */
+export const FaceSelector: z.ZodType<FaceSelector, FaceSelector> = z.strictObject({
+  index: FaceIndex,
+  kind: z.enum(["plane", "cylinder", "cone", "sphere", "torus", "spline"]),
+  edgeCount: z.number().int().positive(),
+  at: At.optional(),
+})
+
+/** See {@linkcode TopologyCounts}. */
+export const TopologyCounts: z.ZodType<TopologyCounts, TopologyCounts> = z.strictObject({
+  faceCount: z.number().int().positive(),
+  edgeCount: z.number().int().positive(),
+})
+
+/** One row of a variable fillet's radius law. See {@linkcode OperationRecord}. */
+const FilletLawRow = z.strictObject({
+  position: z.number().finite().min(0).max(1),
+  radius: z.number().finite().positive(),
+})
+
+/**
+ * See {@linkcode OperationRecord}.
+ *
+ * A variable fillet — `endRadius` or `radii` — names ONE edge: the law is a
+ * property of the blend contour that edge belongs to, and `position` is measured
+ * from that edge's start, so a second edge would have no origin. The two forms
+ * are mutually exclusive and `radii` rows run strictly forward.
+ */
+export const OperationRecord: z.ZodType<OperationRecord, OperationRecord> = z
+  .discriminatedUnion("op", [
+    z.strictObject({
+      op: z.literal("fillet"),
+      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
+      radius: z.number().finite().positive(),
+      endRadius: z.number().finite().positive().optional(),
+      radii: z.array(FilletLawRow).min(2).max(MAX_FILLET_LAW_SAMPLES).optional(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("chamfer"),
+      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
+      distance: z.number().finite().positive(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("shell"),
+      openFaces: z.array(FaceSelector).min(1).max(MAX_OPERATION_FACES),
+      thickness: z.number().finite().positive(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("offset"),
+      distance: z
+        .number()
+        .finite()
+        .refine((value) => value !== 0, { message: "distance must be non-zero" }),
+      input: TopologyCounts,
+    }),
+  ])
+  .superRefine((operation, ctx) => {
+    if (operation.op !== "fillet") return
+    const { edges, endRadius, radii } = operation
+    if (endRadius === undefined && radii === undefined) return
+    if (endRadius !== undefined && radii !== undefined) {
+      ctx.addIssue({
+        code: "custom",
+        message: "endRadius is mutually exclusive with radii",
+      })
+    }
+    if (edges.length !== 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: "a variable fillet names exactly one edge — the blend contour it runs along",
+      })
+    }
+    if (radii?.some((row, i) => i > 0 && row.position <= radii[i - 1].position)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "radii positions must strictly increase",
+      })
+    }
+  })
+
+/**
+ * One value of a parameter patch. See {@linkcode ParameterPatchValue}.
+ *
+ * Deliberately a CLOSED union of the shapes a record's `values` actually hold —
+ * no `z.unknown()`, nothing recursive: an unrecognised value is a VALIDATION at
+ * the wire, not a silent write of nonsense onto a mass. It only ever widens, so
+ * every value it accepted before it still accepts.
+ */
+export const ParameterPatchValue: z.ZodType<ParameterPatchValue, ParameterPatchValue> = z.lazy(() =>
+  z.union([
+    z.number().finite(),
+    XYZ,
+    z.array(XYZ).max(MAX_SWEEP_PATH_POINTS),
+    ContourRecord,
+    z.array(ContourRecord).max(MAX_LOFT_SECTIONS),
+    z.array(CurveRecord).max(MAX_PATH_CURVES),
+    LoftOptions,
+    SweepOptions,
+    SweepAlongCurveRecordOptions,
+    z.array(OperationRecord).max(MAX_OPERATIONS),
+  ]),
+)