@snaptrude/plugin-core 0.0.0-dev-20260908074328 → 0.0.0-surfaces-20260921090636

package/test/massParameters.test.mjs

@@ -0,0 +1,936 @@
+// Node built-in test runner suite for the shared mass-parameter record schemas.
+// Run: node --test test/
+// Imports the BUILT package (dist) — run `pnpm build` first.
+import test from "node:test"
+import assert from "node:assert/strict"
+import { readFileSync } from "node:fs"
+import {
+  MassParametersRecord,
+  MassParametersPatch,
+  OperationRecord,
+  ContourRecord,
+  ProfileRecord,
+  CurveRecord,
+  EdgeSelector,
+  FaceSelector,
+  ParameterPatchValue,
+  SweepAlongCurveRecordOptions,
+  MAX_PROFILE_CURVES,
+  MAX_CONTOUR_HOLES,
+  MAX_SPLINE_THROUGH_POINTS,
+  MAX_SWEEP_PATH_POINTS,
+  MAX_LOFT_SECTIONS,
+  MAX_OPERATIONS,
+  MAX_OPERATION_EDGES,
+  MAX_OPERATION_FACES,
+  MAX_PATH_CURVES,
+  MAX_TWIST_LEVELS,
+  MAX_FILLET_LAW_SAMPLES,
+  MAX_PATCH_BOUNDARY_CURVES,
+  MAX_PATCH_INTERIOR_POINTS,
+  CurveHandle,
+  SplineHandle,
+  PluginGeomCreateBrepFromSweepArgs,
+  PluginGeomCreateBrepFromLoftArgs,
+  PluginGeomCreateBrepFromFilletArgs,
+  PluginGeomCreateBrepFromChamferArgs,
+  PluginGeomCreateBrepFromShellArgs,
+  PluginGeomCreateBrepFromExtrusionArgs,
+  PluginGeomCreateBrepFromPatchArgs,
+  PluginGeomCreateBrepFromSweepAlongCurveArgs,
+  PluginGeomCreateBrepsFromSplitByFaceArgs,
+  PluginGeomCreateCurvesFromProjectionArgs,
+  PluginGeomCreateSplineFromControlPointsArgs,
+  PluginDesignUpdateParametersArgs,
+  PluginGeomQueryFaceGetAreaArgs,
+  PluginGeomQueryFaceGetCentroidArgs,
+} from "../dist/index.js"
+
+const p = (x, y, z) => ({ x, y, z })
+
+/** A square outer loop, no holes — the simplest legal contour record. */
+const squareContour = {
+  outer: {
+    curves: [
+      { type: "line", start: p(0, 0, 0), end: p(4, 0, 0) },
+      { type: "line", start: p(4, 0, 0), end: p(4, 0, 4) },
+      { type: "line", start: p(4, 0, 4), end: p(0, 0, 4) },
+      { type: "line", start: p(0, 0, 4), end: p(0, 0, 0) },
+    ],
+  },
+  holes: [],
+}
+
+test("accepts one record of every kind", () => {
+  const records = [
+    { kind: "sphere", version: 1, values: { centre: p(0, 5, 0), radius: 5 } },
+    {
+      kind: "cylinder",
+      version: 1,
+      values: { base: p(0, 0, 0), axis: p(0, 1, 0), radius: 1, height: 4 },
+    },
+    {
+      kind: "cone",
+      version: 1,
+      values: { base: p(0, 0, 0), axis: p(0, 1, 0), baseRadius: 2, topRadius: 0, height: 3 },
+    },
+    {
+      kind: "torus",
+      version: 1,
+      values: { centre: p(0, 6, 0), axis: p(0, 1, 0), majorRadius: 5, minorRadius: 1 },
+    },
+    {
+      kind: "extrusion",
+      version: 1,
+      values: { contour: squareContour, direction: p(0, 1, 0), amount: 3 },
+    },
+    {
+      kind: "revolution",
+      version: 1,
+      values: {
+        contour: squareContour,
+        axisOrigin: p(0, 0, 0),
+        axisDirection: p(0, 1, 0),
+        angleInDegrees: 360,
+      },
+    },
+    {
+      kind: "loft",
+      version: 1,
+      values: { sections: [squareContour, squareContour], options: { compatibility: "auto" } },
+    },
+    {
+      kind: "sweep",
+      version: 1,
+      values: {
+        profile: squareContour,
+        path: [p(0, 0, 0), p(0, 3, 0)],
+        options: { transition: "round" },
+      },
+    },
+  ]
+  for (const record of records) {
+    const parsed = MassParametersRecord.safeParse(record)
+    assert.equal(parsed.success, true, `${record.kind}: ${JSON.stringify(parsed.error?.issues)}`)
+    assert.deepEqual(parsed.data, record)
+  }
+})
+
+test("both spline curve forms round-trip inside a contour", () => {
+  const contour = {
+    outer: {
+      curves: [
+        { type: "splineThrough", fitVersion: 1, throughPoints: [p(0, 0, 0), p(1, 0, 2), p(3, 0, 1)] },
+        {
+          type: "splinePoles",
+          degree: 3,
+          knots: [0, 1],
+          mults: [4, 4],
+          poles: [p(3, 0, 1), p(2, 0, 0), p(1, 0, -1), p(0, 0, 0)],
+        },
+      ],
+    },
+    holes: [],
+  }
+  assert.equal(ContourRecord.safeParse(contour).success, true)
+})
+
+test("rejects a record that is not the truth", () => {
+  // Unknown key — the host names it back to the caller, never silently drops it.
+  assert.equal(
+    MassParametersRecord.safeParse({
+      kind: "torus",
+      version: 1,
+      values: { centre: p(0, 0, 0), axis: p(0, 1, 0), majorRadius: 5, minorRadius: 1, radius: 5 },
+    }).success,
+    false,
+  )
+  // Unknown schema version — restore degrades the mass to non-parametric.
+  assert.equal(
+    MassParametersRecord.safeParse({
+      kind: "sphere",
+      version: 2,
+      values: { centre: p(0, 0, 0), radius: 5 },
+    }).success,
+    false,
+  )
+  // Non-finite / non-positive values.
+  for (const radius of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+    assert.equal(
+      MassParametersRecord.safeParse({
+        kind: "sphere",
+        version: 1,
+        values: { centre: p(0, 0, 0), radius },
+      }).success,
+      false,
+      `radius ${radius} must be rejected`,
+    )
+  }
+  // A spline record with neither form's fields.
+  assert.equal(CurveRecord.safeParse({ type: "splineThrough", throughPoints: [] }).success, false)
+})
+
+test("array caps are contract, not truncation", () => {
+  const points = (n) => Array.from({ length: n }, (_, i) => p(i, 0, 0))
+  const spline = (n) => ({ type: "splineThrough", fitVersion: 1, throughPoints: points(n) })
+  assert.equal(CurveRecord.safeParse(spline(MAX_SPLINE_THROUGH_POINTS)).success, true)
+  assert.equal(CurveRecord.safeParse(spline(MAX_SPLINE_THROUGH_POINTS + 1)).success, false)
+
+  const sweep = (n) => ({
+    kind: "sweep",
+    version: 1,
+    values: { profile: squareContour, path: points(n) },
+  })
+  assert.equal(MassParametersRecord.safeParse(sweep(MAX_SWEEP_PATH_POINTS)).success, true)
+  assert.equal(MassParametersRecord.safeParse(sweep(MAX_SWEEP_PATH_POINTS + 1)).success, false)
+
+  const loft = (n) => ({
+    kind: "loft",
+    version: 1,
+    values: { sections: Array.from({ length: n }, () => squareContour) },
+  })
+  assert.equal(MassParametersRecord.safeParse(loft(MAX_LOFT_SECTIONS)).success, true)
+  assert.equal(MassParametersRecord.safeParse(loft(MAX_LOFT_SECTIONS + 1)).success, false)
+
+  // The caps bind the RECORD only. The creator args (shipped in 0.9.6 without
+  // any cap) keep accepting an over-cap call — the host builds it and mints no
+  // record (the recipe-less fallback). See "wire schemas keep 0.9.6 acceptance".
+  const sweepArgs = (n) => ({ profile: "contour_1", path: points(n) })
+  assert.equal(
+    PluginGeomCreateBrepFromSweepArgs.safeParse(sweepArgs(MAX_SWEEP_PATH_POINTS)).success,
+    true,
+  )
+  const loftArgs = (n) => ({
+    bottomContour: "contour_1",
+    topContour: "contour_2",
+    intermediateContours: Array.from({ length: n }, (_, i) => `contour_${i + 3}`),
+  })
+  assert.equal(
+    PluginGeomCreateBrepFromLoftArgs.safeParse(loftArgs(MAX_LOFT_SECTIONS - 2)).success,
+    true,
+  )
+
+  // A contour's own arrays are bounded too — a 20 000-curve loop or a
+  // 5 000-hole contour must not ride the save/collab payload as a record.
+  const loop = (n) => ({
+    curves: Array.from({ length: n }, (_, i) => ({
+      type: "line",
+      start: p(i, 0, 0),
+      end: p(i + 1, 0, 0),
+    })),
+  })
+  assert.equal(ProfileRecord.safeParse(loop(MAX_PROFILE_CURVES)).success, true)
+  assert.equal(ProfileRecord.safeParse(loop(MAX_PROFILE_CURVES + 1)).success, false)
+
+  const holed = (n) => ({
+    outer: squareContour.outer,
+    holes: Array.from({ length: n }, () => squareContour.outer),
+  })
+  assert.equal(ContourRecord.safeParse(holed(MAX_CONTOUR_HOLES)).success, true)
+  assert.equal(ContourRecord.safeParse(holed(MAX_CONTOUR_HOLES + 1)).success, false)
+})
+
+/** sphere → shell → fillet: the chained record of binding-design-4b §5.2. */
+const chainedRecord = {
+  kind: "sphere",
+  version: 1,
+  values: { centre: p(0, 23.6, 0), radius: 23.622 },
+  operations: [
+    {
+      op: "shell",
+      openFaces: [{ index: 3, kind: "plane", edgeCount: 2 }],
+      thickness: 1.181,
+      input: { faceCount: 4, edgeCount: 6 },
+    },
+    {
+      op: "fillet",
+      edges: [
+        { index: 2, faces: [0, 3], curve: "arc" },
+        { index: 5, faces: [1, 3], curve: "arc" },
+      ],
+      radius: 0.787,
+      input: { faceCount: 8, edgeCount: 14 },
+    },
+  ],
+}
+
+test("a chained operations record round-trips", () => {
+  const parsed = MassParametersRecord.safeParse(chainedRecord)
+  assert.equal(parsed.success, true, JSON.stringify(parsed.error?.issues))
+  assert.deepEqual(parsed.data, chainedRecord)
+
+  // `operations` is additive and optional — a 4A-era record still parses.
+  const { operations, ...base } = chainedRecord
+  assert.equal(MassParametersRecord.safeParse(base).success, true)
+
+  // Every op kind on its own.
+  const chamfer = {
+    op: "chamfer",
+    edges: [{ index: 0, faces: [0, 1], curve: "line" }],
+    distance: 0.1,
+    input: { faceCount: 6, edgeCount: 12 },
+  }
+  const offset = { op: "offset", distance: -0.4, input: { faceCount: 4, edgeCount: 6 } }
+  for (const op of [operations[0], operations[1], chamfer, offset]) {
+    assert.deepEqual(OperationRecord.parse(op), op)
+  }
+})
+
+test("operation records reject what cannot be replayed", () => {
+  const counts = { faceCount: 4, edgeCount: 6 }
+  // A selector list is never empty — an op that selected nothing is not a record.
+  assert.equal(OperationRecord.safeParse({ op: "fillet", edges: [], radius: 1, input: counts }).success, false)
+  // Fractional / negative indices cannot address a face or an edge.
+  assert.equal(
+    OperationRecord.safeParse({
+      op: "fillet",
+      edges: [{ index: 1.5, faces: [0, 1], curve: "arc" }],
+      radius: 1,
+      input: counts,
+    }).success,
+    false,
+  )
+  assert.equal(
+    OperationRecord.safeParse({
+      op: "fillet",
+      edges: [{ index: 0, faces: [0, -1], curve: "arc" }],
+      radius: 1,
+      input: counts,
+    }).success,
+    false,
+  )
+  // A face pair is exactly two faces.
+  assert.equal(
+    OperationRecord.safeParse({
+      op: "fillet",
+      edges: [{ index: 0, faces: [0, 1, 2], curve: "arc" }],
+      radius: 1,
+      input: counts,
+    }).success,
+    false,
+  )
+  // Unknown surface / curve kinds, unknown op, and a zero offset.
+  assert.equal(
+    OperationRecord.safeParse({
+      op: "shell",
+      openFaces: [{ index: 0, kind: "nurbs", edgeCount: 2 }],
+      thickness: 1,
+      input: counts,
+    }).success,
+    false,
+  )
+  assert.equal(OperationRecord.safeParse({ op: "draft", angle: 3, input: counts }).success, false)
+  assert.equal(OperationRecord.safeParse({ op: "offset", distance: 0, input: counts }).success, false)
+  // Non-positive scalars.
+  for (const radius of [0, -1, Number.NaN]) {
+    assert.equal(
+      OperationRecord.safeParse({
+        op: "fillet",
+        edges: [{ index: 0, faces: [0, 1], curve: "arc" }],
+        radius,
+        input: counts,
+      }).success,
+      false,
+      `radius ${radius} must be rejected`,
+    )
+  }
+})
+
+test("operation caps are contract, not truncation", () => {
+  const counts = { faceCount: 4, edgeCount: 6 }
+  const fillet = (n) => ({
+    op: "fillet",
+    edges: Array.from({ length: n }, (_, i) => ({ index: i, faces: [0, 1], curve: "line" })),
+    radius: 1,
+    input: counts,
+  })
+  assert.equal(OperationRecord.safeParse(fillet(MAX_OPERATION_EDGES)).success, true)
+  assert.equal(OperationRecord.safeParse(fillet(MAX_OPERATION_EDGES + 1)).success, false)
+
+  const shell = (n) => ({
+    op: "shell",
+    openFaces: Array.from({ length: n }, (_, i) => ({ index: i, kind: "plane", edgeCount: 4 })),
+    thickness: 1,
+    input: counts,
+  })
+  assert.equal(OperationRecord.safeParse(shell(MAX_OPERATION_FACES)).success, true)
+  assert.equal(OperationRecord.safeParse(shell(MAX_OPERATION_FACES + 1)).success, false)
+
+  const chain = (n) => ({ ...chainedRecord, operations: Array.from({ length: n }, () => fillet(1)) })
+  assert.equal(MassParametersRecord.safeParse(chain(MAX_OPERATIONS)).success, true)
+  assert.equal(MassParametersRecord.safeParse(chain(MAX_OPERATIONS + 1)).success, false)
+
+  // The creator args are NOT capped (see "wire schemas keep 0.9.6 acceptance").
+  const edges = (n) => Array.from({ length: n }, (_, i) => `edge_${i}`)
+  const faces = (n) => Array.from({ length: n }, (_, i) => `face_${i}`)
+  const filletArgs = (n) => ({ brep: "brep_1", edges: edges(n), radius: 1 })
+  assert.equal(PluginGeomCreateBrepFromFilletArgs.safeParse(filletArgs(MAX_OPERATION_EDGES)).success, true)
+  const shellArgs = (n) => ({ brep: "brep_1", openFaces: faces(n), thickness: 1 })
+  assert.equal(PluginGeomCreateBrepFromShellArgs.safeParse(shellArgs(MAX_OPERATION_FACES)).success, true)
+})
+
+test("wire schemas keep 0.9.6 acceptance: record caps never reach the call", () => {
+  // The five inputs the external review (2026-09-06, #5) ran against the
+  // published 0.9.6 schemas: all accepted there, so all must stay accepted
+  // (feedback-no-breaking-api-changes — a shipped member never narrows). The
+  // record caps above still hold; the host answers an over-cap call with a
+  // solid and no record, never with VALIDATION.
+  const pts = (n) => Array.from({ length: n }, (_, i) => p(i, 0, 0))
+  const ids = (prefix, n) => Array.from({ length: n }, (_, i) => `${prefix}_${i}`)
+  const accepted = [
+    [
+      "loft with 31 intermediates",
+      PluginGeomCreateBrepFromLoftArgs.safeParse({
+        bottomContour: "contour_1",
+        topContour: "contour_2",
+        intermediateContours: ids("contour", MAX_LOFT_SECTIONS - 1),
+      }),
+    ],
+    [
+      "sweep with 513 path points",
+      PluginGeomCreateBrepFromSweepArgs.safeParse({
+        profile: "contour_1",
+        path: pts(MAX_SWEEP_PATH_POINTS + 1),
+      }),
+    ],
+    [
+      "fillet with 65 edges",
+      PluginGeomCreateBrepFromFilletArgs.safeParse({
+        brep: "brep_1",
+        edges: ids("edge", MAX_OPERATION_EDGES + 1),
+        radius: 1,
+      }),
+    ],
+    [
+      "chamfer with 65 edges",
+      PluginGeomCreateBrepFromChamferArgs.safeParse({
+        brep: "brep_1",
+        edges: ids("edge", MAX_OPERATION_EDGES + 1),
+        distance: 1,
+      }),
+    ],
+    [
+      "shell with 33 open faces",
+      PluginGeomCreateBrepFromShellArgs.safeParse({
+        brep: "brep_1",
+        openFaces: ids("face", MAX_OPERATION_FACES + 1),
+        thickness: 1,
+      }),
+    ],
+  ]
+  for (const [what, result] of accepted) {
+    assert.equal(result.success, true, `${what} must stay schema-valid: ${JSON.stringify(result.error?.issues)}`)
+  }
+})
+
+test("MassParametersPatch takes both a partial and a full record", () => {
+  // Partial forms: a scalar, a point, a whole array, and the empty op list.
+  for (const patch of [
+    { radius: 31.496 },
+    { centre: p(1, 2, 3) },
+    { path: [p(0, 0, 0), p(0, 3, 0)] },
+    { sections: [squareContour, squareContour] },
+    { contour: squareContour },
+    { options: { seamAlignment: "authored" } },
+    { options: { startScale: 1, endScale: 2, transition: { bevel: 0.2 } } },
+    { operations: chainedRecord.operations },
+    { operations: [] },
+  ]) {
+    const parsed = MassParametersPatch.safeParse(patch)
+    assert.equal(parsed.success, true, `${JSON.stringify(patch)}: ${JSON.stringify(parsed.error?.issues)}`)
+    assert.deepEqual(parsed.data, patch)
+  }
+
+  // Full-record form: read → edit → send the whole thing back.
+  const echoed = MassParametersPatch.safeParse(chainedRecord)
+  assert.equal(echoed.success, true)
+  assert.deepEqual(echoed.data, chainedRecord)
+
+  // …including the record edited to drop every operation. `{ operations: [] }`
+  // is the documented drop idiom, so the whole-record route must take it too
+  // (the host normalises the empty list to an absent key before storing).
+  const dropped = { ...chainedRecord, operations: [] }
+  const droppedParse = MassParametersPatch.safeParse(dropped)
+  assert.equal(droppedParse.success, true, JSON.stringify(droppedParse.error?.issues))
+  assert.deepEqual(droppedParse.data, dropped)
+  assert.equal(MassParametersRecord.safeParse(dropped).success, true)
+
+  // Values outside the closed union are refused at the wire, not written on.
+  for (const patch of [
+    { radius: "8" },
+    { radius: Number.POSITIVE_INFINITY },
+    { centre: { x: 0, y: 0 } },
+    { operations: [{ op: "fillet", edges: [], radius: 1, input: { faceCount: 4, edgeCount: 6 } }] },
+    { nested: { deeply: { wrong: true } } },
+  ]) {
+    assert.equal(MassParametersPatch.safeParse(patch).success, false, JSON.stringify(patch))
+  }
+})
+
+test("the 4B call args parse", () => {
+  assert.equal(
+    PluginDesignUpdateParametersArgs.safeParse({ component: "component_1", patch: { radius: 8 } })
+      .success,
+    true,
+  )
+  assert.equal(
+    PluginDesignUpdateParametersArgs.safeParse({ component: "component_1", patch: { radius: null } })
+      .success,
+    false,
+  )
+
+  const poles = (n) => Array.from({ length: n }, (_, i) => `vec3_${i}`)
+  assert.equal(
+    PluginGeomCreateSplineFromControlPointsArgs.safeParse({ controlPoints: poles(4) }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateSplineFromControlPointsArgs.safeParse({
+      controlPoints: poles(4),
+      options: { degree: 2 },
+    }).success,
+    true,
+  )
+  // degree is 2 or 3 — 1 is a polyline, 4+ is not offered.
+  for (const degree of [1, 4, 2.5]) {
+    assert.equal(
+      PluginGeomCreateSplineFromControlPointsArgs.safeParse({
+        controlPoints: poles(4),
+        options: { degree },
+      }).success,
+      false,
+      `degree ${degree} must be rejected`,
+    )
+  }
+  assert.equal(
+    PluginGeomCreateSplineFromControlPointsArgs.safeParse({ controlPoints: poles(2) }).success,
+    false,
+  )
+})
+
+test("CurveHandle accepts a spline handle", () => {
+  assert.equal(SplineHandle.parse("spline_1").id, "spline_1")
+  for (const id of ["line_1", "arc_1", "spline_1"]) {
+    assert.equal(CurveHandle.parse(id).id, id)
+  }
+  assert.equal(CurveHandle.safeParse("circle_1").success, false)
+})
+
+// ── Freeform surfaces, sweeps, patches and variable blends ──────────────────
+
+const line = (a, b) => ({ type: "line", start: a, end: b })
+const topology = { faceCount: 6, edgeCount: 12 }
+const edgeSel = { index: 3, faces: [0, 1], curve: "spline" }
+
+test("a sweep-along-a-curve record round-trips, and its path is curves", () => {
+  const record = {
+    kind: "sweepAlongCurve",
+    version: 1,
+    values: {
+      profile: squareContour,
+      path: [
+        line(p(0, 0, 0), p(0, 10, 0)),
+        {
+          type: "arc",
+          start: p(0, 10, 0),
+          end: p(5, 15, 0),
+          centre: p(5, 10, 0),
+          axis: p(0, 0, 1),
+        },
+      ],
+      options: { orientation: "upright" },
+    },
+  }
+  const parsed = MassParametersRecord.safeParse(record)
+  assert.equal(parsed.success, true, JSON.stringify(parsed.error?.issues))
+  assert.deepEqual(parsed.data, record)
+
+  // The options bag is the RECORD's: pure JSON, no rail handle.
+  assert.equal(SweepAlongCurveRecordOptions.safeParse({ orientation: "fixed" }).success, true)
+  assert.equal(SweepAlongCurveRecordOptions.safeParse({ orientation: "banking" }).success, false)
+  assert.equal(SweepAlongCurveRecordOptions.safeParse({ rail: "line_1" }).success, false)
+
+  // Caps and vocabulary are contract: 1..64 curves, no XYZ path.
+  const withPath = (path) => ({ ...record, values: { ...record.values, path } })
+  assert.equal(
+    MassParametersRecord.safeParse(
+      withPath(Array.from({ length: MAX_PATH_CURVES }, () => line(p(0, 0, 0), p(1, 0, 0)))),
+    ).success,
+    true,
+  )
+  assert.equal(
+    MassParametersRecord.safeParse(
+      withPath(Array.from({ length: MAX_PATH_CURVES + 1 }, () => line(p(0, 0, 0), p(1, 0, 0)))),
+    ).success,
+    false,
+  )
+  assert.equal(MassParametersRecord.safeParse(withPath([])).success, false)
+  assert.equal(MassParametersRecord.safeParse(withPath([p(0, 0, 0), p(1, 0, 0)])).success, false)
+  // The shipped polyline `sweep` kind is untouched — its path is still points.
+  assert.equal(
+    MassParametersRecord.safeParse({
+      kind: "sweep",
+      version: 1,
+      values: { profile: squareContour, path: [p(0, 0, 0), p(0, 3, 0)] },
+    }).success,
+    true,
+  )
+})
+
+test("an extrusion record carries twist, taper and levels", () => {
+  const straight = {
+    kind: "extrusion",
+    version: 1,
+    values: { contour: squareContour, direction: p(0, 1, 0), amount: 40 },
+  }
+  const twisted = {
+    ...straight,
+    values: { ...straight.values, twistInDegrees: 90, topScale: 0.6, levels: 6 },
+  }
+  const parsed = MassParametersRecord.safeParse(twisted)
+  assert.equal(parsed.success, true, JSON.stringify(parsed.error?.issues))
+  assert.deepEqual(parsed.data, twisted)
+  // Absent keys are still the shipped straight extrusion, byte for byte.
+  assert.deepEqual(MassParametersRecord.parse(straight), straight)
+
+  const values = (extra) => ({ ...straight, values: { ...straight.values, ...extra } })
+  assert.equal(MassParametersRecord.safeParse(values({ levels: MAX_TWIST_LEVELS })).success, true)
+  assert.equal(
+    MassParametersRecord.safeParse(values({ levels: MAX_TWIST_LEVELS + 1 })).success,
+    false,
+  )
+  assert.equal(MassParametersRecord.safeParse(values({ levels: 1 })).success, false)
+  assert.equal(MassParametersRecord.safeParse(values({ topScale: -1 })).success, false)
+  assert.equal(MassParametersRecord.safeParse(values({ twistInDegrees: "90" })).success, false)
+})
+
+test("a loft record chooses its smoothing", () => {
+  const record = {
+    kind: "loft",
+    version: 1,
+    values: { sections: [squareContour, squareContour], options: { smoothing: "smooth" } },
+  }
+  assert.deepEqual(MassParametersRecord.parse(record), record)
+  assert.equal(
+    MassParametersRecord.safeParse({
+      ...record,
+      values: { ...record.values, options: { smoothing: "curvy" } },
+    }).success,
+    false,
+  )
+})
+
+test("selectors carry an optional normalised position", () => {
+  const face = { index: 2, kind: "spline", edgeCount: 4, at: { x: 0.13, y: 1, z: 0.87 } }
+  assert.deepEqual(FaceSelector.parse(face), face)
+  const edge = { ...edgeSel, at: { x: 0.5, y: 0, z: 0.5 } }
+  assert.deepEqual(EdgeSelector.parse(edge), edge)
+  // A selector recorded before `at` existed still parses unchanged — the key
+  // only widens.
+  assert.deepEqual(EdgeSelector.parse(edgeSel), edgeSel)
+  assert.equal(FaceSelector.safeParse({ ...face, at: { x: 0, y: 0 } }).success, false)
+  assert.equal(EdgeSelector.safeParse({ ...edgeSel, at: [0, 0, 0] }).success, false)
+})
+
+test("a variable fillet operation names one edge and one law", () => {
+  const constant = { op: "fillet", edges: [edgeSel], radius: 0.5, input: topology }
+  const tapered = { ...constant, endRadius: 1.5 }
+  const sampled = {
+    ...constant,
+    radii: [
+      { position: 0, radius: 0.5 },
+      { position: 0.5, radius: 2 },
+      { position: 1, radius: 0.5 },
+    ],
+  }
+  assert.deepEqual(OperationRecord.parse(constant), constant)
+  assert.deepEqual(OperationRecord.parse(tapered), tapered)
+  assert.deepEqual(OperationRecord.parse(sampled), sampled)
+
+  // Both laws at once, more than one edge, a table that does not run forward,
+  // a single row, a position outside 0..1, and an over-long table are refused.
+  const twoEdges = [edgeSel, { ...edgeSel, index: 4 }]
+  for (const operation of [
+    { ...tapered, radii: sampled.radii },
+    { ...tapered, edges: twoEdges },
+    { ...sampled, edges: twoEdges },
+    {
+      ...constant,
+      radii: [
+        { position: 0, radius: 1 },
+        { position: 0, radius: 2 },
+      ],
+    },
+    { ...constant, radii: [{ position: 0, radius: 1 }] },
+    {
+      ...constant,
+      radii: [
+        { position: 0, radius: 1 },
+        { position: 1.5, radius: 2 },
+      ],
+    },
+    {
+      ...constant,
+      radii: Array.from({ length: MAX_FILLET_LAW_SAMPLES + 1 }, (_, i) => ({
+        position: i / MAX_FILLET_LAW_SAMPLES,
+        radius: 1,
+      })),
+    },
+  ]) {
+    assert.equal(OperationRecord.safeParse(operation).success, false, JSON.stringify(operation))
+  }
+  // A full table of the maximum length still parses.
+  assert.equal(
+    OperationRecord.safeParse({
+      ...constant,
+      radii: Array.from({ length: MAX_FILLET_LAW_SAMPLES }, (_, i) => ({
+        position: i / (MAX_FILLET_LAW_SAMPLES - 1),
+        radius: 1,
+      })),
+    }).success,
+    true,
+  )
+})
+
+test("the patch union widens to the new option bag and curve paths", () => {
+  assert.equal(ParameterPatchValue.safeParse({ orientation: "frenet" }).success, true)
+  assert.equal(ParameterPatchValue.safeParse([line(p(0, 0, 0), p(1, 0, 0))]).success, true)
+  assert.equal(ParameterPatchValue.safeParse({ smoothing: "smooth" }).success, true)
+  assert.equal(ParameterPatchValue.safeParse(90).success, true)
+  // A radius law is a key INSIDE an operation, never a top-level `values` key.
+  assert.equal(ParameterPatchValue.safeParse([{ position: 0, radius: 1 }]).success, false)
+
+  assert.equal(
+    MassParametersPatch.safeParse({
+      path: [line(p(0, 0, 0), p(0, 10, 0))],
+      options: { orientation: "fixed" },
+    }).success,
+    true,
+  )
+  assert.equal(MassParametersPatch.safeParse({ twistInDegrees: 120, topScale: 0.5 }).success, true)
+  assert.equal(
+    MassParametersPatch.safeParse({
+      operations: [{ op: "fillet", edges: [edgeSel], radius: 0.5, endRadius: 2, input: topology }],
+    }).success,
+    true,
+  )
+  assert.equal(MassParametersPatch.safeParse({ orientation: "sideways" }).success, false)
+})
+
+test("the freeform call args parse", () => {
+  // brepFromExtrusion keeps its three-positional form and gains a trailing bag.
+  const extrusion = { contour: "contour_1", direction: p(0, 1, 0), amount: 40 }
+  assert.equal(PluginGeomCreateBrepFromExtrusionArgs.safeParse(extrusion).success, true)
+  assert.equal(
+    PluginGeomCreateBrepFromExtrusionArgs.safeParse({
+      ...extrusion,
+      options: { twistInDegrees: 90, topScale: 0.6, levels: 6 },
+    }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromExtrusionArgs.safeParse({ ...extrusion, options: { levels: 1 } })
+      .success,
+    false,
+  )
+
+  // brepFromLoft gains smoothing beside the two shipped switches.
+  const loft = { bottomContour: "contour_1", topContour: "contour_2" }
+  assert.equal(PluginGeomCreateBrepFromLoftArgs.safeParse(loft).success, true)
+  assert.equal(
+    PluginGeomCreateBrepFromLoftArgs.safeParse({ ...loft, options: { smoothing: "smooth" } })
+      .success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromLoftArgs.safeParse({ ...loft, options: { smoothing: "silky" } })
+      .success,
+    false,
+  )
+
+  // brepFromFillet: the shipped three-argument call is untouched; a variable
+  // blend takes exactly one edge and exactly one law.
+  const fillet = { brep: "brep_1", edges: ["edge_1"], radius: 0.5 }
+  assert.equal(PluginGeomCreateBrepFromFilletArgs.safeParse(fillet).success, true)
+  assert.equal(
+    PluginGeomCreateBrepFromFilletArgs.safeParse({ ...fillet, edges: ["edge_1", "edge_2"] })
+      .success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromFilletArgs.safeParse({ ...fillet, options: { endRadius: 2 } }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromFilletArgs.safeParse({
+      ...fillet,
+      options: {
+        radii: [
+          { position: 0, radius: 0.5 },
+          { position: 1, radius: 2 },
+        ],
+      },
+    }).success,
+    true,
+  )
+  for (const bad of [
+    { ...fillet, edges: ["edge_1", "edge_2"], options: { endRadius: 2 } },
+    {
+      ...fillet,
+      options: {
+        endRadius: 2,
+        radii: [
+          { position: 0, radius: 1 },
+          { position: 1, radius: 2 },
+        ],
+      },
+    },
+    {
+      ...fillet,
+      options: {
+        radii: [
+          { position: 1, radius: 1 },
+          { position: 0, radius: 2 },
+        ],
+      },
+    },
+    { ...fillet, options: { radii: [{ position: 0, radius: 1 }] } },
+  ]) {
+    assert.equal(
+      PluginGeomCreateBrepFromFilletArgs.safeParse(bad).success,
+      false,
+      JSON.stringify(bad),
+    )
+  }
+
+  // brepFromPatch: curves, owned edges, and the tangent rule.
+  const boundary = ["line_1", "arc_1", { edge: "edge_1", brep: "brep_1" }]
+  assert.equal(
+    PluginGeomCreateBrepFromPatchArgs.safeParse({ boundary, thickness: 0.25 }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromPatchArgs.safeParse({
+      boundary,
+      thickness: 0.25,
+      options: { interiorPoints: [p(1, 1, 1)], side: "above" },
+    }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepFromPatchArgs.safeParse({
+      boundary: [
+        { edge: "edge_1", brep: "brep_1", face: "face_1" },
+        { edge: "edge_2", brep: "brep_2", face: "face_2" },
+        { edge: "edge_3", brep: "brep_1", face: "face_3" },
+      ],
+      thickness: 0.25,
+      options: { continuity: "tangent" },
+    }).success,
+    true,
+  )
+  for (const bad of [
+    // tangent with a curve item, and with an edge item that names no face
+    { boundary, thickness: 0.25, options: { continuity: "tangent" } },
+    {
+      boundary: [
+        { edge: "edge_1", brep: "brep_1" },
+        { edge: "edge_2", brep: "brep_1" },
+        { edge: "edge_3", brep: "brep_1" },
+      ],
+      thickness: 0.25,
+      options: { continuity: "tangent" },
+    },
+    { boundary: ["line_1", "line_2"], thickness: 0.25 },
+    { boundary, thickness: 0 },
+    {
+      boundary: Array.from({ length: MAX_PATCH_BOUNDARY_CURVES + 1 }, () => "line_1"),
+      thickness: 0.25,
+    },
+    {
+      boundary,
+      thickness: 0.25,
+      options: {
+        interiorPoints: Array.from({ length: MAX_PATCH_INTERIOR_POINTS + 1 }, () => p(0, 0, 0)),
+      },
+    },
+  ]) {
+    assert.equal(
+      PluginGeomCreateBrepFromPatchArgs.safeParse(bad).success,
+      false,
+      JSON.stringify(bad),
+    )
+  }
+
+  // brepFromSweepAlongCurve: 1..64 curve handles, and the creator's own rail.
+  const sweep = { profile: "contour_1", path: ["spline_1"] }
+  assert.equal(PluginGeomCreateBrepFromSweepAlongCurveArgs.safeParse(sweep).success, true)
+  assert.equal(
+    PluginGeomCreateBrepFromSweepAlongCurveArgs.safeParse({
+      ...sweep,
+      options: { orientation: "fixed", rail: "spline_2" },
+    }).success,
+    true,
+  )
+  for (const bad of [
+    { ...sweep, path: [] },
+    { ...sweep, path: Array.from({ length: MAX_PATH_CURVES + 1 }, () => "spline_1") },
+    { ...sweep, path: [p(0, 0, 0)] },
+    { ...sweep, options: { orientation: "banking" } },
+  ]) {
+    assert.equal(
+      PluginGeomCreateBrepFromSweepAlongCurveArgs.safeParse(bad).success,
+      false,
+      JSON.stringify(bad),
+    )
+  }
+
+  // The two owner-last members.
+  assert.equal(
+    PluginGeomCreateBrepsFromSplitByFaceArgs.safeParse({
+      brep: "brep_1",
+      toolFace: "face_1",
+      toolBrep: "brep_2",
+    }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateBrepsFromSplitByFaceArgs.safeParse({
+      brep: "brep_1",
+      toolFace: "brep_2",
+      toolBrep: "brep_2",
+    }).success,
+    false,
+  )
+  assert.equal(
+    PluginGeomCreateCurvesFromProjectionArgs.safeParse({
+      curve: "spline_1",
+      face: "face_1",
+      faceBrep: "brep_1",
+    }).success,
+    true,
+  )
+  assert.equal(
+    PluginGeomCreateCurvesFromProjectionArgs.safeParse({
+      curve: "circle_1",
+      face: "face_1",
+      faceBrep: "brep_1",
+    }).success,
+    false,
+  )
+
+  // The two face reads that need the owning solid for their coordinates.
+  for (const args of [PluginGeomQueryFaceGetAreaArgs, PluginGeomQueryFaceGetCentroidArgs]) {
+    assert.equal(args.safeParse({ face: "face_1", brep: "brep_1" }).success, true)
+    assert.equal(args.safeParse({ face: "face_1", brep: "face_1" }).success, false)
+  }
+})
+
+test("both record modules stay inside the one-shot read budget", () => {
+  // The agent reads a one-shot module whole; 12,000 B is the ceiling asserted
+  // over ONE_SHOT_MODULES in the agent runtime.
+  for (const name of ["handles", "massParameters", "massParameters.ops"]) {
+    const bytes = readFileSync(new URL(`../dist/${name}.d.ts`, import.meta.url)).byteLength
+    assert.ok(bytes < 12_000, `dist/${name}.d.ts is ${bytes} B, over the 12,000 B one-shot ceiling`)
+  }
+})