@mathscan/geometry-engine 0.1.0 → 0.1.1

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

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+export declare const v4ExerciseSchemaVersion = 4;
+/** Version 4's vocabularies: version 2's plus the angle M3.4 added (ADR 0010). */
+export declare const v4EntityKinds: readonly ["point", "segment", "line", "circle", "angle"];
+export declare const v4ObjectTypeNames: readonly ["point", "segment", "line", "circle", "angle"];
+export declare const v4ToolNames: readonly ["ruler", "setSquare", "protractor"];
+export declare const v4GoalTypes: readonly ["create", "throughPoints", "perpendicular", "parallel", "segmentLength", "midpoint"];
+export declare const v4PresentationKeys: readonly ["role", "label", "measureLabel"];
+/**
+ * The exercise document at version 4 as M3.4 left it, frozen by ADR 0019 so the
+ * v4 → v5 step can ask "could version 4 have said this?" once the angle goals
+ * make the current schema wider — and so the v3 → v4 step still has a version 4
+ * to ask.
+ *
+ * Version 4 is version 3 plus `solution` (ADR 0015) and the angle — one entity
+ * kind, one object type, one presentation key — and no goal type, so it is built
+ * on the frozen v3 transcription with those written out and nothing imported
+ * from the current vocabulary (see `exerciseV2.schema.ts`).
+ *
+ * `solution` is admitted and never judged. It is an attempt document that
+ * migrates and validates on its own path (ADR 0015), a malformed one does not
+ * make the exercise unloadable, and both gates that ask this schema hand it the
+ * solution-free projection anyway (ADR 0019).
+ */
+export declare const geometryExerciseV4Schema: z.ZodObject<{
+    id: z.ZodString;
+    viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    showGrid: z.ZodOptional<z.ZodBoolean>;
+    draggableEntityIds: z.ZodArray<z.ZodString>;
+    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>[]>>;
+    grading: z.ZodOptional<z.ZodObject<{
+        extraObjects: z.ZodEnum<{
+            allow: "allow";
+            reject: "reject";
+        }>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<4>;
+    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];
+    } | {
+        kind: "angle";
+        parents: readonly [string, 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];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
+    }>, unknown>>;
+    presentation: z.ZodType<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
+    }>, unknown, z.core.$ZodTypeInternals<Record<string, {
+        role: "implicit" | "explicit";
+        label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
+    }>, unknown>>;
+    allowedObjects: z.ZodArray<z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+        angle: "angle";
+    }>>;
+    solution: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+//# sourceMappingURL=exerciseV4.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exerciseV4.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/exerciseV4.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB,eAAO,MAAM,uBAAuB,IAAI,CAAA;AAExC,kFAAkF;AAClF,eAAO,MAAM,aAAa,0DAAuC,CAAA;AACjE,eAAO,MAAM,iBAAiB,0DAA2C,CAAA;AACzE,eAAO,MAAM,WAAW,+CAAc,CAAA;AACtC,eAAO,MAAM,WAAW,gGAAc,CAAA;AACtC,eAAO,MAAM,kBAAkB,4CAAmD,CAAA;AAElF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwBnC,CAAA"}

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

@@ -27,6 +27,9 @@ export declare const geometryStateSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         kind: "point";
         at: {
@@ -50,13 +53,18 @@ export declare const geometryStateSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown>>;
     presentation: z.ZodType<Record<string, {
         role: "implicit" | "explicit";
         label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         role: "implicit" | "explicit";
         label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
     }>, unknown>>;
     answerEntityIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;

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

@@ -27,6 +27,9 @@ export declare const geometryStateSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         kind: "point";
         at: {
@@ -50,13 +53,18 @@ export declare const geometryStateSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown>>;
     presentation: z.ZodType<Record<string, {
         role: "implicit" | "explicit";
         label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         role: "implicit" | "explicit";
         label?: string | undefined;
+        measureLabel?: "degrees" | undefined;
     }>, unknown>>;
     answerEntityIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;

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

@@ -1 +1 @@
-{"version":3,"file":"geometryState.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/geometryState.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAmB,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAatF,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAG3C,eAAO,MAAM,uBAAuB,EAAE,SAAS,aAAa,EAA0B,CAAA;AAUtF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuB5B,CAAA;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAK/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAErE"}
+{"version":3,"file":"geometryState.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/geometryState.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAmB,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAE,MAAM,WAAW,CAAA;AAatF,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAG3C,eAAO,MAAM,uBAAuB,EAAE,SAAS,aAAa,EAA0B,CAAA;AAUtF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuB5B,CAAA;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAK/D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAErE"}

package/dist/schemas/goals/angleBisectorGoal.schema.d.cts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const angleBisectorGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleBisector">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+        angle: "angle";
+    }>;
+    referenceAngleId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>;
+export type AngleBisectorGoal = z.infer<typeof angleBisectorGoalSchema>;

package/dist/schemas/goals/angleBisectorGoal.schema.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const angleBisectorGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleBisector">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+        angle: "angle";
+    }>;
+    referenceAngleId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>;
+export type AngleBisectorGoal = z.infer<typeof angleBisectorGoalSchema>;
+//# sourceMappingURL=angleBisectorGoal.schema.d.ts.map

package/dist/schemas/goals/angleBisectorGoal.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleBisectorGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/angleBisectorGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;kBAUzB,CAAA;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/schemas/goals/angleCriterion.schema.d.cts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const angleTypeSchema: z.ZodEnum<{
+    acute: "acute";
+    right: "right";
+    obtuse: "obtuse";
+    straight: "straight";
+    reflex: "reflex";
+}>;
+/**
+ * What an angle goal asks of a measure (RFC 0006 § Decision 2): a degree with a
+ * tolerance, or a named type. A type takes no tolerance — "right, ± 2" is
+ * already `degrees` 90 ± 2 — so the strict member refuses one.
+ */
+export declare const angleCriterionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"degrees">;
+    targetDegrees: z.ZodNumber;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"type">;
+    angleType: z.ZodEnum<{
+        acute: "acute";
+        right: "right";
+        obtuse: "obtuse";
+        straight: "straight";
+        reflex: "reflex";
+    }>;
+}, z.core.$strict>], "kind">;
+export type AngleCriterion = z.infer<typeof angleCriterionSchema>;

package/dist/schemas/goals/angleCriterion.schema.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const angleTypeSchema: z.ZodEnum<{
+    acute: "acute";
+    right: "right";
+    obtuse: "obtuse";
+    straight: "straight";
+    reflex: "reflex";
+}>;
+/**
+ * What an angle goal asks of a measure (RFC 0006 § Decision 2): a degree with a
+ * tolerance, or a named type. A type takes no tolerance — "right, ± 2" is
+ * already `degrees` 90 ± 2 — so the strict member refuses one.
+ */
+export declare const angleCriterionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"degrees">;
+    targetDegrees: z.ZodNumber;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"type">;
+    angleType: z.ZodEnum<{
+        acute: "acute";
+        right: "right";
+        obtuse: "obtuse";
+        straight: "straight";
+        reflex: "reflex";
+    }>;
+}, z.core.$strict>], "kind">;
+export type AngleCriterion = z.infer<typeof angleCriterionSchema>;
+//# sourceMappingURL=angleCriterion.schema.d.ts.map

package/dist/schemas/goals/angleCriterion.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleCriterion.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/angleCriterion.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,eAAe;;;;;;EAA6D,CAAA;AAEzF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;4BAU/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/schemas/goals/angleMeasureGoal.schema.d.cts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const angleMeasureGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleMeasure">;
+    objectType: z.ZodLiteral<"angle">;
+    vertexPointId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type AngleMeasureGoal = z.infer<typeof angleMeasureGoalSchema>;

package/dist/schemas/goals/angleMeasureGoal.schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const angleMeasureGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleMeasure">;
+    objectType: z.ZodLiteral<"angle">;
+    vertexPointId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type AngleMeasureGoal = z.infer<typeof angleMeasureGoalSchema>;
+//# sourceMappingURL=angleMeasureGoal.schema.d.ts.map

package/dist/schemas/goals/angleMeasureGoal.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleMeasureGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/angleMeasureGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;kBAWxB,CAAA;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/schemas/goals/createGoal.schema.d.cts

@@ -7,6 +7,7 @@ export declare const createGoalSchema: z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
 }, z.core.$strict>;
 export type CreateGoal = z.infer<typeof createGoalSchema>;

package/dist/schemas/goals/createGoal.schema.d.ts

@@ -7,6 +7,7 @@ export declare const createGoalSchema: z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
 }, z.core.$strict>;
 export type CreateGoal = z.infer<typeof createGoalSchema>;

package/dist/schemas/goals/createGoal.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/createGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;kBAMlB,CAAA;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"createGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/createGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;;;;;;;;kBAMlB,CAAA;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schemas/goals/geometryGoal.schema.d.cts

@@ -7,6 +7,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
@@ -16,6 +17,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     pointIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
@@ -26,6 +28,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     referenceObjectId: z.ZodString;
     throughPointId: z.ZodString;
@@ -38,6 +41,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     referenceObjectId: z.ZodString;
     throughPointId: z.ZodString;
@@ -54,5 +58,62 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     objectType: z.ZodLiteral<"point">;
     referenceObjectId: z.ZodString;
     toleranceUnits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleMeasure">;
+    objectType: z.ZodLiteral<"angle">;
+    vertexPointId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleBisector">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+        angle: "angle";
+    }>;
+    referenceAngleId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"givenAngle">;
+    angleId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
 }, z.core.$strict>], "type">;
 export type GeometryGoal = z.infer<typeof geometryGoalSchema>;

package/dist/schemas/goals/geometryGoal.schema.d.ts

@@ -7,6 +7,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
 }, z.core.$strict>, z.ZodObject<{
     id: z.ZodString;
@@ -16,6 +17,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     pointIds: z.ZodArray<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
@@ -26,6 +28,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     referenceObjectId: z.ZodString;
     throughPointId: z.ZodString;
@@ -38,6 +41,7 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>;
     referenceObjectId: z.ZodString;
     throughPointId: z.ZodString;
@@ -54,6 +58,63 @@ export declare const geometryGoalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     objectType: z.ZodLiteral<"point">;
     referenceObjectId: z.ZodString;
     toleranceUnits: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleMeasure">;
+    objectType: z.ZodLiteral<"angle">;
+    vertexPointId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"angleBisector">;
+    objectType: z.ZodEnum<{
+        point: "point";
+        segment: "segment";
+        line: "line";
+        circle: "circle";
+        angle: "angle";
+    }>;
+    referenceAngleId: z.ZodString;
+    toleranceDegrees: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"givenAngle">;
+    angleId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
 }, z.core.$strict>], "type">;
 export type GeometryGoal = z.infer<typeof geometryGoalSchema>;
 //# sourceMappingURL=geometryGoal.schema.d.ts.map

package/dist/schemas/goals/geometryGoal.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometryGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/geometryGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"geometryGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/geometryGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAU7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schemas/goals/givenAngleGoal.schema.d.cts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/**
+ * The first **figure goal** (ADR 0016): it judges a given angle as the evaluated
+ * figure resolves it, rather than an entity the student built.
+ *
+ * An exercise that pins an angle's vertex and first arm and lets the student
+ * drag the second has no candidate to grade — a given is never a candidate
+ * (ADR 0008 § Amendment) — so its only subject is the figure itself. What makes
+ * that safe is the override invariant: an attempt may move an authorized point
+ * and nothing else, so the figure judged here is the exercise's.
+ */
+export declare const givenAngleGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"givenAngle">;
+    angleId: z.ZodString;
+    interpretation: z.ZodEnum<{
+        directed: "directed";
+        undirected: "undirected";
+    }>;
+    criterion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"degrees">;
+        targetDegrees: z.ZodNumber;
+        toleranceDegrees: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"type">;
+        angleType: z.ZodEnum<{
+            acute: "acute";
+            right: "right";
+            obtuse: "obtuse";
+            straight: "straight";
+            reflex: "reflex";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type GivenAngleGoal = z.infer<typeof givenAngleGoalSchema>;