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

package/test/massParameters.test.mjs

@@ -1,952 +1,952 @@
-// 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,
-  ArenaKind,
-  PluginHandlesReleaseAllArgs,
-  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)
-})
-
-test("a spline handle is releasable like every other value handle", () => {
-  // ArenaKind types release / endScope(retain) and validates releaseAll's kind.
-  assert.equal(ArenaKind.safeParse("spline").success, true)
-  assert.equal(PluginHandlesReleaseAllArgs.safeParse({ kind: "spline" }).success, true)
-})
-
-test("CurveHandle keeps the union type that 0.9.13 shipped, so .options still compiles", () => {
-  const dts = readFileSync(new URL("../dist/handles.d.ts", import.meta.url), "utf8")
-  assert.ok(/declare const CurveHandle: z\.ZodUnion</.test(dts), "CurveHandle is not declared as a ZodUnion")
-  assert.equal(CurveHandle.options.length, 3)
-})
-
-// ── 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; 14,000 B is the ceiling asserted
-  // over ONE_SHOT_MODULES in the agent runtime (readApiFullMaxChars). It was
-  // 12,000 B until the grid and dimension handles took handles.d.ts past it on
-  // their own; both sides moved in the same change.
-  for (const name of ["handles", "massParameters", "massParameters.ops"]) {
-    const bytes = readFileSync(new URL(`../dist/${name}.d.ts`, import.meta.url)).byteLength
-    assert.ok(bytes < 14_000, `dist/${name}.d.ts is ${bytes} B, over the 14,000 B one-shot ceiling`)
-  }
-})
+// 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,
+  ArenaKind,
+  PluginHandlesReleaseAllArgs,
+  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)
+})
+
+test("a spline handle is releasable like every other value handle", () => {
+  // ArenaKind types release / endScope(retain) and validates releaseAll's kind.
+  assert.equal(ArenaKind.safeParse("spline").success, true)
+  assert.equal(PluginHandlesReleaseAllArgs.safeParse({ kind: "spline" }).success, true)
+})
+
+test("CurveHandle keeps the union type that 0.9.13 shipped, so .options still compiles", () => {
+  const dts = readFileSync(new URL("../dist/handles.d.ts", import.meta.url), "utf8")
+  assert.ok(/declare const CurveHandle: z\.ZodUnion</.test(dts), "CurveHandle is not declared as a ZodUnion")
+  assert.equal(CurveHandle.options.length, 3)
+})
+
+// ── 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; 14,000 B is the ceiling asserted
+  // over ONE_SHOT_MODULES in the agent runtime (readApiFullMaxChars). It was
+  // 12,000 B until the grid and dimension handles took handles.d.ts past it on
+  // their own; both sides moved in the same change.
+  for (const name of ["handles", "massParameters", "massParameters.ops"]) {
+    const bytes = readFileSync(new URL(`../dist/${name}.d.ts`, import.meta.url)).byteLength
+    assert.ok(bytes < 14_000, `dist/${name}.d.ts is ${bytes} B, over the 14,000 B one-shot ceiling`)
+  }
+})