diff --git a/.changeset/honest-tables-impress.md b/.changeset/honest-tables-impress.md
new file mode 100644
index 0000000000..29dd4efe54
--- /dev/null
+++ b/.changeset/honest-tables-impress.md
@@ -0,0 +1,6 @@
+---
+"@khanacademy/perseus": major
+"@khanacademy/perseus-dev-ui": patch
+---
+
+Change ServerItemRenderer scoring APIs to externalize scoring
diff --git a/dev/flipbook.tsx b/dev/flipbook.tsx
index f6dde1281c..ea05772598 100644
--- a/dev/flipbook.tsx
+++ b/dev/flipbook.tsx
@@ -18,6 +18,7 @@ import {useEffect, useMemo, useReducer, useRef, useState} from "react";
 
 import {Renderer} from "../packages/perseus/src";
 import {SvgImage} from "../packages/perseus/src/components";
+import {scorePerseusItem} from "../packages/perseus/src/renderer-util";
 import {mockStrings} from "../packages/perseus/src/strings";
 import {isCorrect} from "../packages/perseus/src/util";
 import {trueForAllMafsSupportedGraphTypes} from "../packages/perseus/src/widgets/interactive-graphs/mafs-supported-graph-types";
@@ -319,7 +320,15 @@ function GradableRenderer(props: QuestionRendererProps) {
                 leftContent={
                     <Button
                         onClick={() => {
-                            setScore(rendererRef.current?.score());
+                            if (rendererRef.current) {
+                                const score = scorePerseusItem(
+                                    question,
+                                    rendererRef.current.getUserInputMap(),
+                                    mockStrings,
+                                    "en",
+                                );
+                                setScore(score);
+                            }
                             clearScoreTimeout.set();
                         }}
                     >
diff --git a/packages/perseus/src/components/__tests__/sorter.test.tsx b/packages/perseus/src/components/__tests__/sorter.test.tsx
index 467bbe43d2..2101d87ff8 100644
--- a/packages/perseus/src/components/__tests__/sorter.test.tsx
+++ b/packages/perseus/src/components/__tests__/sorter.test.tsx
@@ -76,15 +76,13 @@ describe("sorter widget", () => {
         const {renderer} = renderQuestion(question1, apiOptions);
         const sorter = renderer.findWidgets("sorter 1")[0];
 
+        // Act
         // Put the options in the correct order
-
         ["$0.005$ kilograms", "$15$ grams", "$55$ grams"].forEach((option) => {
             act(() => sorter.moveOptionToIndex(option, 3));
         });
-        // Act
-        renderer.guessAndScore();
 
-        // assert
+        // Assert
         expect(renderer).toHaveBeenAnsweredCorrectly();
     });
     it("can be answered incorrectly", () => {
@@ -95,6 +93,7 @@ describe("sorter widget", () => {
         const {renderer} = renderQuestion(question1, apiOptions);
         const sorter = renderer.findWidgets("sorter 1")[0];
 
+        // Act
         // Put the options in the reverse order
         ["$0.005$ kilograms", "$15$ grams", "$55$ grams"].forEach(
             (option, index) => {
@@ -102,10 +101,7 @@ describe("sorter widget", () => {
             },
         );
 
-        // Act
-        renderer.guessAndScore();
-
-        // assert
+        // Assert
         expect(renderer).toHaveBeenAnsweredIncorrectly();
     });
 });
diff --git a/packages/perseus/src/index.ts b/packages/perseus/src/index.ts
index ecf8aab1b7..f8f4c96dd5 100644
--- a/packages/perseus/src/index.ts
+++ b/packages/perseus/src/index.ts
@@ -18,6 +18,7 @@ export {default as ServerItemRenderer} from "./server-item-renderer";
 export {default as HintsRenderer} from "./hints-renderer";
 export {default as HintRenderer} from "./hint-renderer";
 export {default as Renderer} from "./renderer";
+export {scorePerseusItem} from "./renderer-util";
 
 /**
  * Widgets
@@ -224,6 +225,7 @@ export type {
     PerseusWidgetsMap,
     MultiItem,
 } from "./perseus-types";
+export type {UserInputMap} from "./validation.types";
 export type {Coord} from "./interactive2/types";
 export type {MarkerType} from "./widgets/label-image/types";
 
diff --git a/packages/perseus/src/interactive2/objective_.ts b/packages/perseus/src/interactive2/objective_.ts
index 9dd605e5da..49cadd8b14 100644
--- a/packages/perseus/src/interactive2/objective_.ts
+++ b/packages/perseus/src/interactive2/objective_.ts
@@ -46,7 +46,7 @@ const mapObject = function <K extends string, V, U>(
     lambda: (arg1: V, arg2: K) => U,
 ): Record<K, U> {
     const result: Record<string, any> = {};
-    _.each(_.keys(obj), function (key) {
+    Object.keys(obj).forEach((key) => {
         // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'K'.
         result[key] = lambda(obj[key], key);
     });
@@ -66,7 +66,7 @@ const mapObjectFromArray = function <K extends string, V>(
     lambda: (arg1: K) => V,
 ): Record<K, V> {
     const result: Record<string, any> = {};
-    _.each(arr, function (elem) {
+    arr.forEach((elem) => {
         result[elem] = lambda(elem);
     });
     return result;
diff --git a/packages/perseus/src/renderer-util.test.ts b/packages/perseus/src/renderer-util.test.ts
index a9e80c78b7..4b32b8471e 100644
--- a/packages/perseus/src/renderer-util.test.ts
+++ b/packages/perseus/src/renderer-util.test.ts
@@ -1,33 +1,99 @@
-import {emptyWidgetsFunctional, scoreWidgetsFunctional} from "./renderer-util";
+import {screen} from "@testing-library/react";
+import {userEvent as userEventLib} from "@testing-library/user-event";
+
+import {
+    testDependencies,
+    testDependenciesV2,
+} from "../../../testing/test-dependencies";
+
+import * as Dependencies from "./dependencies";
+import {
+    emptyWidgetsFunctional,
+    scorePerseusItem,
+    scoreWidgetsFunctional,
+} from "./renderer-util";
 import {mockStrings} from "./strings";
 import {registerAllWidgetsForTesting} from "./util/register-all-widgets-for-testing";
-
-import type {DropdownWidget, PerseusWidgetsMap} from "./perseus-types";
+import {renderQuestion} from "./widgets/__testutils__/renderQuestion";
+import {question1} from "./widgets/group/group.testdata";
+
+import type {
+    DropdownWidget,
+    ExpressionWidget,
+    PerseusWidgetsMap,
+} from "./perseus-types";
 import type {UserInputMap} from "./validation.types";
-
-const testDropdownWidget: DropdownWidget = {
-    type: "dropdown",
-    options: {
-        choices: [
-            {
-                content: "Test choice 1",
-                correct: true,
-            },
-            {
-                content: "Test choice 2",
-                correct: false,
-            },
-        ],
-        placeholder: "Test placeholder",
-        static: false,
-    },
-};
+import type {UserEvent} from "@testing-library/user-event";
+
+function getTestDropdownWidget(): DropdownWidget {
+    return {
+        type: "dropdown",
+        options: {
+            choices: [
+                {
+                    content: "Test choice 1",
+                    correct: true,
+                },
+                {
+                    content: "Test choice 2",
+                    correct: false,
+                },
+            ],
+            placeholder: "Test placeholder",
+            static: false,
+        },
+    };
+}
+
+function getExpressionWidget(): ExpressionWidget {
+    return {
+        type: "expression",
+        version: {major: 1, minor: 0},
+        options: {
+            times: false,
+            buttonSets: ["basic"],
+            functions: [],
+            answerForms: [
+                {
+                    form: false,
+                    simplify: false,
+                    value: "2+2",
+                    considered: "correct",
+                },
+            ],
+        },
+    };
+}
+
+function getLegacyExpressionWidget() {
+    return {
+        type: "expression",
+        options: {
+            times: false,
+            buttonSets: ["basic"],
+            functions: [],
+            form: false,
+            simplify: false,
+            value: "2+2",
+        },
+    };
+}
 
 describe("emptyWidgetsFunctional", () => {
     beforeAll(() => {
         registerAllWidgetsForTesting();
     });
 
+    beforeEach(() => {
+        jest.spyOn(testDependenciesV2.analytics, "onAnalyticsEvent");
+        jest.spyOn(Dependencies, "getDependencies").mockReturnValue(
+            testDependencies,
+        );
+        jest.spyOn(Dependencies, "useDependencies").mockReturnValue(
+            testDependenciesV2,
+        );
+    });
+
     it("returns an empty array if there are no widgets", () => {
         // Arrange / Act
         const result = emptyWidgetsFunctional({}, [], {}, mockStrings, "en");
@@ -39,7 +105,7 @@ describe("emptyWidgetsFunctional", () => {
     it("properly identifies empty widgets", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -64,7 +130,7 @@ describe("emptyWidgetsFunctional", () => {
     it("does not return widget IDs that are not empty", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -89,7 +155,7 @@ describe("emptyWidgetsFunctional", () => {
     it("does not check for empty widgets whose IDs aren't provided", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = [];
         const userInputMap: UserInputMap = {
@@ -114,8 +180,8 @@ describe("emptyWidgetsFunctional", () => {
     it("can properly split empty and non-empty widgets", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
-            "dropdown 2": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
+            "dropdown 2": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1", "dropdown 2"];
         const userInputMap: UserInputMap = {
@@ -148,7 +214,7 @@ describe("emptyWidgetsFunctional", () => {
                 options: {
                     content: "[[☃ dropdown 1]]",
                     widgets: {
-                        "dropdown 1": testDropdownWidget,
+                        "dropdown 1": getTestDropdownWidget(),
                     },
                     images: {},
                 },
@@ -184,7 +250,7 @@ describe("emptyWidgetsFunctional", () => {
                 options: {
                     content: "[[☃ dropdown 1]]",
                     widgets: {
-                        "dropdown 1": testDropdownWidget,
+                        "dropdown 1": getTestDropdownWidget(),
                     },
                     images: {},
                 },
@@ -211,6 +277,98 @@ describe("emptyWidgetsFunctional", () => {
         // Assert
         expect(result).toEqual([]);
     });
+
+    it("handles an empty modern Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getExpressionWidget(),
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "",
+        };
+
+        // Act
+        const result = emptyWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result).toEqual(["expression 1"]);
+    });
+
+    it("upgrades an empty legacy Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getLegacyExpressionWidget() as any,
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "",
+        };
+
+        // Act
+        const result = emptyWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result).toEqual(["expression 1"]);
+    });
+
+    it("handles a non-empty modern Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getExpressionWidget(),
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+2",
+        };
+
+        // Act
+        const result = emptyWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result).toEqual([]);
+    });
+
+    it("upgrades a non-empty legacy Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getLegacyExpressionWidget() as any,
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+2",
+        };
+
+        // Act
+        const result = emptyWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result).toEqual([]);
+    });
 });
 
 describe("scoreWidgetsFunctional", () => {
@@ -218,6 +376,16 @@ describe("scoreWidgetsFunctional", () => {
         registerAllWidgetsForTesting();
     });
 
+    beforeEach(() => {
+        jest.spyOn(testDependenciesV2.analytics, "onAnalyticsEvent");
+        jest.spyOn(Dependencies, "getDependencies").mockReturnValue(
+            testDependencies,
+        );
+        jest.spyOn(Dependencies, "useDependencies").mockReturnValue(
+            testDependenciesV2,
+        );
+    });
+
     it("returns an empty object when there's no widgets", () => {
         // Arrange / Act
         const result = scoreWidgetsFunctional({}, [], {}, mockStrings, "en");
@@ -229,7 +397,7 @@ describe("scoreWidgetsFunctional", () => {
     it("returns invalid if widget is unanswered", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -254,7 +422,7 @@ describe("scoreWidgetsFunctional", () => {
     it("can determine if a widget was answered correctly", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -279,7 +447,7 @@ describe("scoreWidgetsFunctional", () => {
     it("can determine if a widget was answered incorrectly", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -304,8 +472,8 @@ describe("scoreWidgetsFunctional", () => {
     it("can handle multiple widgets", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
-            "dropdown 2": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
+            "dropdown 2": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1", "dropdown 2"];
         const userInputMap: UserInputMap = {
@@ -334,8 +502,8 @@ describe("scoreWidgetsFunctional", () => {
     it("skips widgets not in widgetIds", () => {
         // Arrange
         const widgets: PerseusWidgetsMap = {
-            "dropdown 1": testDropdownWidget,
-            "dropdown 2": testDropdownWidget,
+            "dropdown 1": getTestDropdownWidget(),
+            "dropdown 2": getTestDropdownWidget(),
         };
         const widgetIds: Array<string> = ["dropdown 1"];
         const userInputMap: UserInputMap = {
@@ -369,7 +537,7 @@ describe("scoreWidgetsFunctional", () => {
                 options: {
                     content: "[[☃ dropdown 1]]",
                     widgets: {
-                        "dropdown 1": testDropdownWidget,
+                        "dropdown 1": getTestDropdownWidget(),
                     },
                     images: {},
                 },
@@ -405,7 +573,7 @@ describe("scoreWidgetsFunctional", () => {
                 options: {
                     content: "[[☃ dropdown 1]]",
                     widgets: {
-                        "dropdown 1": testDropdownWidget,
+                        "dropdown 1": getTestDropdownWidget(),
                     },
                     images: {},
                 },
@@ -441,7 +609,7 @@ describe("scoreWidgetsFunctional", () => {
                 options: {
                     content: "[[☃ dropdown 1]]",
                     widgets: {
-                        "dropdown 1": testDropdownWidget,
+                        "dropdown 1": getTestDropdownWidget(),
                     },
                     images: {},
                 },
@@ -468,4 +636,135 @@ describe("scoreWidgetsFunctional", () => {
         // Assert
         expect(result["group 1"]).toHaveBeenAnsweredIncorrectly();
     });
+
+    it("can handle a correct modern Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getExpressionWidget(),
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+2",
+        };
+
+        // Act
+        const result = scoreWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result["expression 1"]).toHaveBeenAnsweredCorrectly();
+    });
+
+    it("can handle a correct legacy Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getLegacyExpressionWidget() as any,
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+2",
+        };
+
+        // Act
+        const result = scoreWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result["expression 1"]).toHaveBeenAnsweredCorrectly();
+    });
+
+    it("can handle an incorrect modern Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getExpressionWidget(),
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+42",
+        };
+
+        // Act
+        const result = scoreWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result["expression 1"]).toHaveBeenAnsweredIncorrectly();
+    });
+
+    it("can handle an incorrect legacy Expression widget", () => {
+        // Arrange
+        const widgets: PerseusWidgetsMap = {
+            "expression 1": getLegacyExpressionWidget() as any,
+        };
+        const widgetIds: Array<string> = ["expression 1"];
+        const userInputMap: UserInputMap = {
+            "expression 1": "2+42",
+        };
+
+        // Act
+        const result = scoreWidgetsFunctional(
+            widgets,
+            widgetIds,
+            userInputMap,
+            mockStrings,
+            "en",
+        );
+
+        // Assert
+        expect(result["expression 1"]).toHaveBeenAnsweredIncorrectly();
+    });
+});
+
+describe("scorePerseusItem", () => {
+    let userEvent: UserEvent;
+    beforeEach(() => {
+        userEvent = userEventLib.setup({
+            advanceTimers: jest.advanceTimersByTime,
+        });
+    });
+
+    it("should return score from contained Renderer", async () => {
+        // Arrange
+        const {renderer} = renderQuestion(question1);
+        // Answer all widgets correctly
+        await userEvent.click(screen.getAllByRole("radio")[4]);
+        // Note(jeremy): If we don't tab away from the radio button in this
+        // test, it seems like the userEvent typing doesn't land in the first
+        // text field.
+        await userEvent.tab();
+        await userEvent.type(
+            screen.getByRole("textbox", {name: /nearest ten/}),
+            "230",
+        );
+        await userEvent.type(
+            screen.getByRole("textbox", {name: /nearest hundred/}),
+            "200",
+        );
+        const userInput = renderer.getUserInputMap();
+        const score = scorePerseusItem(question1, userInput, mockStrings, "en");
+
+        // Assert
+        expect(score).toHaveBeenAnsweredCorrectly();
+        expect(score).toEqual({
+            earned: 3,
+            message: null,
+            total: 3,
+            type: "points",
+        });
+    });
 });
diff --git a/packages/perseus/src/renderer-util.ts b/packages/perseus/src/renderer-util.ts
index ccc423afdc..cc332f8713 100644
--- a/packages/perseus/src/renderer-util.ts
+++ b/packages/perseus/src/renderer-util.ts
@@ -1,11 +1,40 @@
+import Objective from "./interactive2/objective_";
 import Util from "./util";
-import {getWidgetScorer} from "./widgets";
+import {getWidgetIdsFromContent} from "./widget-type-utils";
+import {getWidgetScorer, upgradeWidgetInfoToLatestVersion} from "./widgets";
 
-import type {PerseusWidgetsMap} from "./perseus-types";
+import type {PerseusRenderer, PerseusWidgetsMap} from "./perseus-types";
 import type {PerseusStrings} from "./strings";
 import type {PerseusScore} from "./types";
 import type {UserInput, UserInputMap} from "./validation.types";
 
+const {mapObject} = Objective;
+
+export function getUpgradedWidgetOptions(
+    oldWidgetOptions: PerseusWidgetsMap,
+): PerseusWidgetsMap {
+    // @ts-expect-error - TS2322 - Type '(props: Props) => Partial<Record<string, CategorizerWidget | CSProgramWidget | DefinitionWidget | DropdownWidget | ... 35 more ... | VideoWidget>>' is not assignable to type '(props: Props) => { [key: string]: PerseusWidget; }'.
+    return mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
+        if (!widgetInfo.type || !widgetInfo.alignment) {
+            const newValues: Record<string, any> = {};
+
+            if (!widgetInfo.type) {
+                // TODO: why does widget have no type?
+                // We don't want to derive type from widget ID
+                // see: LEMS-1845
+                newValues.type = widgetId.split(" ")[0];
+            }
+
+            if (!widgetInfo.alignment) {
+                newValues.alignment = "default";
+            }
+
+            widgetInfo = {...widgetInfo, ...newValues};
+        }
+        return upgradeWidgetInfoToLatestVersion(widgetInfo);
+    });
+}
+
 export function emptyWidgetsFunctional(
     widgets: PerseusWidgetsMap,
     // This is a port of old code, I'm not sure why
@@ -15,8 +44,10 @@ export function emptyWidgetsFunctional(
     strings: PerseusStrings,
     locale: string,
 ): ReadonlyArray<string> {
+    const upgradedWidgets = getUpgradedWidgetOptions(widgets);
+
     return widgetIds.filter((id) => {
-        const widget = widgets[id];
+        const widget = upgradedWidgets[id];
         if (!widget || widget.static) {
             // Static widgets shouldn't count as empty
             return false;
@@ -50,17 +81,43 @@ export function emptyWidgetsFunctional(
     });
 }
 
+// TODO: combine scorePerseusItem with scoreWidgetsFunctional
+// once scorePerseusItem is the only one calling scoreWidgetsFunctional
+export function scorePerseusItem(
+    perseusRenderData: PerseusRenderer,
+    userInputMap: UserInputMap,
+    // TODO(LEMS-2461,LEMS-2391): these probably
+    // need to be removed before we move this to the server
+    strings: PerseusStrings,
+    locale: string,
+): PerseusScore {
+    // There seems to be a chance that PerseusRenderer.widgets might include
+    // widget data for widgets that are not in PerseusRenderer.content,
+    // so this checks that the widgets are being used before scoring them
+    const usedWidgetIds = getWidgetIdsFromContent(perseusRenderData.content);
+    const scores = scoreWidgetsFunctional(
+        perseusRenderData.widgets,
+        usedWidgetIds,
+        userInputMap,
+        strings,
+        locale,
+    );
+    return Util.flattenScores(scores);
+}
+
 export function scoreWidgetsFunctional(
     widgets: PerseusWidgetsMap,
     // This is a port of old code, I'm not sure why
     // we need widgetIds vs the keys of the widgets object
-    widgetIds: Array<string>,
+    widgetIds: ReadonlyArray<string>,
     userInputMap: UserInputMap,
     strings: PerseusStrings,
     locale: string,
 ): {[widgetId: string]: PerseusScore} {
+    const upgradedWidgets = getUpgradedWidgetOptions(widgets);
+
     const gradedWidgetIds = widgetIds.filter((id) => {
-        const props = widgets[id];
+        const props = upgradedWidgets[id];
         const widgetIsGraded: boolean = props?.graded == null || props.graded;
         const widgetIsStatic = !!props?.static;
         // Ungraded widgets or widgets set to static shouldn't be graded.
@@ -69,7 +126,7 @@ export function scoreWidgetsFunctional(
 
     const widgetScores: Record<string, PerseusScore> = {};
     gradedWidgetIds.forEach((id) => {
-        const widget = widgets[id];
+        const widget = upgradedWidgets[id];
         if (!widget) {
             return;
         }
@@ -79,7 +136,7 @@ export function scoreWidgetsFunctional(
         if (widget.type === "group") {
             const scores = scoreWidgetsFunctional(
                 widget.options.widgets,
-                Object.keys(widget.options.widgets),
+                getWidgetIdsFromContent(widget.options.content),
                 userInputMap[id] as UserInputMap,
                 strings,
                 locale,
diff --git a/packages/perseus/src/renderer.tsx b/packages/perseus/src/renderer.tsx
index 41e383a641..e2f291c589 100644
--- a/packages/perseus/src/renderer.tsx
+++ b/packages/perseus/src/renderer.tsx
@@ -25,7 +25,11 @@ import {Log} from "./logging/log";
 import {ClassNames as ApiClassNames, ApiOptions} from "./perseus-api";
 import PerseusMarkdown from "./perseus-markdown";
 import QuestionParagraph from "./question-paragraph";
-import {emptyWidgetsFunctional, scoreWidgetsFunctional} from "./renderer-util";
+import {
+    emptyWidgetsFunctional,
+    getUpgradedWidgetOptions,
+    scoreWidgetsFunctional,
+} from "./renderer-util";
 import TranslationLinter from "./translation-linter";
 import Util from "./util";
 import preprocessTex from "./util/tex-preprocess";
@@ -438,38 +442,13 @@ class Renderer
         widgetInfo: State["widgetInfo"];
         widgetProps: State["widgetProps"];
     } = (props: Props) => {
-        const allWidgetInfo = this._getAllWidgetsInfo(props);
+        const allWidgetInfo = getUpgradedWidgetOptions(props.widgets);
         return {
             widgetInfo: allWidgetInfo,
             widgetProps: this._getAllWidgetsStartProps(allWidgetInfo, props),
         };
     };
 
-    // @ts-expect-error - TS2322 - Type '(props: Props) => Partial<Record<string, CategorizerWidget | CSProgramWidget | DefinitionWidget | DropdownWidget | ... 35 more ... | VideoWidget>>' is not assignable to type '(props: Props) => { [key: string]: PerseusWidget; }'.
-    _getAllWidgetsInfo: (props: Props) => PerseusWidgetsMap = (
-        props: Props,
-    ) => {
-        return mapObject(props.widgets, (widgetInfo, widgetId) => {
-            if (!widgetInfo.type || !widgetInfo.alignment) {
-                const newValues: Record<string, any> = {};
-
-                if (!widgetInfo.type) {
-                    // TODO: why does widget have no type?
-                    // We don't want to derive type from widget ID
-                    // see: LEMS-1845
-                    newValues.type = widgetId.split(" ")[0];
-                }
-
-                if (!widgetInfo.alignment) {
-                    newValues.alignment = "default";
-                }
-
-                widgetInfo = _.extend({}, widgetInfo, newValues);
-            }
-            return Widgets.upgradeWidgetInfoToLatestVersion(widgetInfo);
-        });
-    };
-
     _getAllWidgetsStartProps: (
         allWidgetInfo: PerseusWidgetsMap,
         props: Props,
@@ -1124,7 +1103,7 @@ class Renderer
             // /cry(aria)
             this._foundTextNodes = true;
 
-            if (_.contains(this.widgetIds, node.id)) {
+            if (this.widgetIds.includes(node.id)) {
                 // We don't want to render a duplicate widget key/ref,
                 // as this causes problems with react (for obvious
                 // reasons). Instead we just notify the
@@ -1510,7 +1489,7 @@ class Renderer
 
     getInputPaths: () => ReadonlyArray<FocusPath> = () => {
         const inputPaths: Array<FocusPath> = [];
-        _.each(this.widgetIds, (widgetId: string) => {
+        this.widgetIds.forEach((widgetId: string) => {
             const widget = this.getWidgetInstance(widgetId);
             if (widget && widget.getInputPaths) {
                 // Grab all input paths and add widgetID to the front
@@ -1518,7 +1497,7 @@ class Renderer
                 // Prefix paths with their widgetID and add to collective
                 // list of paths.
                 // @ts-expect-error - TS2345 - Argument of type '(inputPath: string) => void' is not assignable to parameter of type 'CollectionIterator<FocusPath, void, readonly FocusPath[]>'.
-                _.each(widgetInputPaths, (inputPath: string) => {
+                widgetInputPaths.forEach((inputPath: string) => {
                     const relativeInputPath = [widgetId].concat(inputPath);
                     inputPaths.push(relativeInputPath);
                 });
@@ -1742,46 +1721,42 @@ class Renderer
     }
 
     /**
-     * Returns an object mapping from widget ID to perseus-style score.
-     * The keys of this object are the values of the array returned
-     * from `getWidgetIds`.
+     * Scores the content.
+     *
+     * @deprecated use scorePerseusItem
      */
-    scoreWidgets(): {[widgetId: string]: PerseusScore} {
-        return scoreWidgetsFunctional(
+    score(): PerseusScore {
+        const scores = scoreWidgetsFunctional(
             this.state.widgetInfo,
             this.widgetIds,
             this.getUserInputMap(),
             this.props.strings,
             this.context.locale,
         );
-    }
-
-    /**
-     * Grades the content.
-     */
-    score(): PerseusScore {
-        const scores = this.scoreWidgets();
         const combinedScore = Util.flattenScores(scores);
         return combinedScore;
     }
 
-    guessAndScore(): [UserInputArray, PerseusScore] {
+    /**
+     * @deprecated use scorePerseusItem
+     */
+    guessAndScore: () => [UserInputArray, PerseusScore] = () => {
         const totalGuess = this.getUserInput();
         const totalScore = this.score();
 
         return [totalGuess, totalScore];
-    }
+    };
 
     examples: () => ReadonlyArray<string> | null | undefined = () => {
         const widgetIds = this.widgetIds;
-        const examples = _.compact(
-            _.map(widgetIds, (widgetId) => {
+        const examples = widgetIds
+            .map((widgetId) => {
                 const widget = this.getWidgetInstance(widgetId);
                 return widget != null && widget.examples
                     ? widget.examples()
                     : null;
-            }),
-        );
+            })
+            .filter(Boolean);
 
         // no widgets with examples
         if (!examples.length) {
diff --git a/packages/perseus/src/server-item-renderer.tsx b/packages/perseus/src/server-item-renderer.tsx
index 41476dc8d7..f842ad5e13 100644
--- a/packages/perseus/src/server-item-renderer.tsx
+++ b/packages/perseus/src/server-item-renderer.tsx
@@ -19,6 +19,7 @@ import HintsRenderer from "./hints-renderer";
 import LoadingContext from "./loading-context";
 import {ApiOptions} from "./perseus-api";
 import Renderer from "./renderer";
+import {scorePerseusItem} from "./renderer-util";
 import Util from "./util";
 
 import type {PerseusItem, ShowSolutions} from "./perseus-types";
@@ -27,6 +28,7 @@ import type {
     PerseusDependenciesV2,
     SharedRendererProps,
 } from "./types";
+import type {UserInputArray, UserInputMap} from "./validation.types";
 import type {
     GetPromptJSONInterface,
     RendererPromptJSON,
@@ -42,6 +44,7 @@ import type {PropsFor} from "@khanacademy/wonder-blocks-core";
 type OwnProps = {
     hintsVisible?: number;
     item: PerseusItem;
+    score?: KEScore | null;
     problemNum?: number;
     reviewMode?: boolean;
     keypadElement?: KeypadAPI | null | undefined;
@@ -60,10 +63,23 @@ type DefaultProps = Required<
 >;
 
 type State = {
+    /**
+     * questionCompleted is used to signal that a learner has attempted
+     * the exercise. This is used when widgets want to show things like
+     * rationale or partial correctness.
+     */
     questionCompleted: boolean;
-    questionHighlightedWidgets: ReadonlyArray<any>;
-    // Keeps track of whether each asset (SvgImage or TeX) rendered by
-    // the questionRenderer has finished loading or rendering.
+    /**
+     * As far as I can tell, this is used to highlight empty widgets
+     * after a learner has clicked the "check" button. I don't think this could
+     * still be used though, because the "check" button is disabled while there
+     * are empty widgets.
+     */
+    questionHighlightedWidgets: ReadonlyArray<string>;
+    /**
+     * Keeps track of whether each asset (SvgImage or TeX) rendered by
+     * the questionRenderer has finished loading or rendering.
+     */
     assetStatuses: {
         [assetKey: string]: boolean;
     };
@@ -139,6 +155,16 @@ export class ServerItemRenderer
                 this.props.onRendered(true);
             }
         }
+
+        if (this.props.score && this.props.score !== prevProps.score) {
+            const emptyQuestionAreaWidgets =
+                this.questionRenderer.emptyWidgets();
+
+            this.setState({
+                questionCompleted: this.props.score.correct,
+                questionHighlightedWidgets: emptyQuestionAreaWidgets,
+            });
+        }
     }
 
     componentWillUnmount() {
@@ -305,18 +331,42 @@ export class ServerItemRenderer
         return this.questionRenderer.getPromptJSON();
     }
 
+    /**
+     * Returns an array of the widget `.getUserInput()` results
+     *
+     * TODO: can we remove this? Seems to be just for backwards
+     * compatibility with old Perseus Chrome logging
+     * @deprecated use getUserInput
+     */
+    getUserInputLegacy(): UserInputArray {
+        return this.questionRenderer.getUserInput();
+    }
+
+    /**
+     * Returns an object of the widget `.getUserInput()` results
+     */
+    getUserInput(): UserInputMap {
+        return this.questionRenderer.getUserInputMap();
+    }
+
     /**
      * Grades the item.
+     *
+     * @deprecated use scorePerseusItem
      */
     scoreInput(): KEScore {
-        const guessAndScore = this.questionRenderer.guessAndScore();
-        const guess = guessAndScore[0];
-        const score = guessAndScore[1];
+        const guess = this.getUserInput();
+        const score = scorePerseusItem(
+            this.props.item.question,
+            guess,
+            this.context.strings,
+            this.context.locale,
+        );
 
         // Continue to include an empty guess for the now defunct answer area.
         // TODO(alex): Check whether we rely on the format here for
         //             analyzing ProblemLogs. If not, remove this layer.
-        const maxCompatGuess = [guess, []];
+        const maxCompatGuess = [this.questionRenderer.getUserInput(), []];
 
         const keScore = Util.keScoreFromPerseusScore(
             score,
diff --git a/packages/perseus/src/types.ts b/packages/perseus/src/types.ts
index ec8da5f961..6cc7f2babc 100644
--- a/packages/perseus/src/types.ts
+++ b/packages/perseus/src/types.ts
@@ -666,6 +666,11 @@ export type WidgetProps<
     problemNum: number | null | undefined;
     apiOptions: APIOptionsWithDefaults;
     keypadElement?: any;
+    /**
+     * questionCompleted is used to signal that a learner has attempted
+     * the exercise. This is used when widgets want to show things like
+     * rationale or partial correctness.
+     */
     questionCompleted?: boolean;
     onFocus: (blurPath: FocusPath) => void;
     onBlur: (blurPath: FocusPath) => void;
diff --git a/packages/perseus/src/widgets/categorizer/categorizer.test.ts b/packages/perseus/src/widgets/categorizer/categorizer.test.ts
index d428a3b779..96517d76a1 100644
--- a/packages/perseus/src/widgets/categorizer/categorizer.test.ts
+++ b/packages/perseus/src/widgets/categorizer/categorizer.test.ts
@@ -3,6 +3,8 @@ import {userEvent as userEventLib} from "@testing-library/user-event";
 
 import {testDependencies} from "../../../../../testing/test-dependencies";
 import * as Dependencies from "../../dependencies";
+import {scorePerseusItem} from "../../renderer-util";
+import {mockStrings} from "../../strings";
 import {renderQuestion} from "../__testutils__/renderQuestion";
 
 import {Categorizer} from "./categorizer";
@@ -57,7 +59,12 @@ describe("categorizer widget", () => {
         const {renderer} = renderQuestion(question1, apiOptions);
 
         // Act
-        const [_, score] = renderer.guessAndScore();
+        const score = scorePerseusItem(
+            question1,
+            renderer.getUserInputMap(),
+            mockStrings,
+            "en",
+        );
 
         // Assert
         expect(score).toMatchInlineSnapshot(`
@@ -76,7 +83,12 @@ describe("categorizer widget", () => {
         await userEvent.click(firstItem);
 
         // act
-        const [_, score] = renderer.guessAndScore();
+        const score = scorePerseusItem(
+            question1,
+            renderer.getUserInputMap(),
+            mockStrings,
+            "en",
+        );
 
         // assert
         expect(score).toMatchInlineSnapshot(`
@@ -111,8 +123,6 @@ describe("categorizer widget", () => {
             })[1],
         );
 
-        renderer.guessAndScore();
-
         // assert
         expect(renderer).toHaveBeenAnsweredCorrectly();
     });
diff --git a/packages/perseus/src/widgets/definition/definition.test.ts b/packages/perseus/src/widgets/definition/definition.test.ts
index 261ba43d1a..d1fccca161 100644
--- a/packages/perseus/src/widgets/definition/definition.test.ts
+++ b/packages/perseus/src/widgets/definition/definition.test.ts
@@ -123,14 +123,11 @@ describe("Definition widget", () => {
     });
 
     it("should not affect answerable", () => {
-        // Arrange
+        // Arrange / Act
         const {renderer} = renderQuestion(question);
 
-        // Act
-        const result = renderer.scoreWidgets();
-
         // Assert
-        expect(result["definition 1"]).toHaveBeenAnsweredCorrectly({
+        expect(renderer).toHaveBeenAnsweredCorrectly({
             shouldHavePoints: false,
         });
     });
diff --git a/packages/perseus/src/widgets/deprecated-standin/__tests__/deprecated-standin.test.ts b/packages/perseus/src/widgets/deprecated-standin/__tests__/deprecated-standin.test.ts
index 93604de822..3aa8b98c69 100644
--- a/packages/perseus/src/widgets/deprecated-standin/__tests__/deprecated-standin.test.ts
+++ b/packages/perseus/src/widgets/deprecated-standin/__tests__/deprecated-standin.test.ts
@@ -41,13 +41,10 @@ describe("Deprecated Standin widget", () => {
     });
 
     it("should be scorable and always give points", () => {
-        // Arrange
+        // Arrange / Act
         const {renderer} = renderQuestion(question);
 
-        // Act
-        const result = renderer.scoreWidgets();
-
         // Assert
-        expect(result["widget 1"]).toHaveBeenAnsweredCorrectly();
+        expect(renderer).toHaveBeenAnsweredCorrectly();
     });
 });
diff --git a/packages/perseus/src/widgets/expression/expression.test.tsx b/packages/perseus/src/widgets/expression/expression.test.tsx
index 2f5ee2a239..278e6a873e 100644
--- a/packages/perseus/src/widgets/expression/expression.test.tsx
+++ b/packages/perseus/src/widgets/expression/expression.test.tsx
@@ -7,6 +7,8 @@ import {
     testDependenciesV2,
 } from "../../../../../testing/test-dependencies";
 import * as Dependencies from "../../dependencies";
+import {scorePerseusItem} from "../../renderer-util";
+import {mockStrings} from "../../strings";
 import {renderQuestion} from "../__testutils__/renderQuestion";
 
 import ExpressionWidgetExport from "./expression";
@@ -447,7 +449,12 @@ describe("Expression Widget", function () {
                 renderer.setInputValue(["expression 1"], "123-x", () => {}),
             );
             act(() => jest.runOnlyPendingTimers());
-            const score = renderer.guessAndScore()[1];
+            const score = scorePerseusItem(
+                expressionItem2.question,
+                renderer.getUserInputMap(),
+                mockStrings,
+                "en",
+            );
 
             // Assert
             expect(score.type).toBe("points");
@@ -467,7 +474,12 @@ describe("Expression Widget", function () {
             act(() => jest.runOnlyPendingTimers());
 
             // act
-            const score = renderer.score();
+            const score = scorePerseusItem(
+                expressionItem2.question,
+                renderer.getUserInputMap(),
+                mockStrings,
+                "en",
+            );
 
             // Assert
             // Score.total doesn't exist if the input is invalid
@@ -498,7 +510,6 @@ describe("Expression Widget", function () {
             act(() => jest.runOnlyPendingTimers());
             act(() => screen.getByRole("textbox").blur());
             act(() => jest.runOnlyPendingTimers());
-            renderer.guessAndScore();
 
             // Assert
             await waitFor(() =>
@@ -517,7 +528,6 @@ describe("Expression Widget", function () {
             act(() => expression.insert("sen(x)"));
             act(() => jest.runOnlyPendingTimers());
             act(() => screen.getByRole("textbox").blur());
-            renderer.guessAndScore();
 
             // Assert
             expect(screen.queryByText("Oops!")).toBeNull();
diff --git a/packages/perseus/src/widgets/group/group.test.tsx b/packages/perseus/src/widgets/group/group.test.tsx
index b4d1316bfb..7f090d3e46 100644
--- a/packages/perseus/src/widgets/group/group.test.tsx
+++ b/packages/perseus/src/widgets/group/group.test.tsx
@@ -8,6 +8,7 @@ import * as Perseus from "@khanacademy/perseus";
 
 import {testDependencies} from "../../../../../testing/test-dependencies";
 import * as Dependencies from "../../dependencies";
+import {scorePerseusItem} from "../../renderer-util";
 import {mockStrings} from "../../strings";
 import {traverse} from "../../traversal";
 import {renderQuestion} from "../__testutils__/renderQuestion";
@@ -413,10 +414,13 @@ describe("group widget", () => {
             screen.getByRole("textbox", {name: /nearest hundred/}),
             "200",
         );
-        const guessAndScore = renderer.guessAndScore();
+
+        const guess = renderer.getUserInputMap();
+        const score = scorePerseusItem(question1, guess, mockStrings, "en");
+        const guessAndScore = [renderer.getUserInput(), score];
 
         // Assert
-        expect(guessAndScore[1]).toHaveBeenAnsweredCorrectly();
+        expect(score).toHaveBeenAnsweredCorrectly();
         expect(guessAndScore).toMatchInlineSnapshot(`
             [
               [
diff --git a/packages/perseus/src/widgets/group/group.tsx b/packages/perseus/src/widgets/group/group.tsx
index 8affeafdb4..6df7646007 100644
--- a/packages/perseus/src/widgets/group/group.tsx
+++ b/packages/perseus/src/widgets/group/group.tsx
@@ -154,6 +154,8 @@ class Group extends React.Component<Props> implements Widget {
             }
         };
 
+        // TODO(LEMS-2391): replace this when there's a separate check
+        // for valid/invalid state
         const score = this.rendererRef?.score();
         const isValid = score && score.type !== "invalid";
         const isInvalid = score && score.type === "invalid";
diff --git a/packages/perseus/src/widgets/matcher/matcher.test.tsx b/packages/perseus/src/widgets/matcher/matcher.test.tsx
index 61872ecc16..c583ad1490 100644
--- a/packages/perseus/src/widgets/matcher/matcher.test.tsx
+++ b/packages/perseus/src/widgets/matcher/matcher.test.tsx
@@ -105,6 +105,7 @@ describe("matcher widget", () => {
         const {renderer} = renderQuestion(question1, apiOptions);
         await wait();
 
+        // Act
         const matcher: Matcher = renderer.findWidgets("matcher 1")[0];
 
         // Put the right options in the correct order by repeatedly moving
@@ -119,9 +120,6 @@ describe("matcher widget", () => {
             act(() => matcher.moveRightOptionToIndex(option, 4));
         });
 
-        // Act
-        renderer.guessAndScore();
-
         // assert
         expect(renderer).toHaveBeenAnsweredCorrectly();
     });
@@ -134,6 +132,7 @@ describe("matcher widget", () => {
         const {renderer} = renderQuestion(question1, apiOptions);
         await wait();
 
+        // Act
         const matcher: Matcher = renderer.findWidgets("matcher 1")[0];
 
         // Put the left options in reverse order
@@ -147,9 +146,6 @@ describe("matcher widget", () => {
             matcher.moveLeftOptionToIndex(option, 0);
         });
 
-        // Act
-        renderer.guessAndScore();
-
         // Assert
         expect(renderer).toHaveBeenAnsweredIncorrectly();
     });
@@ -164,14 +160,12 @@ describe("matcher widget", () => {
             },
         });
 
+        // Act
         const apiOptions: APIOptions = {
             isMobile: false,
         };
         const {renderer} = renderQuestion(question1, apiOptions);
 
-        // Act
-        renderer.guessAndScore();
-
         // Assert
         expect(renderer).toHaveBeenAnsweredIncorrectly();
     });
diff --git a/packages/perseus/src/widgets/matrix/matrix.test.ts b/packages/perseus/src/widgets/matrix/matrix.test.ts
index 05aebbdcad..27eee1a180 100644
--- a/packages/perseus/src/widgets/matrix/matrix.test.ts
+++ b/packages/perseus/src/widgets/matrix/matrix.test.ts
@@ -62,8 +62,6 @@ describe("matrix widget", () => {
             await userEvent.type(textboxes[i], correctAnswers[i].toString());
         }
 
-        renderer.guessAndScore();
-
         // assert
         expect(renderer).toHaveBeenAnsweredCorrectly();
     });
@@ -81,8 +79,6 @@ describe("matrix widget", () => {
             await userEvent.type(textboxes[i], "1");
         }
 
-        renderer.guessAndScore();
-
         // Assert
         expect(renderer).toHaveBeenAnsweredIncorrectly();
     });
diff --git a/packages/perseus/src/widgets/passage/__tests__/passage.test.tsx b/packages/perseus/src/widgets/passage/__tests__/passage.test.tsx
index fd3026773d..f34a76d644 100644
--- a/packages/perseus/src/widgets/passage/__tests__/passage.test.tsx
+++ b/packages/perseus/src/widgets/passage/__tests__/passage.test.tsx
@@ -5,6 +5,8 @@ import React from "react";
 import {testDependencies} from "../../../../../../testing/test-dependencies";
 import * as Dependencies from "../../../dependencies";
 import {ApiOptions} from "../../../perseus-api";
+import {scorePerseusItem} from "../../../renderer-util";
+import {mockStrings} from "../../../strings";
 import {renderQuestion} from "../../__testutils__/renderQuestion";
 import PassageWidgetExport, {LineHeightMeasurer} from "../passage";
 
@@ -133,7 +135,12 @@ describe("passage widget", () => {
         act(() => jest.runOnlyPendingTimers());
 
         // Act
-        const score = renderer.score();
+        const score = scorePerseusItem(
+            question2,
+            renderer.getUserInputMap(),
+            mockStrings,
+            "en",
+        );
 
         // Assert
         expect(score).toMatchInlineSnapshot(`
diff --git a/testing/renderer-with-debug-ui.tsx b/testing/renderer-with-debug-ui.tsx
index 322d81422f..e66ec3493b 100644
--- a/testing/renderer-with-debug-ui.tsx
+++ b/testing/renderer-with-debug-ui.tsx
@@ -10,6 +10,8 @@ import * as React from "react";
 import ReactJson from "react-json-view";
 
 import {Renderer, usePerseusI18n} from "../packages/perseus/src/index";
+import {scorePerseusItem} from "../packages/perseus/src/renderer-util";
+import {mockStrings} from "../packages/perseus/src/strings";
 import {registerAllWidgetsForTesting} from "../packages/perseus/src/util/register-all-widgets-for-testing";
 
 import SideBySide from "./side-by-side";
@@ -80,7 +82,14 @@ export const RendererWithDebugUI = ({
                                 if (!ref.current) {
                                     return;
                                 }
-                                setState(ref.current.guessAndScore());
+                                const guess = ref.current.getUserInputMap();
+                                const score = scorePerseusItem(
+                                    question,
+                                    ref.current.getUserInputMap(),
+                                    mockStrings,
+                                    "en",
+                                );
+                                setState([guess, score]);
                             }}
                         >
                             Check