@snaptrude/plugin-core 0.0.0-dev-20260907135026 → 0.0.0-dev-20260908074328

package/test/massParameters.test.mjs

@@ -1,500 +0,0 @@
-// 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 {
-  MassParametersRecord,
-  MassParametersPatch,
-  OperationRecord,
-  ContourRecord,
-  ProfileRecord,
-  CurveRecord,
-  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,
-  CurveHandle,
-  SplineHandle,
-  PluginGeomCreateBrepFromSweepArgs,
-  PluginGeomCreateBrepFromLoftArgs,
-  PluginGeomCreateBrepFromFilletArgs,
-  PluginGeomCreateBrepFromChamferArgs,
-  PluginGeomCreateBrepFromShellArgs,
-  PluginGeomCreateSplineFromControlPointsArgs,
-  PluginDesignUpdateParametersArgs,
-} 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)
-})