@khanacademy/perseus 41.2.0 → 41.4.0

package/dist/perseus-api.d.ts

@@ -96,13 +96,13 @@ export declare const ApiOptions: {
                 circle?: boolean | undefined;
                 polygon?: boolean | undefined;
                 point?: boolean | undefined;
+                quadratic?: boolean | undefined;
+                sinusoid?: boolean | undefined;
                 angle?: boolean | undefined;
-                segment?: boolean | undefined;
                 "linear-system"?: boolean | undefined;
                 ray?: boolean | undefined;
+                segment?: boolean | undefined;
                 "unlimited-polygon"?: boolean | undefined;
-                quadratic?: boolean | undefined;
-                sinusoid?: boolean | undefined;
                 "unlimited-point"?: boolean | undefined;
             } & {
                 "interactive-graph-locked-features-labels"?: boolean | undefined;

package/dist/perseus-types.d.ts

@@ -85,6 +85,11 @@ export type PerseusItem = {
     itemDataVersion: Version;
     answer: any;
 };
+/**
+ * A "PerseusArticle" is an item that is meant to be rendered as an article.
+ * This item is never scored and is rendered by the `ArticleRenderer`.
+ */
+export type PerseusArticle = PerseusRenderer | ReadonlyArray<PerseusRenderer>;
 /**
  * A "MultiItem" is an advanced Perseus item. It is rendered by the
  * `MultiRenderer` and you can control the layout of individual parts of the
@@ -119,7 +124,7 @@ export type PerseusImageDetail = {
 };
 export declare const ItemExtras: readonly ["calculator", "chi2Table", "financialCalculatorMonthlyPayment", "financialCalculatorTotalAmount", "financialCalculatorTimeToPayOff", "periodicTable", "periodicTableWithKey", "tTable", "zTable"];
 export type PerseusAnswerArea = Record<(typeof ItemExtras)[number], boolean>;
-type WidgetOptions<Type extends string, Options> = {
+export type WidgetOptions<Type extends string, Options> = {
     type: Type;
     static?: boolean;
     graded?: boolean;
@@ -366,7 +371,7 @@ export type PerseusInteractiveGraphWidgetOptions = {
     fullGraphAriaLabel?: string;
     fullGraphAriaDescription?: string;
 };
-declare const lockedFigureColorNames: readonly ["blue", "green", "grayH", "purple", "pink", "orange", "red"];
+export declare const lockedFigureColorNames: readonly ["blue", "green", "grayH", "purple", "pink", "orange", "red"];
 export type LockedFigureColor = (typeof lockedFigureColorNames)[number];
 export declare const lockedFigureColors: Record<LockedFigureColor, string>;
 export type LockedFigure = LockedPointType | LockedLineType | LockedVectorType | LockedEllipseType | LockedPolygonType | LockedFunctionType | LockedLabelType;

package/dist/prompt-types.d.ts

@@ -0,0 +1,33 @@
+import type { CategorizerPromptJSON } from "./widget-ai-utils/categorizer/prompt-utils";
+import type { DefinitionPromptJSON } from "./widget-ai-utils/definition/prompt-utils";
+import type { DropdownPromptJSON } from "./widget-ai-utils/dropdown/prompt-utils";
+import type { ExplanationPromptJSON } from "./widget-ai-utils/explanation/prompt-utils";
+import type { ExpressionPromptJSON } from "./widget-ai-utils/expression/prompt-utils";
+import type { GradedGroupPromptJSON } from "./widget-ai-utils/graded-group/prompt-utils";
+import type { GradedGroupSetPromptJSON } from "./widget-ai-utils/graded-group-set/prompt-utils";
+import type { GrapherPromptJSON } from "./widget-ai-utils/grapher/prompt-utils";
+import type { GroupPromptJSON } from "./widget-ai-utils/group/prompt-utils";
+import type { ImagePromptJSON } from "./widget-ai-utils/image/prompt-utils";
+import type { InputNumberPromptJSON } from "./widget-ai-utils/input-number/prompt-utils";
+import type { LabelImagePromptJSON } from "./widget-ai-utils/label-image/prompt-utils";
+import type { MatcherPromptJSON } from "./widget-ai-utils/matcher/prompt-utils";
+import type { MatrixPromptJSON } from "./widget-ai-utils/matrix/prompt-utils";
+import type { NumberLinePromptJSON } from "./widget-ai-utils/number-line/prompt-utils";
+import type { NumericInputPromptJSON } from "./widget-ai-utils/numeric-input/prompt-utils";
+import type { OrdererPromptJSON } from "./widget-ai-utils/orderer/prompt-utils";
+import type { PassagePromptJSON } from "./widget-ai-utils/passage/prompt-utils";
+import type { PassageRefPromptJSON } from "./widget-ai-utils/passage-ref/prompt-utils";
+import type { RadioPromptJSON } from "./widget-ai-utils/radio/prompt-utils";
+import type { SorterPromptJSON } from "./widget-ai-utils/sorter/prompt-utils";
+import type { UnsupportedWidgetPromptJSON } from "./widget-ai-utils/unsupported-widget";
+export type UnsupportedWidget = "cs-program" | "iframe" | "interaction" | "interactive-graph-unsupported" | "measurer" | "phet-simulation" | "plotter" | "python-program" | "video";
+export type WidgetPromptJSON = CategorizerPromptJSON | DefinitionPromptJSON | DropdownPromptJSON | ExplanationPromptJSON | ExpressionPromptJSON | GradedGroupPromptJSON | GradedGroupSetPromptJSON | GrapherPromptJSON | GroupPromptJSON | ImagePromptJSON | InputNumberPromptJSON | LabelImagePromptJSON | MatcherPromptJSON | MatrixPromptJSON | NumberLinePromptJSON | NumericInputPromptJSON | OrdererPromptJSON | PassagePromptJSON | PassageRefPromptJSON | RadioPromptJSON | SorterPromptJSON | UnsupportedWidgetPromptJSON;
+export type RendererPromptJSON = {
+    content: string;
+    widgets: {
+        [widgetId: string]: WidgetPromptJSON;
+    };
+};
+export interface GetPromptJSONInterface {
+    getPromptJSON(): RendererPromptJSON;
+}

package/dist/renderer.d.ts

@@ -5,6 +5,7 @@ import TranslationLinter from "./translation-linter";
 import WidgetContainer from "./widget-container";
 import type { DependenciesContext } from "./dependencies";
 import type { PerseusRenderer, PerseusWidget, PerseusWidgetOptions, PerseusWidgetsMap, ShowSolutions } from "./perseus-types";
+import type { GetPromptJSONInterface, RendererPromptJSON } from "./prompt-types";
 import type { PerseusStrings } from "./strings";
 import type { APIOptions, APIOptionsWithDefaults, FilterCriterion, FocusPath, PerseusScore, SerializedState, Widget, WidgetProps } from "./types";
 import type { UserInputArray, UserInputMap } from "./validation.types";
@@ -70,7 +71,7 @@ type State = {
     lastUsedWidgetId: string | null | undefined;
 };
 type DefaultProps = Required<Pick<Props, "alwaysUpdate" | "content" | "findExternalWidgets" | "highlightedWidgets" | "images" | "linterContext" | "onInteractWithWidget" | "onRender" | "onSerializedStateUpdated" | "questionCompleted" | "showSolutions" | "reviewMode" | "serializedState" | "widgets">>;
-declare class Renderer extends React.Component<Props, State> {
+declare class Renderer extends React.Component<Props, State> implements GetPromptJSONInterface {
     static contextType: React.Context<{
         strings: PerseusStrings;
         locale: string;
@@ -107,7 +108,7 @@ declare class Renderer extends React.Component<Props, State> {
     _getDefaultWidgetInfo: (widgetId: string) => any;
     _getWidgetInfo: (widgetId: string) => PerseusWidget;
     renderWidget: (impliedType: string, id: string, state: WidgetState) => null | React.ReactNode;
-    getWidgetProps: (id: string) => WidgetProps<any, PerseusWidgetOptions>;
+    getWidgetProps(widgetId: string): WidgetProps<any, PerseusWidgetOptions>;
     /**
      * Serializes the questions state so it can be recovered.
      *
@@ -211,6 +212,11 @@ declare class Renderer extends React.Component<Props, State> {
      * the content.
      */
     getWidgetIds: () => ReadonlyArray<string>;
+    /**
+     * Returns a JSON representation of the content and widgets
+     * that can be passed to an LLM for prompt context.
+     */
+    getPromptJSON(): RendererPromptJSON;
     /**
      * Returns an object mapping from widget ID to perseus-style score.
      * The keys of this object are the values of the array returned

package/dist/server-item-renderer.d.ts

@@ -11,6 +11,7 @@ import * as React from "react";
 import { PerseusI18nContext } from "./components/i18n-context";
 import Renderer from "./renderer";
 import type { PerseusItem, ShowSolutions } from "./perseus-types";
+import type { GetPromptJSONInterface, RendererPromptJSON } from "./prompt-types";
 import type { FocusPath, PerseusDependenciesV2, SharedRendererProps } from "./types";
 import type { KeypadAPI } from "@khanacademy/math-input";
 import type { KeypadContextRendererInterface, RendererInterface, KEScore } from "@khanacademy/perseus-core";
@@ -39,7 +40,7 @@ type SerializedState = {
     question: any;
     hints: any;
 };
-export declare class ServerItemRenderer extends React.Component<Props, State> implements RendererInterface, KeypadContextRendererInterface {
+export declare class ServerItemRenderer extends React.Component<Props, State> implements RendererInterface, KeypadContextRendererInterface, GetPromptJSONInterface {
     static contextType: React.Context<{
         strings: import("./strings").PerseusStrings;
         locale: string;
@@ -74,6 +75,7 @@ export declare class ServerItemRenderer extends React.Component<Props, State> im
     focus(): boolean | null | undefined;
     blur(): void;
     getNumHints(): number;
+    getPromptJSON(): RendererPromptJSON;
     /**
      * Grades the item.
      */
@@ -134,13 +136,13 @@ declare const ref: React.ForwardRefExoticComponent<Omit<Pick<SharedRendererProps
                 circle?: boolean | undefined;
                 polygon?: boolean | undefined;
                 point?: boolean | undefined;
+                quadratic?: boolean | undefined;
+                sinusoid?: boolean | undefined;
                 angle?: boolean | undefined;
-                segment?: boolean | undefined;
                 "linear-system"?: boolean | undefined;
                 ray?: boolean | undefined;
+                segment?: boolean | undefined;
                 "unlimited-polygon"?: boolean | undefined;
-                quadratic?: boolean | undefined;
-                sinusoid?: boolean | undefined;
                 "unlimited-point"?: boolean | undefined;
             } & {
                 "interactive-graph-locked-features-labels"?: boolean | undefined;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { ILogger } from "./logging/log";
 import type { Item } from "./multi-items/item-types";
 import type { Hint, PerseusAnswerArea, PerseusGraphType, PerseusWidget, PerseusWidgetsMap } from "./perseus-types";
+import type { WidgetPromptJSON } from "./prompt-types";
 import type { PerseusStrings } from "./strings";
 import type { SizeClass } from "./util/sizing-utils";
 import type { Rubric, UserInput, UserInputArray, UserInputMap } from "./validation.types";
@@ -55,6 +56,7 @@ export interface Widget {
     getUserInput?: () => UserInputArray | UserInput | undefined;
     showRationalesForCurrentlySelectedChoices?: (options?: any) => void;
     examples?: () => ReadonlyArray<string>;
+    getPromptJSON?: () => WidgetPromptJSON;
 }
 export type ImageDict = {
     [url: string]: Dimensions;
@@ -352,7 +354,7 @@ type TrackingSequenceExtraArguments = {
 export type Alignment = "default" | "block" | "inline-block" | "inline" | "float-left" | "float-right" | "full-width";
 type WidgetOptions = any;
 export type WidgetTransform = (arg1: WidgetOptions, strings: PerseusStrings, problemNumber?: number) => any;
-export type WidgetValidatorFunction = (userInput: UserInput, rubric: Rubric, string?: PerseusStrings, locale?: string) => PerseusScore;
+export type WidgetScorerFunction = (userInput: UserInput, rubric: Rubric, string?: PerseusStrings, locale?: string) => PerseusScore;
 export type WidgetExports<T extends React.ComponentType<any> & Widget = React.ComponentType<any>> = Readonly<{
     name: string;
     displayName: string;
@@ -380,7 +382,7 @@ export type WidgetExports<T extends React.ComponentType<any> & Widget = React.Co
     /** transforms the widget options to the props used to render the widget for
     static renders  */
     staticTransform?: WidgetTransform;
-    validator?: WidgetValidatorFunction;
+    scorer?: WidgetScorerFunction;
     getOneCorrectAnswerFromRubric?: (rubric: Rubric) => string | null | undefined;
     /**
     A map of major version numbers (as a string, eg "1") to a function that

package/dist/util/answer-types.d.ts

@@ -1,6 +1,6 @@
 import type { PerseusStrings } from "../strings";
 type Guess = any;
-type Predicate = any;
+type Predicate = (guess: number, maxError: number) => boolean;
 export type Score = {
     empty: boolean;
     correct: boolean;
@@ -9,13 +9,56 @@ export type Score = {
     guess: Guess;
     ungraded?: boolean;
 };
+/**
+ * Answer types
+ *
+ * Utility for creating answerable questions displayed in exercises
+ *
+ * Different answer types produce different kinds of input displays, and do
+ * different kinds of checking on the solutions.
+ *
+ * Each of the objects contain two functions, setup and createValidator.
+ *
+ * The setup function takes a solutionarea and solution, and performs setup
+ * within the solutionarea, and then returns an object which contains:
+ *
+ * answer: a function which, when called, will retrieve the current answer from
+ *         the solutionarea, which can then be validated using the validator
+ *         function
+ * validator: a function returned from the createValidator function (defined
+ *            below)
+ * solution: the correct answer to the problem
+ * showGuess: a function which, when given a guess, shows the guess within the
+ *            provided solutionarea
+ * showGuessCustom: a function which displays parts of a guess that are not
+ *                  within the solutionarea; currently only used for custom
+ *                  answers
+ *
+ * The createValidator function only takes a solution, and it returns a
+ * function which can be used to validate an answer.
+ *
+ * The resulting validator function returns:
+ * - true: if the answer is fully correct
+ * - false: if the answer is incorrect
+ * - "" (the empty string): if no answer has been provided (e.g. the answer box
+ *   is left unfilled)
+ * - a string: if there is some slight error
+ *
+ * In most cases, setup and createValidator don't really need the solution DOM
+ * element so we have setupFunctional and createValidatorFunctional for them
+ * which take only $solution.text() and $solution.data(). This makes it easier
+ * to reuse specific answer types.
+ *
+ * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
+ *
+ */
 declare const KhanAnswerTypes: {
     readonly predicate: {
         readonly defaultForms: "integer, proper, improper, mixed, decimal";
         readonly createValidatorFunctional: (predicate: Predicate, options: any, strings: PerseusStrings) => (arg1: Guess) => Score;
     };
     readonly number: {
-        readonly convertToPredicate: (correctAnswer: string, options: any) => Predicate;
+        readonly convertToPredicate: (correctAnswer: string, options: any) => [predicate: Predicate, options: any];
         readonly createValidatorFunctional: (correctAnswer: string, options: any, strings: PerseusStrings) => (arg1: Guess) => Score;
     };
     readonly expression: {

package/dist/util/parse-perseus-json/error-tracking-parse-context.d.ts

@@ -0,0 +1,9 @@
+import type { ParseContext, Mismatch, PathSegment } from "./parser-types";
+import type { Failure, Success } from "./result";
+export declare class ErrorTrackingParseContext implements ParseContext {
+    private readonly path;
+    constructor(path: PathSegment[]);
+    failure(expected: string | string[], badValue: unknown): Failure<Mismatch[]>;
+    forSubtree(key: PathSegment): ParseContext;
+    success<T>(value: T): Success<T>;
+}

package/dist/util/parse-perseus-json/general-purpose-parsers/any.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare const any: Parser<any>;

package/dist/util/parse-perseus-json/general-purpose-parsers/array.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function array<T>(elementParser: Parser<T>): Parser<T[]>;

package/dist/util/parse-perseus-json/general-purpose-parsers/array.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/parse-perseus-json/general-purpose-parsers/boolean.d.ts

@@ -0,0 +1,2 @@
+import type { ParseContext, ParseResult } from "../parser-types";
+export declare function boolean(rawValue: unknown, ctx: ParseContext): ParseResult<boolean>;

package/dist/util/parse-perseus-json/general-purpose-parsers/compose-parsers.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedValue, PartialParser, Parser } from "../parser-types";
+export declare function composeParsers<A extends Parser<any>, B extends PartialParser<ParsedValue<A>, any>>(parserA: A, parserB: B): Parser<ParsedValue<B>>;

package/dist/util/parse-perseus-json/general-purpose-parsers/constant.d.ts

@@ -0,0 +1,4 @@
+import type { Parser } from "../parser-types";
+type Primitive = string | number | boolean | null | undefined;
+export declare function constant<T extends Primitive>(acceptedValue: T): Parser<T>;
+export {};

package/dist/util/parse-perseus-json/general-purpose-parsers/defaulted.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function defaulted<T, Default extends T | null | undefined>(parser: Parser<T>, fallback: (missingValue: null | undefined) => Default): Parser<T | Default>;

package/dist/util/parse-perseus-json/general-purpose-parsers/enumeration.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function enumeration<T extends readonly string[]>(...acceptedValues: T): Parser<T[number]>;

package/dist/util/parse-perseus-json/general-purpose-parsers/enumeration.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/parse-perseus-json/general-purpose-parsers/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./any";
+export * from "./array";
+export * from "./boolean";
+export * from "./constant";
+export * from "./enumeration";
+export * from "./is-object";
+export * from "./nullable";
+export * from "./number";
+export * from "./object";
+export * from "./optional";
+export * from "./pair";
+export * from "./record";
+export * from "./string";
+export * from "./trio";
+export * from "./union";

package/dist/util/parse-perseus-json/general-purpose-parsers/is-object.d.ts

@@ -0,0 +1 @@
+export declare function isObject(x: unknown): x is Record<keyof any, unknown>;

package/dist/util/parse-perseus-json/general-purpose-parsers/nullable.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function nullable<T>(parseValue: Parser<T>): Parser<T | null>;

package/dist/util/parse-perseus-json/general-purpose-parsers/number.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare const number: Parser<number>;

package/dist/util/parse-perseus-json/general-purpose-parsers/object.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedValue, Parser } from "../parser-types";
+type ObjectSchema = Record<keyof any, Parser<any>>;
+export declare function object<S extends ObjectSchema>(schema: S): Parser<{
+    [K in keyof S]: ParsedValue<S[K]>;
+}>;
+export {};

package/dist/util/parse-perseus-json/general-purpose-parsers/optional.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function optional<T>(parseValue: Parser<T>): Parser<T | undefined>;

package/dist/util/parse-perseus-json/general-purpose-parsers/pair.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function pair<A, B>(parseA: Parser<A>, parseB: Parser<B>): Parser<[A, B]>;

package/dist/util/parse-perseus-json/general-purpose-parsers/record.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function record<K extends string, V>(parseKey: Parser<K>, parseValue: Parser<V>): Parser<Record<K, V>>;

package/dist/util/parse-perseus-json/general-purpose-parsers/string.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare const string: Parser<string>;

package/dist/util/parse-perseus-json/general-purpose-parsers/test-helpers.d.ts

@@ -0,0 +1,8 @@
+import { ErrorTrackingParseContext } from "../error-tracking-parse-context";
+import type { Mismatch, ParsedValue, Parser } from "../parser-types";
+import type { Failure } from "../result";
+export declare function ctx(): ErrorTrackingParseContext;
+export declare const anyFailure: Failure<any>;
+export declare const anySuccess: import("../result").Success<any>;
+export declare function parseFailureWith(expected: Partial<Mismatch>): Failure<Mismatch[]>;
+export declare function summonParsedValue<P extends Parser<any>>(): ParsedValue<P>;

package/dist/util/parse-perseus-json/general-purpose-parsers/trio.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from "../parser-types";
+export declare function trio<A, B, C>(parseA: Parser<A>, parseB: Parser<B>, parseC: Parser<C>): Parser<[A, B, C]>;

package/dist/util/parse-perseus-json/general-purpose-parsers/union.d.ts

@@ -0,0 +1,7 @@
+import type { Parser } from "../parser-types";
+export declare function union<T>(parseBranch: Parser<T>): UnionBuilder<T>;
+export declare class UnionBuilder<T> {
+    parser: Parser<T>;
+    constructor(parser: Parser<T>);
+    or<New>(newBranch: Parser<New>): UnionBuilder<T | New>;
+}

package/dist/util/parse-perseus-json/general-purpose-parsers/union.typetest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/{parse-perseus-json.d.ts → parse-perseus-json/index.d.ts}

@@ -1,4 +1,5 @@
-import type { PerseusItem } from "../perseus-types";
+import type { Result } from "./result";
+import type { PerseusItem } from "../../perseus-types";
 /**
  * Helper to parse PerseusItem JSON
  * Why not just use JSON.parse? We want:
@@ -8,3 +9,8 @@ import type { PerseusItem } from "../perseus-types";
  * @returns {PerseusItem} the parsed PerseusItem object
  */
 export declare function parsePerseusItem(json: string): PerseusItem;
+/**
+ * Typesafe version of parsePerseusItem, which runtime-typechecks the JSON.
+ * TODO(benchristel): Replace parsePerseusItem with this function.
+ */
+export declare function parseAndTypecheckPerseusItem(json: string): Result<PerseusItem, string>;

package/dist/util/parse-perseus-json/object-path.d.ts

@@ -0,0 +1,2 @@
+import type { PathSegment } from "./parser-types";
+export declare function formatPath(path: PathSegment[]): string;

package/dist/util/parse-perseus-json/parse-failure-detail.d.ts

@@ -0,0 +1,2 @@
+import type { Mismatch } from "./parser-types";
+export declare function message(failure: Mismatch): string;

package/dist/util/parse-perseus-json/parse.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from "./parser-types";
+import type { Result } from "./result";
+export declare function parse<T>(value: unknown, parser: Parser<T>): Result<T, string>;

package/dist/util/parse-perseus-json/parser-types.d.ts

@@ -0,0 +1,30 @@
+import type { Success, Failure, Result } from "./result";
+export type Parser<T> = (rawVal: unknown, ctx: ParseContext) => ParseResult<T>;
+export type PartialParser<Input, Output> = (rawVal: Input, ctx: ParseContext) => ParseResult<Output>;
+export type ParseResult<T> = Result<T, Mismatch[]>;
+export type Mismatch = {
+    expected: string[];
+    badValue: unknown;
+    path: PathSegment[];
+};
+export type PathSegment = keyof any;
+export interface ParseContext {
+    /**
+     * Returns a Success result based on the current state of the parse.
+     * @param value The value to return in the Success.
+     */
+    success<T>(value: T): Success<T>;
+    /**
+     * Returns a Failure result based on the current state of the parse.
+     *
+     * @param expected one or more descriptions of the types that were expected.
+     * An array of several expected types has "any" semantics - any of the
+     * listed types is valid.
+     * @param badValue the value that caused the parse to fail.
+     */
+    failure(expected: string | string[], badValue: unknown): Failure<Mismatch[]>;
+    forSubtree(key: PathSegment): ParseContext;
+}
+export type ParsedValue<P extends Parser<any>> = Extract<ReturnType<P>, {
+    type: "success";
+}>["value"];

package/dist/util/parse-perseus-json/perseus-parsers/categorizer-widget.d.ts

@@ -0,0 +1,3 @@
+import type { CategorizerWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseCategorizerWidget: Parser<CategorizerWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/cs-program-widget.d.ts

@@ -0,0 +1,3 @@
+import type { CSProgramWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseCSProgramWidget: Parser<CSProgramWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/definition-widget.d.ts

@@ -0,0 +1,3 @@
+import type { DefinitionWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseDefinitionWidget: Parser<DefinitionWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/dropdown-widget.d.ts

@@ -0,0 +1,3 @@
+import type { DropdownWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseDropdownWidget: Parser<DropdownWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/explanation-widget.d.ts

@@ -0,0 +1,3 @@
+import type { ExplanationWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseExplanationWidget: Parser<ExplanationWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/expression-widget.d.ts

@@ -0,0 +1,3 @@
+import type { ExpressionWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseExpressionWidget: Parser<ExpressionWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/hint.d.ts

@@ -0,0 +1,3 @@
+import type { Hint } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseHint: Parser<Hint>;

package/dist/util/parse-perseus-json/perseus-parsers/interactive-graph-widget.d.ts

@@ -0,0 +1,3 @@
+import type { InteractiveGraphWidget } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseInteractiveGraphWidget: Parser<InteractiveGraphWidget>;

package/dist/util/parse-perseus-json/perseus-parsers/perseus-image-background.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from "../parser-types";
+import type { PerseusImageBackground } from "@khanacademy/perseus";
+export declare const parsePerseusImageBackground: Parser<PerseusImageBackground>;

package/dist/util/parse-perseus-json/perseus-parsers/perseus-item.d.ts

@@ -0,0 +1,3 @@
+import type { PerseusItem } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parsePerseusItem: Parser<PerseusItem>;

package/dist/util/parse-perseus-json/perseus-parsers/perseus-renderer.d.ts

@@ -0,0 +1,3 @@
+import type { PerseusRenderer } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parsePerseusRenderer: Parser<PerseusRenderer>;

package/dist/util/parse-perseus-json/perseus-parsers/widget.d.ts

@@ -0,0 +1,3 @@
+import type { WidgetOptions } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare function parseWidget<Type extends string, Options>(parseType: Parser<Type>, parseOptions: Parser<Options>): Parser<WidgetOptions<Type, Options>>;

package/dist/util/parse-perseus-json/perseus-parsers/widgets-map.d.ts

@@ -0,0 +1,3 @@
+import type { PerseusWidgetsMap } from "../../../perseus-types";
+import type { Parser } from "../parser-types";
+export declare const parseWidgetsMap: Parser<PerseusWidgetsMap>;

package/dist/util/parse-perseus-json/result.d.ts

@@ -0,0 +1,16 @@
+export type Result<S, F> = Success<S> | Failure<F>;
+export type Success<T> = {
+    type: "success";
+    value: T;
+};
+export type Failure<T> = {
+    type: "failure";
+    detail: T;
+};
+export declare function success<T>(value: T): Success<T>;
+export declare function failure<T>(detail: T): Failure<T>;
+export declare function isFailure<S, F>(result: Result<S, F>): result is Failure<F>;
+export declare function isSuccess<S, F>(result: Result<S, F>): result is Success<S>;
+export declare function assertFailure<S, F>(result: Result<S, F>): asserts result is Failure<F>;
+export declare function assertSuccess<S, F>(result: Result<S, F>): asserts result is Success<S>;
+export declare function all<S, F>(results: Array<Result<S, F>>, combineFailureDetails?: (a: F, b: F) => F): Result<S[], F>;

package/dist/validation.types.d.ts

@@ -1,4 +1,4 @@
-import type { GrapherAnswerTypes, PerseusDropdownChoice, PerseusExpressionAnswerForm, PerseusGradedGroupSetWidgetOptions, PerseusGradedGroupWidgetOptions, PerseusGraphType, PerseusGroupWidgetOptions, PerseusMatcherWidgetOptions, PerseusMatrixWidgetAnswers, PerseusNumberLineWidgetOptions, PerseusNumericInputAnswer, PerseusOrdererWidgetOptions, PerseusPlotterWidgetOptions, PerseusRadioChoice, PerseusTableWidgetOptions, PerseusGraphCorrectType } from "./perseus-types";
+import type { GrapherAnswerTypes, PerseusDropdownChoice, PerseusExpressionAnswerForm, PerseusGradedGroupSetWidgetOptions, PerseusGradedGroupWidgetOptions, PerseusGraphType, PerseusGroupWidgetOptions, PerseusMatcherWidgetOptions, PerseusMatrixWidgetAnswers, PerseusNumberLineWidgetOptions, PerseusNumericInputAnswer, PerseusOrdererWidgetOptions, PerseusPlotterWidgetOptions, PerseusRadioChoice, PerseusGraphCorrectType } from "./perseus-types";
 import type { InteractiveMarkerType } from "./widgets/label-image/types";
 import type { Relationship } from "./widgets/number-line/number-line";
 export type UserInputStatus = "correct" | "incorrect" | "incomplete";
@@ -94,9 +94,6 @@ export type PerseusRadioRubric = {
 };
 export type PerseusRadioUserInput = {
     choicesSelected: ReadonlyArray<boolean>;
-    numCorrect?: number;
-    noneOfTheAboveIndex?: number | null | undefined;
-    noneOfTheAboveSelected?: boolean;
 };
 export type PerseusSorterRubric = {
     correct: ReadonlyArray<string>;
@@ -105,7 +102,9 @@ export type PerseusSorterUserInput = {
     options: ReadonlyArray<string>;
     changed: boolean;
 };
-export type PerseusTableRubric = PerseusTableWidgetOptions;
+export type PerseusTableRubric = {
+    answers: ReadonlyArray<ReadonlyArray<string>>;
+};
 export type PerseusTableUserInput = ReadonlyArray<ReadonlyArray<string>>;
 export type Rubric = PerseusCategorizerRubric | PerseusCSProgramRubric | PerseusDropdownRubric | PerseusExpressionRubric | PerseusGroupRubric | PerseusGradedGroupRubric | PerseusGradedGroupSetRubric | PerseusGrapherRubric | PerseusIFrameRubric | PerseusInputNumberRubric | PerseusInteractiveGraphRubric | PerseusLabelImageRubric | PerseusMatcherRubric | PerseusMatrixRubric | PerseusNumberLineRubric | PerseusNumericInputRubric | PerseusOrdererRubric | PerseusPlotterRubric | PerseusRadioRubric | PerseusSorterRubric | PerseusTableRubric;
 export type UserInput = PerseusCategorizerUserInput | PerseusCSProgramUserInput | PerseusDropdownUserInput | PerseusExpressionUserInput | PerseusGrapherUserInput | PerseusIFrameUserInput | PerseusInputNumberUserInput | PerseusInteractiveGraphUserInput | PerseusLabelImageUserInput | PerseusMatcherUserInput | PerseusMatrixUserInput | PerseusNumberLineUserInput | PerseusNumericInputUserInput | PerseusOrdererUserInput | PerseusPlotterUserInput | PerseusRadioUserInput | PerseusSorterUserInput | PerseusTableUserInput;

package/dist/widget-ai-utils/categorizer/prompt-utils.d.ts

@@ -0,0 +1,14 @@
+import type { PerseusCategorizerUserInput } from "../../validation.types";
+import type categorizer from "../../widgets/categorizer/categorizer";
+import type React from "react";
+export type CategorizerPromptJSON = {
+    type: "categorizer";
+    options: {
+        items: ReadonlyArray<string>;
+        categories: ReadonlyArray<string>;
+    };
+    userInput: {
+        itemToCategoryMapping: ReadonlyArray<number>;
+    };
+};
+export declare const getPromptJSON: (renderProps: React.ComponentProps<typeof categorizer.widget>, userInput: PerseusCategorizerUserInput) => CategorizerPromptJSON;

package/dist/widget-ai-utils/cs-program/prompt-utils.d.ts

@@ -0,0 +1,2 @@
+import { type UnsupportedWidgetPromptJSON } from "../unsupported-widget";
+export declare const getPromptJSON: () => UnsupportedWidgetPromptJSON;

package/dist/widget-ai-utils/definition/prompt-utils.d.ts

@@ -0,0 +1,8 @@
+import type definition from "../../widgets/definition/definition";
+import type React from "react";
+export type DefinitionPromptJSON = {
+    type: "definition";
+    definition: string;
+    togglePrompt: string;
+};
+export declare const getPromptJSON: (renderProps: React.ComponentProps<typeof definition.widget>) => DefinitionPromptJSON;

package/dist/widget-ai-utils/dropdown/prompt-utils.d.ts

@@ -0,0 +1,13 @@
+import type { PerseusDropdownUserInput } from "../../validation.types";
+import type dropdown from "../../widgets/dropdown/dropdown";
+import type React from "react";
+export type DropdownPromptJSON = {
+    type: "dropdown";
+    options: {
+        items: ReadonlyArray<string>;
+    };
+    userInput: {
+        selectedIndex: number;
+    };
+};
+export declare const getPromptJSON: (renderProps: React.ComponentProps<typeof dropdown.widget>, userInput: PerseusDropdownUserInput) => DropdownPromptJSON;