fix: spread getConstructorParams tuples in download templates

lib/format-solver-constructor-call.ts

@@ -0,0 +1,11 @@
+/**
+ * `getConstructorParams()` returns either a tuple of constructor arguments or
+ * a legacy single-object value. Download templates must unpack tuples.
+ */
+export function getConstructorArgumentList(params: unknown): unknown[] {
+  return Array.isArray(params) ? params : [params]
+}
+
+export function formatNewSolverExpression(solverName: string): string {
+  return `new ${solverName}(...(Array.isArray(input) ? input : [input]) as any)`
+}

lib/react/DownloadDropdown.tsx

@@ -1,5 +1,6 @@
-import { useState, useRef, useEffect } from "react"
+import { useEffect, useRef, useState } from "react"
 import type { BaseSolver } from "../BaseSolver"
+import { formatNewSolverExpression } from "../format-solver-constructor-call"
 
 interface DownloadDropdownProps {
   solver: BaseSolver
@@ -102,7 +103,8 @@ export const inputProblem = ${JSON.stringify(params, null, 2)}
 
 export default () => {
   const solver = useMemo(() => {
-    return new ${solverName}(inputProblem as any)
+    const input = inputProblem
+    return ${formatNewSolverExpression(solverName)}
   }, [])
   return <GenericSolverDebugger solver={solver} />
 }
@@ -137,7 +139,7 @@ import { test, expect } from "bun:test"
 test("${solverName} should solve problem correctly", () => {
   const input = ${JSON.stringify(params, null, 2)}
 
-  const solver = new ${solverName}(input as any)
+  const solver = ${formatNewSolverExpression(solverName)}
   solver.solve()
 
   expect(solver).toMatchSolverSnapshot(import.meta.path)

tests/format-solver-constructor-call.test.ts

@@ -0,0 +1,52 @@
+import { expect, test } from "bun:test"
+import {
+  formatNewSolverExpression,
+  getConstructorArgumentList,
+} from "../lib/format-solver-constructor-call"
+
+test("unpacks constructor-param tuples instead of nesting them", () => {
+  expect(getConstructorArgumentList([])).toEqual([])
+  expect(getConstructorArgumentList([{ limit: 7 }])).toEqual([{ limit: 7 }])
+  expect(getConstructorArgumentList([{ limit: 7 }, 3])).toEqual([
+    { limit: 7 },
+    3,
+  ])
+  expect(getConstructorArgumentList([[1, 2, 3]])).toEqual([[1, 2, 3]])
+})
+
+test("wraps a legacy plain-object return as a single argument", () => {
+  expect(getConstructorArgumentList({ limit: 7 })).toEqual([{ limit: 7 }])
+})
+
+test("generated construction spreads tuples into the constructor", () => {
+  class ProbeSolver {
+    input: { limit: number }
+    scale: number | undefined
+    constructor(input: { limit: number }, scale?: number) {
+      this.input = input
+      this.scale = scale
+    }
+  }
+
+  const cases: Array<{ params: unknown; expected: [unknown, unknown?] }> = [
+    { params: [], expected: [undefined, undefined] },
+    { params: [{ limit: 7 }], expected: [{ limit: 7 }, undefined] },
+    { params: [{ limit: 7 }, 3], expected: [{ limit: 7 }, 3] },
+    { params: [[1, 2, 3]], expected: [[1, 2, 3], undefined] },
+    { params: { limit: 7 }, expected: [{ limit: 7 }, undefined] },
+  ]
+
+  expect(formatNewSolverExpression("ProbeSolver")).toBe(
+    "new ProbeSolver(...(Array.isArray(input) ? input : [input]) as any)",
+  )
+
+  for (const { params, expected } of cases) {
+    const solver = new ProbeSolver(
+      ...(getConstructorArgumentList(params) as [
+        { limit: number },
+        number | undefined,
+      ]),
+    )
+    expect([solver.input, solver.scale] as unknown[]).toEqual(expected)
+  }
+})