@mathscan/geometry-engine 0.1.0

package/dist/schemas/exercise.schema.d.ts

@@ -0,0 +1,218 @@
+import { z } from 'zod';
+import { MigrationOutcome, MigrationStep } from './migrate.js';
+export declare const toolNameSchema: z.ZodEnum<{
+    ruler: "ruler";
+    setSquare: "setSquare";
+    protractor: "protractor";
+}>;
+export type ToolName = z.infer<typeof toolNameSchema>;
+export declare const latestGeometryExerciseVersion = 4;
+export declare const extraObjectPolicySchema: z.ZodEnum<{
+    allow: "allow";
+    reject: "reject";
+}>;
+export type ExtraObjectPolicy = z.infer<typeof extraObjectPolicySchema>;
+export declare const exerciseGradingSchema: z.ZodObject<{
+    extraObjects: z.ZodEnum<{
+        allow: "allow";
+        reject: "reject";
+    }>;
+}, z.core.$strict>;
+export type ExerciseGrading = z.infer<typeof exerciseGradingSchema>;
+export declare const geometryExerciseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<4>;
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>>;
+    tools: z.ZodArray<z.ZodEnum<{
+        ruler: "ruler";
+        setSquare: "setSquare";
+        protractor: "protractor";
+    }>>;
+    goals: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"create">;
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"throughPoints">;
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        pointIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"perpendicular">;
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"parallel">;
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"segmentLength">;
+        objectType: z.ZodLiteral<"segment">;
+        targetLength: z.ZodNumber;
+        toleranceUnits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"midpoint">;
+        objectType: z.ZodLiteral<"point">;
+        referenceObjectId: z.ZodString;
+        toleranceUnits: z.ZodNumber;
+    }, z.core.$strict>], "type">>;
+    grading: z.ZodOptional<z.ZodObject<{
+        extraObjects: z.ZodEnum<{
+            allow: "allow";
+            reject: "reject";
+        }>;
+    }, z.core.$strict>>;
+    solution: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        entities: z.ZodType<Record<string, {
+            kind: "point";
+            at: {
+                x: number;
+                y: number;
+            };
+        } | {
+            kind: "point";
+            on: string;
+            t: number;
+        } | {
+            kind: "point";
+            intersectionOf: readonly [string, string];
+            which?: 0 | 1 | undefined;
+        } | {
+            kind: "segment";
+            parents: readonly [string, string];
+        } | {
+            kind: "line";
+            parents: readonly [string, string];
+        } | {
+            kind: "circle";
+            parents: readonly [string, string];
+        }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+            kind: "point";
+            at: {
+                x: number;
+                y: number;
+            };
+        } | {
+            kind: "point";
+            on: string;
+            t: number;
+        } | {
+            kind: "point";
+            intersectionOf: readonly [string, string];
+            which?: 0 | 1 | undefined;
+        } | {
+            kind: "segment";
+            parents: readonly [string, string];
+        } | {
+            kind: "line";
+            parents: readonly [string, string];
+        } | {
+            kind: "circle";
+            parents: readonly [string, string];
+        }>, unknown>>;
+        presentation: z.ZodType<Record<string, {
+            role: "implicit" | "explicit";
+            label?: string | undefined;
+        }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+            role: "implicit" | "explicit";
+            label?: string | undefined;
+        }>, unknown>>;
+        answerEntityIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GeometryExercise = z.infer<typeof geometryExerciseSchema>;
+export declare const geometryExerciseMigrations: readonly MigrationStep[];
+export declare function parseGeometryExercise(input: unknown): GeometryExercise;
+export declare function migrateGeometryExercise(input: unknown): MigrationOutcome;
+//# sourceMappingURL=exercise.schema.d.ts.map

package/dist/schemas/exercise.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exercise.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/exercise.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,OAAO,EAAmB,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAQtF,eAAO,MAAM,cAAc;;;;EAA+C,CAAA;AAC1E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAgBrD,eAAO,MAAM,6BAA6B,IAAI,CAAA;AAM9C,eAAO,MAAM,uBAAuB;;;EAA8B,CAAA;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAKvE,eAAO,MAAM,qBAAqB;;;;;kBAA+D,CAAA;AACjG,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAgBnE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+D/B,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAYrE,eAAO,MAAM,0BAA0B,EAAE,SAAS,aAAa,EAS9D,CAAA;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAEtE;AAKD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAExE"}

package/dist/schemas/exerciseProjection.d.cts

@@ -0,0 +1,10 @@
+/**
+ * The exercise as grading and the student runtime see it: without the authored
+ * solution (ADR 0015). The solution is client-visible by product decision, but
+ * it is never student state, a malformed one must not disable Check or the
+ * canvas, and changing only the solution must not look like a different
+ * exercise. Works on a parsed exercise and on a raw migrated document alike.
+ * Returns the input itself when there is nothing to remove, so a solution-free
+ * exercise keeps its identity.
+ */
+export declare function withoutSolution<T extends object>(exercise: T): Omit<T, 'solution'>;

package/dist/schemas/exerciseProjection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The exercise as grading and the student runtime see it: without the authored
+ * solution (ADR 0015). The solution is client-visible by product decision, but
+ * it is never student state, a malformed one must not disable Check or the
+ * canvas, and changing only the solution must not look like a different
+ * exercise. Works on a parsed exercise and on a raw migrated document alike.
+ * Returns the input itself when there is nothing to remove, so a solution-free
+ * exercise keeps its identity.
+ */
+export declare function withoutSolution<T extends object>(exercise: T): Omit<T, 'solution'>;
+//# sourceMappingURL=exerciseProjection.d.ts.map

package/dist/schemas/exerciseProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exerciseProjection.d.ts","sourceRoot":"","sources":["../../src/schemas/exerciseProjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,CAKlF"}

package/dist/schemas/exerciseV2.schema.d.cts

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+export declare const v2ExerciseSchemaVersion = 2;
+/** v2's four entity kinds, its object types, its tools and its goal types. */
+export declare const v2EntityKinds: readonly ["point", "segment", "line", "circle"];
+export declare const v2ObjectTypeNames: readonly ["point", "segment", "line", "circle"];
+export declare const v2ToolNames: readonly ["ruler", "setSquare", "protractor"];
+export declare const v2GoalTypes: readonly ["create", "throughPoints", "perpendicular", "parallel", "segmentLength", "midpoint"];
+/** And the only two keys a v2 presentation entry had. */
+export declare const v2PresentationKeys: readonly ["role", "label"];
+export declare const geometryExerciseV2Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>>;
+    tools: z.ZodArray<z.ZodEnum<{
+        ruler: "ruler";
+        setSquare: "setSquare";
+        protractor: "protractor";
+    }>>;
+    goals: z.ZodArray<z.ZodUnion<z.ZodObject<{
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        pointIds: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"segment">;
+        targetLength: z.ZodNumber;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"point">;
+        referenceObjectId: z.ZodString;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    }, z.core.$strict>[]>>;
+}, z.core.$strict>;

package/dist/schemas/exerciseV2.schema.d.ts

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+export declare const v2ExerciseSchemaVersion = 2;
+/** v2's four entity kinds, its object types, its tools and its goal types. */
+export declare const v2EntityKinds: readonly ["point", "segment", "line", "circle"];
+export declare const v2ObjectTypeNames: readonly ["point", "segment", "line", "circle"];
+export declare const v2ToolNames: readonly ["ruler", "setSquare", "protractor"];
+export declare const v2GoalTypes: readonly ["create", "throughPoints", "perpendicular", "parallel", "segmentLength", "midpoint"];
+/** And the only two keys a v2 presentation entry had. */
+export declare const v2PresentationKeys: readonly ["role", "label"];
+export declare const geometryExerciseV2Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>>;
+    tools: z.ZodArray<z.ZodEnum<{
+        ruler: "ruler";
+        setSquare: "setSquare";
+        protractor: "protractor";
+    }>>;
+    goals: z.ZodArray<z.ZodUnion<z.ZodObject<{
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        pointIds: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"segment">;
+        targetLength: z.ZodNumber;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"point">;
+        referenceObjectId: z.ZodString;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    }, z.core.$strict>[]>>;
+}, z.core.$strict>;
+//# sourceMappingURL=exerciseV2.schema.d.ts.map

package/dist/schemas/exerciseV2.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exerciseV2.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/exerciseV2.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAgDxC,8EAA8E;AAC9E,eAAO,MAAM,aAAa,iDAAkD,CAAA;AAC5E,eAAO,MAAM,iBAAiB,iDAAkD,CAAA;AAChF,eAAO,MAAM,WAAW,+CAAgD,CAAA;AACxE,eAAO,MAAM,WAAW,gGAOd,CAAA;AACV,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,4BAA6B,CAAA;AA2C5D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiB1B,CAAA"}

package/dist/schemas/exerciseV3.schema.d.cts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+export declare const v3ExerciseSchemaVersion = 3;
+/**
+ * The exercise document ADR 0013 froze at version 3, so the v3 → v4 step can
+ * check what it was handed before promoting it (ADR 0015) — and so the v2 → v3
+ * step still has a version 3 to ask once the current schema has moved past it.
+ *
+ * Version 3 is version 2 plus `grading` and nothing else, so it is built on the
+ * frozen v2 transcription rather than transcribed a second time. `grading` is
+ * written out here with nothing imported from the current vocabulary, for the
+ * reason `exerciseV2.schema.ts` gives: a shared schema admits every later
+ * addition to it. Like that schema this one carries no cross-reference
+ * refinements and no issue messages; it only answers "could version 3 have
+ * said this?".
+ */
+export declare const geometryExerciseV3Schema: z.ZodObject<{
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    entities: z.ZodType<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        kind: "point";
+        at: {
+            x: number;
+            y: number;
+        };
+    } | {
+        kind: "point";
+        on: string;
+        t: number;
+    } | {
+        kind: "point";
+        intersectionOf: readonly [string, string];
+        which?: 0 | 1 | undefined;
+    } | {
+        kind: "segment";
+        parents: readonly [string, string];
+    } | {
+        kind: "line";
+        parents: readonly [string, string];
+    } | {
+        kind: "circle";
+        parents: readonly [string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+    }>, unknown>>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+    }>>;
+    tools: z.ZodArray<z.ZodEnum<{
+        ruler: "ruler";
+        setSquare: "setSquare";
+        protractor: "protractor";
+    }>>;
+    goals: z.ZodArray<z.ZodUnion<z.ZodObject<{
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        pointIds: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodEnum<{
+            point: "point";
+            segment: "segment";
+            line: "line";
+            circle: "circle";
+        }>;
+        referenceObjectId: z.ZodString;
+        throughPointId: z.ZodString;
+        toleranceDegrees: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"segment">;
+        targetLength: z.ZodNumber;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    } | {
+        objectType: z.ZodLiteral<"point">;
+        referenceObjectId: z.ZodString;
+        toleranceUnits: z.ZodNumber;
+        id: z.ZodString;
+        type: z.ZodLiteral<"create" | "throughPoints" | "perpendicular" | "parallel" | "segmentLength" | "midpoint">;
+    }, z.core.$strict>[]>>;
+    schemaVersion: z.ZodLiteral<3>;
+    grading: z.ZodOptional<z.ZodObject<{
+        extraObjects: z.ZodEnum<{
+            allow: "allow";
+            reject: "reject";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;