@mathscan/geometry-engine 0.1.0 → 0.1.1

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

@@ -6,7 +6,7 @@ export declare const toolNameSchema: z.ZodEnum<{
     protractor: "protractor";
 }>;
 export type ToolName = z.infer<typeof toolNameSchema>;
-export declare const latestGeometryExerciseVersion = 4;
+export declare const latestGeometryExerciseVersion = 5;
 export declare const extraObjectPolicySchema: z.ZodEnum<{
     allow: "allow";
     reject: "reject";
@@ -20,7 +20,7 @@ export declare const exerciseGradingSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ExerciseGrading = z.infer<typeof exerciseGradingSchema>;
 export declare const geometryExerciseSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<4>;
+    schemaVersion: z.ZodLiteral<5>;
     id: z.ZodString;
     viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
     showGrid: z.ZodOptional<z.ZodBoolean>;
@@ -47,6 +47,9 @@ export declare const geometryExerciseSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         kind: "point";
         at: {
@@ -70,13 +73,18 @@ export declare const geometryExerciseSchema: 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>>;
     draggableEntityIds: z.ZodArray<z.ZodString>;
     allowedObjects: z.ZodArray<z.ZodEnum<{
@@ -84,6 +92,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>>;
     tools: z.ZodArray<z.ZodEnum<{
         ruler: "ruler";
@@ -98,6 +107,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
@@ -107,6 +117,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         pointIds: z.ZodArray<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
@@ -117,6 +128,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         referenceObjectId: z.ZodString;
         throughPointId: z.ZodString;
@@ -129,6 +141,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         referenceObjectId: z.ZodString;
         throughPointId: z.ZodString;
@@ -145,6 +158,63 @@ export declare const geometryExerciseSchema: 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">>;
     grading: z.ZodOptional<z.ZodObject<{
         extraObjects: z.ZodEnum<{
@@ -177,6 +247,9 @@ export declare const geometryExerciseSchema: z.ZodObject<{
         } | {
             kind: "circle";
             parents: readonly [string, string];
+        } | {
+            kind: "angle";
+            parents: readonly [string, string, string];
         }>, unknown, z.core.$ZodTypeInternals<Record<string, {
             kind: "point";
             at: {
@@ -200,13 +273,18 @@ export declare const geometryExerciseSchema: 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/exercise.schema.d.ts

@@ -6,7 +6,7 @@ export declare const toolNameSchema: z.ZodEnum<{
     protractor: "protractor";
 }>;
 export type ToolName = z.infer<typeof toolNameSchema>;
-export declare const latestGeometryExerciseVersion = 4;
+export declare const latestGeometryExerciseVersion = 5;
 export declare const extraObjectPolicySchema: z.ZodEnum<{
     allow: "allow";
     reject: "reject";
@@ -20,7 +20,7 @@ export declare const exerciseGradingSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type ExerciseGrading = z.infer<typeof exerciseGradingSchema>;
 export declare const geometryExerciseSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<4>;
+    schemaVersion: z.ZodLiteral<5>;
     id: z.ZodString;
     viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
     showGrid: z.ZodOptional<z.ZodBoolean>;
@@ -47,6 +47,9 @@ export declare const geometryExerciseSchema: z.ZodObject<{
     } | {
         kind: "circle";
         parents: readonly [string, string];
+    } | {
+        kind: "angle";
+        parents: readonly [string, string, string];
     }>, unknown, z.core.$ZodTypeInternals<Record<string, {
         kind: "point";
         at: {
@@ -70,13 +73,18 @@ export declare const geometryExerciseSchema: 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>>;
     draggableEntityIds: z.ZodArray<z.ZodString>;
     allowedObjects: z.ZodArray<z.ZodEnum<{
@@ -84,6 +92,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
         segment: "segment";
         line: "line";
         circle: "circle";
+        angle: "angle";
     }>>;
     tools: z.ZodArray<z.ZodEnum<{
         ruler: "ruler";
@@ -98,6 +107,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
     }, z.core.$strict>, z.ZodObject<{
         id: z.ZodString;
@@ -107,6 +117,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         pointIds: z.ZodArray<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
@@ -117,6 +128,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         referenceObjectId: z.ZodString;
         throughPointId: z.ZodString;
@@ -129,6 +141,7 @@ export declare const geometryExerciseSchema: z.ZodObject<{
             segment: "segment";
             line: "line";
             circle: "circle";
+            angle: "angle";
         }>;
         referenceObjectId: z.ZodString;
         throughPointId: z.ZodString;
@@ -145,6 +158,63 @@ export declare const geometryExerciseSchema: 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">>;
     grading: z.ZodOptional<z.ZodObject<{
         extraObjects: z.ZodEnum<{
@@ -177,6 +247,9 @@ export declare const geometryExerciseSchema: z.ZodObject<{
         } | {
             kind: "circle";
             parents: readonly [string, string];
+        } | {
+            kind: "angle";
+            parents: readonly [string, string, string];
         }>, unknown, z.core.$ZodTypeInternals<Record<string, {
             kind: "point";
             at: {
@@ -200,13 +273,18 @@ export declare const geometryExerciseSchema: 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/exercise.schema.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"exercise.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/exercise.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,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;AAmBrD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkE/B,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AASrE,eAAO,MAAM,0BAA0B,EAAE,SAAS,aAAa,EAK9D,CAAA;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAEtE;AAKD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAExE"}

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

@@ -1,5 +1,37 @@
 import { z } from 'zod';
 export declare const v2ExerciseSchemaVersion = 2;
+/**
+ * The exercise document ADR 0008 froze, transcribed **whole** so the v2 → v3
+ * step can check what it was handed before promoting it (ADR 0013).
+ *
+ * Frozen means frozen: nothing below is imported from the current vocabulary.
+ * An earlier version of this file reused `entityDefinitionSchema`,
+ * `entityPresentationSchema`, `objectTypeNameSchema`, `toolNameSchema` and
+ * `geometryGoalSchema`, which would have silently admitted every later addition
+ * to them — the `angle` entity kind, `angleMeasure` / `angleBisector` goals and
+ * the `measureLabel` presentation entry ADR 0010 already plans — into a document
+ * claiming to be version 2. A union member or an enum value is as much a version
+ * change as a new field, and a shared schema cannot tell two versions apart.
+ *
+ * What is deliberately shared is machinery rather than vocabulary:
+ * `entityRecordSchema()` supplies the `__proto__` refusal (M2.G.1) and the
+ * record's id-key rule. If those change they change for every version at once,
+ * which is a decision of its own rather than a new document feature.
+ *
+ * Two things this schema is not. It carries **no cross-reference refinements**:
+ * it answers "could version 2 have said this?", never "is this exercise
+ * coherent?" — the migrated document is parsed by `geometryExerciseSchema`,
+ * whose refinements report a dangling id or a duplicate goal id at its real
+ * path. And it carries **no issue messages**: nothing renders them, because
+ * `v2ToV3.ts` reports the offending *paths* and the surviving document is
+ * described by the current schema.
+ *
+ * `tests/schemas/v2ToV3.test.ts` § "the frozen v2 vocabulary" fails the day the
+ * current schemas gain a kind, goal, object type, tool or presentation field
+ * this file does not list, so the freeze cannot rot quietly.
+ */
+/** v2's id rule, shared with the later frozen transcriptions built on this one. */
+export declare const v2IdSchema: z.ZodString;
 /** 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"];
@@ -7,6 +39,31 @@ 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"];
+/** v2's entity definitions, for the later frozen transcriptions to widen by name. */
+export declare const v2EntityDefinitionMembers: readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    at: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    on: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    intersectionOf: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    which: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"circle">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>];
 export declare const geometryExerciseV2Schema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<2>;
     id: z.ZodString;

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

@@ -1,5 +1,37 @@
 import { z } from 'zod';
 export declare const v2ExerciseSchemaVersion = 2;
+/**
+ * The exercise document ADR 0008 froze, transcribed **whole** so the v2 → v3
+ * step can check what it was handed before promoting it (ADR 0013).
+ *
+ * Frozen means frozen: nothing below is imported from the current vocabulary.
+ * An earlier version of this file reused `entityDefinitionSchema`,
+ * `entityPresentationSchema`, `objectTypeNameSchema`, `toolNameSchema` and
+ * `geometryGoalSchema`, which would have silently admitted every later addition
+ * to them — the `angle` entity kind, `angleMeasure` / `angleBisector` goals and
+ * the `measureLabel` presentation entry ADR 0010 already plans — into a document
+ * claiming to be version 2. A union member or an enum value is as much a version
+ * change as a new field, and a shared schema cannot tell two versions apart.
+ *
+ * What is deliberately shared is machinery rather than vocabulary:
+ * `entityRecordSchema()` supplies the `__proto__` refusal (M2.G.1) and the
+ * record's id-key rule. If those change they change for every version at once,
+ * which is a decision of its own rather than a new document feature.
+ *
+ * Two things this schema is not. It carries **no cross-reference refinements**:
+ * it answers "could version 2 have said this?", never "is this exercise
+ * coherent?" — the migrated document is parsed by `geometryExerciseSchema`,
+ * whose refinements report a dangling id or a duplicate goal id at its real
+ * path. And it carries **no issue messages**: nothing renders them, because
+ * `v2ToV3.ts` reports the offending *paths* and the surviving document is
+ * described by the current schema.
+ *
+ * `tests/schemas/v2ToV3.test.ts` § "the frozen v2 vocabulary" fails the day the
+ * current schemas gain a kind, goal, object type, tool or presentation field
+ * this file does not list, so the freeze cannot rot quietly.
+ */
+/** v2's id rule, shared with the later frozen transcriptions built on this one. */
+export declare const v2IdSchema: z.ZodString;
 /** 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"];
@@ -7,6 +39,31 @@ 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"];
+/** v2's entity definitions, for the later frozen transcriptions to widen by name. */
+export declare const v2EntityDefinitionMembers: readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    at: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    on: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    intersectionOf: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    which: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"circle">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>];
 export declare const geometryExerciseV2Schema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<2>;
     id: z.ZodString;

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

@@ -1 +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"}
+{"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;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,mFAAmF;AACnF,eAAO,MAAM,UAAU,aAGqB,CAAA;AAa5C,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;AAK5D,qFAAqF;AACrF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;mBAa5B,CAAA;AA0BV,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiB1B,CAAA"}

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

@@ -0,0 +1,168 @@
+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>;