@mathscan/geometry-engine 0.1.0

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const midpointGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"midpoint">;
+    objectType: z.ZodLiteral<"point">;
+    referenceObjectId: z.ZodString;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>;
+export type MidpointGoal = z.infer<typeof midpointGoalSchema>;
+//# sourceMappingURL=midpointGoal.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"midpointGoal.schema.d.ts","sourceRoot":"","sources":["../../../src/schemas/goals/midpointGoal.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,kBAAkB;;;;;;kBAWpB,CAAA;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const parallelGoalSchema: 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>;
+export type ParallelGoal = z.infer<typeof parallelGoalSchema>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const parallelGoalSchema: 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>;
+export type ParallelGoal = z.infer<typeof parallelGoalSchema>;
+//# sourceMappingURL=parallelGoal.schema.d.ts.map

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

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

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const perpendicularGoalSchema: 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>;
+export type PerpendicularGoal = z.infer<typeof perpendicularGoalSchema>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const perpendicularGoalSchema: 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>;
+export type PerpendicularGoal = z.infer<typeof perpendicularGoalSchema>;
+//# sourceMappingURL=perpendicularGoal.schema.d.ts.map

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

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

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const segmentLengthGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segmentLength">;
+    objectType: z.ZodLiteral<"segment">;
+    targetLength: z.ZodNumber;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>;
+export type SegmentLengthGoal = z.infer<typeof segmentLengthGoalSchema>;

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const segmentLengthGoalSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segmentLength">;
+    objectType: z.ZodLiteral<"segment">;
+    targetLength: z.ZodNumber;
+    toleranceUnits: z.ZodNumber;
+}, z.core.$strict>;
+export type SegmentLengthGoal = z.infer<typeof segmentLengthGoalSchema>;
+//# sourceMappingURL=segmentLengthGoal.schema.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const throughPointsGoalSchema: 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>;
+export type ThroughPointsGoal = z.infer<typeof throughPointsGoalSchema>;

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export declare const throughPointsGoalSchema: 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>;
+export type ThroughPointsGoal = z.infer<typeof throughPointsGoalSchema>;
+//# sourceMappingURL=throughPointsGoal.schema.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const geometryIdSchema: z.ZodString;

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const geometryIdSchema: z.ZodString;
+//# sourceMappingURL=identifier.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identifier.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/identifier.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB,aAKzB,CAAA"}

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const lineSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>;
+export type Line = z.infer<typeof lineSchema>;

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const lineSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"line">;
+    through: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>;
+export type Line = z.infer<typeof lineSchema>;
+//# sourceMappingURL=line.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"line.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/line.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU;;;;kBAMZ,CAAA;AAEX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schemas/migrate.d.cts

@@ -0,0 +1,21 @@
+export interface MigrationStep {
+    from: number;
+    to: number;
+    migrate: (document: Record<string, unknown>) => Record<string, unknown>;
+}
+export type MigrationOutcome = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    message: string;
+};
+/**
+ * Brings a stored document up to `latestVersion` by applying steps in order.
+ *
+ * Failure is a message, never a throw: the input is untrusted JSON from a
+ * database or a request body, and the caller wants to report it rather than
+ * crash. A document from a *newer* version fails too — downgrading by guessing
+ * which fields to drop would silently destroy student work.
+ */
+export declare function applyMigrations(input: unknown, steps: readonly MigrationStep[], latestVersion: number): MigrationOutcome;

package/dist/schemas/migrate.d.ts

@@ -0,0 +1,22 @@
+export interface MigrationStep {
+    from: number;
+    to: number;
+    migrate: (document: Record<string, unknown>) => Record<string, unknown>;
+}
+export type MigrationOutcome = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    message: string;
+};
+/**
+ * Brings a stored document up to `latestVersion` by applying steps in order.
+ *
+ * Failure is a message, never a throw: the input is untrusted JSON from a
+ * database or a request body, and the caller wants to report it rather than
+ * crash. A document from a *newer* version fails too — downgrading by guessing
+ * which fields to drop would silently destroy student work.
+ */
+export declare function applyMigrations(input: unknown, steps: readonly MigrationStep[], latestVersion: number): MigrationOutcome;
+//# sourceMappingURL=migrate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/schemas/migrate.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACxE;AAED,MAAM,MAAM,gBAAgB,GAC1B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAOxE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,aAAa,EAAE,MAAM,GACpB,gBAAgB,CAgDlB"}

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const objectTypeNameSchema: z.ZodEnum<{
+    point: "point";
+    segment: "segment";
+    line: "line";
+    circle: "circle";
+}>;
+export type ObjectTypeName = z.infer<typeof objectTypeNameSchema>;

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const objectTypeNameSchema: z.ZodEnum<{
+    point: "point";
+    segment: "segment";
+    line: "line";
+    circle: "circle";
+}>;
+export type ObjectTypeName = z.infer<typeof objectTypeNameSchema>;
+//# sourceMappingURL=objectTypeName.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objectTypeName.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/objectTypeName.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,oBAAoB;;;;;EAAiD,CAAA;AAElF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const pointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export type Point = z.infer<typeof pointSchema>;
+export declare const givenPointSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"point">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    draggable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GivenPoint = z.infer<typeof givenPointSchema>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const pointSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export type Point = z.infer<typeof pointSchema>;
+export declare const givenPointSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"point">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    draggable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type GivenPoint = z.infer<typeof givenPointSchema>;
+//# sourceMappingURL=point.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"point.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/point.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,WAAW;;;kBAKb,CAAA;AAEX,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,gBAAgB;;;;;;;kBASlB,CAAA;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const freePointOriginSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export declare const onObjectPointOriginSchema: z.ZodObject<{
+    onObject: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>;
+export declare const intersectionPointOriginSchema: z.ZodObject<{
+    intersectionOf: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>;
+export declare const pointOriginSchema: z.ZodUnion<readonly [z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    onObject: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    intersectionOf: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>]>;
+export type FreePointOrigin = z.infer<typeof freePointOriginSchema>;
+export type OnObjectPointOrigin = z.infer<typeof onObjectPointOriginSchema>;
+export type IntersectionPointOrigin = z.infer<typeof intersectionPointOriginSchema>;
+export type PointOrigin = z.infer<typeof pointOriginSchema>;

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const freePointOriginSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>;
+export declare const onObjectPointOriginSchema: z.ZodObject<{
+    onObject: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>;
+export declare const intersectionPointOriginSchema: z.ZodObject<{
+    intersectionOf: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>;
+export declare const pointOriginSchema: z.ZodUnion<readonly [z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    onObject: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    intersectionOf: z.ZodTuple<[z.ZodString, z.ZodString], null>;
+}, z.core.$strict>]>;
+export type FreePointOrigin = z.infer<typeof freePointOriginSchema>;
+export type OnObjectPointOrigin = z.infer<typeof onObjectPointOriginSchema>;
+export type IntersectionPointOrigin = z.infer<typeof intersectionPointOriginSchema>;
+export type PointOrigin = z.infer<typeof pointOriginSchema>;
+//# sourceMappingURL=pointOrigin.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pointOrigin.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/pointOrigin.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,qBAAqB;;;kBAKvB,CAAA;AAIX,eAAO,MAAM,yBAAyB;;;kBAK3B,CAAA;AAEX,eAAO,MAAM,6BAA6B;;kBAI/B,CAAA;AAIX,eAAO,MAAM,iBAAiB;;;;;;;;oBAI5B,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AACnF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const segmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>;
+export type Segment = z.infer<typeof segmentSchema>;

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const segmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"segment">;
+    from: z.ZodString;
+    to: z.ZodString;
+}, z.core.$strict>;
+export type Segment = z.infer<typeof segmentSchema>;
+//# sourceMappingURL=segment.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"segment.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/segment.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,aAAa;;;;;kBAOf,CAAA;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/dist/schemas/v1ToV2.d.cts

@@ -0,0 +1,37 @@
+import { MigrationStep } from './migrate.cjs';
+/** The version both steps below produce. */
+export declare const v2SchemaVersion = 2;
+/**
+ * A stored v1 attempt as a v2 one: `points` and `constructions` become the
+ * single `entities` record, `constructedPointIds` becomes `answerEntityIds`
+ * **plus every construction id**, and every entity gets an explicit
+ * presentation entry.
+ *
+ * The presentation row is the only line here that is not a rename. A v1 attempt
+ * has no concept of an implicit entity — everything in it came from a student
+ * gesture and is drawn — so `presentation: {}` plus the attempt's `implicit`
+ * default would hide every construction a student ever made (ADR 0008).
+ *
+ * `answerEntityIds` gaining the construction ids reproduces v1 grading exactly:
+ * v1 keeps a candidacy list for points only and treats every construction as a
+ * candidate.
+ */
+export declare const geometryStateV1ToV2: MigrationStep;
+/**
+ * A stored v1 exercise as a v2 one: `givens[]` becomes the same `entities`
+ * record the attempt uses, `label` moves into `presentation` and `draggable`
+ * becomes the `draggableEntityIds` list.
+ *
+ * `id`, `viewport`, `showGrid`, `allowedObjects`, `tools` and `goals` are
+ * carried over untouched — the goals array migrates by identity — and anything
+ * else a stored document carries is carried over too, so that the strict v2
+ * schema rejects an unknown field rather than this step silently eating it.
+ *
+ * An unlabelled given gets **no** presentation entry: the exercise's default
+ * role is `explicit`, so `{ role: 'explicit' }` and no entry mean the same
+ * thing, and the smaller document is the one that stays true if a given is
+ * later relabelled.
+ *
+ * A duplicate id is refused rather than collapsed — see `claimId()`.
+ */
+export declare const geometryExerciseV1ToV2: MigrationStep;

package/dist/schemas/v1ToV2.d.ts

@@ -0,0 +1,38 @@
+import { MigrationStep } from './migrate.js';
+/** The version both steps below produce. */
+export declare const v2SchemaVersion = 2;
+/**
+ * A stored v1 attempt as a v2 one: `points` and `constructions` become the
+ * single `entities` record, `constructedPointIds` becomes `answerEntityIds`
+ * **plus every construction id**, and every entity gets an explicit
+ * presentation entry.
+ *
+ * The presentation row is the only line here that is not a rename. A v1 attempt
+ * has no concept of an implicit entity — everything in it came from a student
+ * gesture and is drawn — so `presentation: {}` plus the attempt's `implicit`
+ * default would hide every construction a student ever made (ADR 0008).
+ *
+ * `answerEntityIds` gaining the construction ids reproduces v1 grading exactly:
+ * v1 keeps a candidacy list for points only and treats every construction as a
+ * candidate.
+ */
+export declare const geometryStateV1ToV2: MigrationStep;
+/**
+ * A stored v1 exercise as a v2 one: `givens[]` becomes the same `entities`
+ * record the attempt uses, `label` moves into `presentation` and `draggable`
+ * becomes the `draggableEntityIds` list.
+ *
+ * `id`, `viewport`, `showGrid`, `allowedObjects`, `tools` and `goals` are
+ * carried over untouched — the goals array migrates by identity — and anything
+ * else a stored document carries is carried over too, so that the strict v2
+ * schema rejects an unknown field rather than this step silently eating it.
+ *
+ * An unlabelled given gets **no** presentation entry: the exercise's default
+ * role is `explicit`, so `{ role: 'explicit' }` and no entry mean the same
+ * thing, and the smaller document is the one that stays true if a given is
+ * later relabelled.
+ *
+ * A duplicate id is refused rather than collapsed — see `claimId()`.
+ */
+export declare const geometryExerciseV1ToV2: MigrationStep;
+//# sourceMappingURL=v1ToV2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v1ToV2.d.ts","sourceRoot":"","sources":["../../src/schemas/v1ToV2.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAY9C,4CAA4C;AAC5C,eAAO,MAAM,eAAe,IAAI,CAAA;AA8EhC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAsCjC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,EAAE,aA8CpC,CAAA"}

package/dist/schemas/v2ToV3.d.cts

@@ -0,0 +1,37 @@
+import { ZodType } from 'zod';
+import { MigrationStep } from './migrate.cjs';
+/** The version the step below produces. */
+export declare const v3SchemaVersion = 3;
+/**
+ * Just enough of a schema for the gate: the next version's parser, passed in
+ * rather than imported to keep this module free of a cycle with
+ * `exercise.schema.ts` — and small enough that a test can substitute a laxer
+ * one and watch the gate react.
+ */
+export interface DocumentGate {
+    safeParse(input: unknown): {
+        success: boolean;
+    };
+}
+/**
+ * An exercise hop that adds vocabulary and changes nothing it already had. The
+ * refusal rule, stated exactly: **a document that is invalid at `from` and
+ * valid at `from + 1` is refused.** That is what silent promotion means, and it
+ * covers every way the next version can be wider — a new field, a new entity
+ * kind, a new goal type, a new `allowedObjects` member, a new presentation
+ * entry, a loosened value — without the step having to enumerate them or read
+ * issue codes to guess which is which.
+ *
+ * A document that is invalid at **both** versions passes through untouched, so
+ * an ordinary fault (a bad viewport, a dangling parent) is still reported by
+ * `geometryExerciseSchema` at its own document path rather than refiled here as
+ * one message under `schemaVersion`. It is rejected either way; only the quality
+ * of the error differs, and the path is the better answer.
+ *
+ * `frozenSchema` must be a transcription of version `from` and `nextSchema` the
+ * parser of version `from + 1` — frozen as well unless that is the current one,
+ * because a current schema's version literal would never accept the promotion.
+ */
+export declare function createIdentityExerciseStep(from: number, frozenSchema: ZodType, nextSchema: DocumentGate): MigrationStep;
+/** The v2 → v3 hop, gated against the version 3 schema it is given. */
+export declare function createGeometryExerciseV2ToV3(v3ExerciseSchema: DocumentGate): MigrationStep;

package/dist/schemas/v2ToV3.d.ts

@@ -0,0 +1,38 @@
+import { ZodType } from 'zod';
+import { MigrationStep } from './migrate.js';
+/** The version the step below produces. */
+export declare const v3SchemaVersion = 3;
+/**
+ * Just enough of a schema for the gate: the next version's parser, passed in
+ * rather than imported to keep this module free of a cycle with
+ * `exercise.schema.ts` — and small enough that a test can substitute a laxer
+ * one and watch the gate react.
+ */
+export interface DocumentGate {
+    safeParse(input: unknown): {
+        success: boolean;
+    };
+}
+/**
+ * An exercise hop that adds vocabulary and changes nothing it already had. The
+ * refusal rule, stated exactly: **a document that is invalid at `from` and
+ * valid at `from + 1` is refused.** That is what silent promotion means, and it
+ * covers every way the next version can be wider — a new field, a new entity
+ * kind, a new goal type, a new `allowedObjects` member, a new presentation
+ * entry, a loosened value — without the step having to enumerate them or read
+ * issue codes to guess which is which.
+ *
+ * A document that is invalid at **both** versions passes through untouched, so
+ * an ordinary fault (a bad viewport, a dangling parent) is still reported by
+ * `geometryExerciseSchema` at its own document path rather than refiled here as
+ * one message under `schemaVersion`. It is rejected either way; only the quality
+ * of the error differs, and the path is the better answer.
+ *
+ * `frozenSchema` must be a transcription of version `from` and `nextSchema` the
+ * parser of version `from + 1` — frozen as well unless that is the current one,
+ * because a current schema's version literal would never accept the promotion.
+ */
+export declare function createIdentityExerciseStep(from: number, frozenSchema: ZodType, nextSchema: DocumentGate): MigrationStep;
+/** The v2 → v3 hop, gated against the version 3 schema it is given. */
+export declare function createGeometryExerciseV2ToV3(v3ExerciseSchema: DocumentGate): MigrationStep;
+//# sourceMappingURL=v2ToV3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v2ToV3.d.ts","sourceRoot":"","sources":["../../src/schemas/v2ToV3.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAA;AAClC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAG9C,2CAA2C;AAC3C,eAAO,MAAM,eAAe,IAAI,CAAA;AAEhC;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAA;CAChD;AAkBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,OAAO,EACrB,UAAU,EAAE,YAAY,GACvB,aAAa,CAkBf;AAED,uEAAuE;AACvE,wBAAgB,4BAA4B,CAAC,gBAAgB,EAAE,YAAY,GAAG,aAAa,CAE1F"}

package/dist/schemas/v3ToV4.d.cts

@@ -0,0 +1,3 @@
+import { MigrationStep } from './migrate.cjs';
+import { DocumentGate } from './v2ToV3.cjs';
+export declare function createGeometryExerciseV3ToV4(currentExerciseSchema: DocumentGate): MigrationStep;

package/dist/schemas/v3ToV4.d.ts

@@ -0,0 +1,4 @@
+import { MigrationStep } from './migrate.js';
+import { DocumentGate } from './v2ToV3.js';
+export declare function createGeometryExerciseV3ToV4(currentExerciseSchema: DocumentGate): MigrationStep;
+//# sourceMappingURL=v3ToV4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"v3ToV4.d.ts","sourceRoot":"","sources":["../../src/schemas/v3ToV4.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAE9C,OAAO,EAA8B,KAAK,YAAY,EAAE,MAAM,UAAU,CAAA;AAExE,wBAAgB,4BAA4B,CAAC,qBAAqB,EAAE,YAAY,GAAG,aAAa,CAE/F"}

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

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const mathViewportSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+export type MathViewport = z.infer<typeof mathViewportSchema>;

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export declare const mathViewportSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+export type MathViewport = z.infer<typeof mathViewportSchema>;
+//# sourceMappingURL=viewport.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"viewport.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/viewport.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,kBAAkB,wEAe3B,CAAA;AAEJ,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schemas.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./geometryState.schema-DKQ-durx.cjs"),t=require("./exercise.schema-BV2b7rtN.cjs");exports.applyMigrations=e.o,exports.createGoalSchema=e.y,exports.exerciseGradingSchema=t.t,exports.extraObjectPolicySchema=t.n,exports.geometryExerciseMigrations=t.r,exports.geometryExerciseSchema=t.i,exports.geometryGoalSchema=t.l,exports.geometryIdSchema=e.D,exports.geometryStateMigrations=e.t,exports.geometryStateSchema=e.n,exports.latestGeometryExerciseVersion=t.a,exports.latestGeometryStateVersion=e.r,exports.mathViewportSchema=t.u,exports.midpointGoalSchema=e.v,exports.migrateGeometryExercise=t.o,exports.migrateGeometryState=e.i,exports.objectTypeNameSchema=e.b,exports.parallelGoalSchema=e._,exports.parseGeometryExercise=t.s,exports.perpendicularGoalSchema=e.g,exports.pointSchema=e.l,exports.segmentLengthGoalSchema=e.h,exports.throughPointsGoalSchema=e.m,exports.toolNameSchema=t.c;

package/dist/schemas.mjs

@@ -0,0 +1,3 @@
+import { D as e, _ as t, b as n, g as r, h as i, i as a, l as o, m as s, n as c, o as l, r as u, t as d, v as f, y as p } from "./geometryState.schema-D0ixyGYE.js";
+import { a as m, c as h, i as g, l as _, n as v, o as y, r as b, s as x, t as S, u as C } from "./exercise.schema-ckVBW9XA.js";
+export { l as applyMigrations, p as createGoalSchema, S as exerciseGradingSchema, v as extraObjectPolicySchema, b as geometryExerciseMigrations, g as geometryExerciseSchema, _ as geometryGoalSchema, e as geometryIdSchema, d as geometryStateMigrations, c as geometryStateSchema, m as latestGeometryExerciseVersion, u as latestGeometryStateVersion, C as mathViewportSchema, f as midpointGoalSchema, y as migrateGeometryExercise, a as migrateGeometryState, n as objectTypeNameSchema, t as parallelGoalSchema, x as parseGeometryExercise, r as perpendicularGoalSchema, o as pointSchema, i as segmentLengthGoalSchema, s as throughPointsGoalSchema, h as toolNameSchema };

package/dist/snapping/computeSnap.d.cts

@@ -0,0 +1,30 @@
+import { SceneEntity } from '../geometry/hitTest.cjs';
+import { Point, PointId } from '../geometry/point.cjs';
+import { EntityId, PointDefinition } from '../geometry/entityModel.cjs';
+import { MathViewport } from '../schemas/viewport.schema.cjs';
+export type SnapKind = 'point' | 'intersection' | 'grid' | 'onObject';
+export interface SnapResult {
+    position: Point;
+    kind: SnapKind;
+    targetIds: string[];
+    parameter?: number;
+    distance: number;
+}
+export interface SnapScene {
+    points: ReadonlyMap<PointId, Point>;
+    objects: readonly SceneEntity[];
+    viewport: MathViewport;
+    showGrid?: boolean;
+    isSnapTarget?: (id: EntityId) => boolean;
+}
+export interface SnapOptions {
+    tolerance: number;
+    exclude?: readonly string[];
+    kinds?: readonly SnapKind[];
+}
+export declare function computeSnap(at: Point, scene: SnapScene, options: SnapOptions): SnapResult | null;
+export declare function snapPosition(at: Point, scene: SnapScene, options: SnapOptions): Point;
+export declare function originForSnap(placement: {
+    position: Point;
+    snap: SnapResult | null;
+}): PointDefinition | null;