@mathscan/geometry-engine 0.1.0

package/dist/renderer/usePointerGestures.d.ts

@@ -0,0 +1,47 @@
+import { RefObject } from 'react';
+import { Stage } from 'konva/lib/Stage';
+import { CanvasSize } from '../coordinates/transform.js';
+import { PointId } from '../geometry/point.js';
+import { ObjectTypeName } from '../schemas/objectTypeName.schema.js';
+import { Store } from '../store/createStore.js';
+import { ScreenPoint } from './gesturePolicy.js';
+import { ConnectionPreview } from './useConnectionPreview.js';
+type EpochStore = Pick<Store<{
+    interactionEpoch?: number;
+}>, 'getState' | 'subscribe'>;
+export interface PointerGestureHandlers {
+    tool: ObjectTypeName | null;
+    connection: ConnectionPreview;
+    placement: {
+        trackAt(pointer: ScreenPoint): void;
+        clearPointer(): void;
+    };
+    pointOnScreen(id: PointId): ScreenPoint | null;
+    canDragPoint(id: PointId): boolean;
+    dragPoint(id: PointId, to: ScreenPoint): void;
+    endPointDrag(id: PointId): void;
+    tapPoint(id: PointId): void;
+    tapObject(id: string): void;
+    tapStage(pointer: ScreenPoint): void;
+    abandonConstruction(): void;
+    disarmTool(): void;
+}
+/**
+ * The one pointer lifecycle behind both canvases (RFC 0004 § Decision 4,
+ * ADR 0011).
+ *
+ * Native Pointer Events on the stage's container, one contact at a time,
+ * identified by `pointerId` and captured while it is down. A contact is a tap
+ * until it moves its pointer type's threshold and a drag from then on, and it
+ * becomes geometry only through a normal release on the canvas — no Konva
+ * click, tap or drag handler, and no compatibility mouse event, can build or
+ * select anything on its own, so one contact is at most one creation.
+ *
+ * Every other ending is a cancellation, and every cancellation clears the
+ * preview, the snap marker, the pending endpoint and the contact, and closes a
+ * point drag's undo step where it stands: a dragged point keeps the last
+ * position it was moved to, and one Undo takes it back.
+ */
+export declare function usePointerGestures(stageRef: RefObject<Stage | null>, canvas: CanvasSize, store: EpochStore, handlers: PointerGestureHandlers): void;
+export {};
+//# sourceMappingURL=usePointerGestures.d.ts.map

package/dist/renderer/usePointerGestures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePointerGestures.d.ts","sourceRoot":"","sources":["../../src/renderer/usePointerGestures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAC1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AACjD,OAAO,EASL,KAAK,WAAW,EACjB,MAAM,iBAAiB,CAAA;AACxB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAE/D,KAAK,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC;IAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC,CAAA;AA+BtF,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAA;IAC3B,UAAU,EAAE,iBAAiB,CAAA;IAC7B,SAAS,EAAE;QAAE,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;QAAC,YAAY,IAAI,IAAI,CAAA;KAAE,CAAA;IAGxE,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAAA;IAC9C,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAA;IAGlC,SAAS,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI,CAAA;IAC7C,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAA;IAC/B,QAAQ,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAA;IAC3B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAAA;IAEpC,mBAAmB,IAAI,IAAI,CAAA;IAE3B,UAAU,IAAI,IAAI,CAAA;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,EACjC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,sBAAsB,GAC/B,IAAI,CA8VN"}

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const circleSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"circle">;
+    center: z.ZodString;
+    through: z.ZodString;
+}, z.core.$strict>;
+export type Circle = z.infer<typeof circleSchema>;

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

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

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

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

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare const freePointDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    at: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const onEntityPointDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    on: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>;
+export declare const intersectionPointDefinitionSchema: 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>;
+export declare const pointDefinitionSchema: z.ZodUnion<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>]>;
+export declare const segmentDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const lineDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const circleDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"circle">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const entityDefinitionSchema: z.ZodUnion<readonly [z.ZodUnion<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>]>;

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

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+export declare const freePointDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    at: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const onEntityPointDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"point">;
+    on: z.ZodString;
+    t: z.ZodNumber;
+}, z.core.$strict>;
+export declare const intersectionPointDefinitionSchema: 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>;
+export declare const pointDefinitionSchema: z.ZodUnion<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>]>;
+export declare const segmentDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"segment">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const lineDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const circleDefinitionSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"circle">;
+    parents: z.ZodReadonly<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+}, z.core.$strict>;
+export declare const entityDefinitionSchema: z.ZodUnion<readonly [z.ZodUnion<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>]>;
+//# sourceMappingURL=entityDefinition.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entityDefinition.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/entityDefinition.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,eAAO,MAAM,yBAAyB;;;;;;kBAK3B,CAAA;AAMX,eAAO,MAAM,6BAA6B;;;;kBAM/B,CAAA;AAKX,eAAO,MAAM,iCAAiC;;;;kBAMnC,CAAA;AAMX,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;oBAIhC,CAAA;AAQF,eAAO,MAAM,uBAAuB;;;kBAEzB,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;kBAEtB,CAAA;AAIX,eAAO,MAAM,sBAAsB;;;kBAExB,CAAA;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;oBAKuB,CAAA"}

package/dist/schemas/entityDocument.d.cts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { EntityDefinition, EntityId, EntityPresentation } from '../geometry/entityModel.cjs';
+/**
+ * The `entities` / `presentation` record shape, guarded before `z.record()`
+ * sees it.
+ *
+ * `z.record()` reports success and drops a `__proto__` entry, so a v2 document
+ * this engine wrote and read back loses that entity at load with no error at
+ * all. Two tidier places to catch it do not work, and were measured rather than
+ * argued (M2.G.1): a key schema is never asked, because zod skips a `__proto__`
+ * key *before* validating it, and a `superRefine` on the record runs after the
+ * entry is already gone. `z.preprocess` is the one hook that still sees the own
+ * property.
+ *
+ * One helper for all four records — both records of both documents — because a
+ * guard copied four times is a guard three of them will eventually not have.
+ */
+export declare function entityRecordSchema<Value extends z.ZodType>(value: Value): z.ZodType<Record<EntityId, z.output<Value>>, unknown>;
+/** A structural fault, at a path relative to the document that produced it. */
+export interface EntityDocumentIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/** The half of either v2 document these rules read. */
+export interface EntityDocumentShape {
+    entities: Record<EntityId, EntityDefinition>;
+    presentation: Record<EntityId, EntityPresentation>;
+}
+export interface EntityDocumentRules {
+    /**
+     * Whether a parent this document does not declare is an error.
+     *
+     * True for an exercise, which is self-contained. **False for an attempt**: a
+     * student's point sits on a given segment, and since ADR 0008's amendment a
+     * v2 attempt no longer copies the givens, so most of its parents live in the
+     * other document. `validateGeometryStateInput()` completes the check once it
+     * has the exercise — the same staging v1 used for point origins.
+     */
+    parentsMustBeDeclared: boolean;
+}
+/**
+ * Every structural fault a single v2 document can see in itself.
+ *
+ * Returned rather than reported, so both `superRefine` blocks map them onto
+ * their own issue paths and neither owns the rules.
+ */
+export declare function entityDocumentIssues(document: EntityDocumentShape, rules: EntityDocumentRules): EntityDocumentIssue[];
+/**
+ * The parent rules a v2 attempt cannot check alone, completed against the
+ * exercise it is an attempt at.
+ *
+ * `entityDocumentIssues()` skips a parent an attempt does not declare, because
+ * since ADR 0008 § Amendment most of them are given entities living in the
+ * other document. This is the other half, and the reason it is here rather than
+ * in `validateGeometryStateInput()`: a parent that turns out to be a given is
+ * judged by exactly the rules a declared one is, in exactly the same words.
+ *
+ * The *kind* rules are asked only of the parents the attempt does not declare —
+ * the rest have already been reported by the schema, and reporting them twice
+ * would make one fault look like two. One rule reaches the declared ones as
+ * well, because the schema cannot ask it: an entity **the exercise declares**
+ * may not be defined on an entity it does not (M2.G.5), and a parent the
+ * attempt declares is exactly the case that violates it.
+ */
+export declare function crossDocumentParentIssues(attempt: EntityDocumentShape, given: Record<EntityId, EntityDefinition>): EntityDocumentIssue[];
+/**
+ * Whether the two documents declaring the same id is a *collision* rather than
+ * a re-declaration.
+ *
+ * One rule, read by both callers, because they answer for the same document
+ * pair and had no reason to say it twice: `buildGeometryContext()` asks it to
+ * decide whether to drop the attempt's entity and report `duplicate-id`, and
+ * `validateGeometryStateInput()` asks it to refuse the document outright.
+ *
+ * A given **point** re-declared as a **point** is the one shared id that is
+ * not a collision — it is how the student moves a draggable given, and how
+ * every migrated v1 attempt arrives (ADR 0008 § Amendment). Every other pair
+ * is one document claiming an id the other already gave a different meaning.
+ */
+export declare function isCrossDocumentIdCollision(given: EntityDefinition, declared: EntityDefinition): boolean;
+/**
+ * The collisions of `isCrossDocumentIdCollision()`, as load errors.
+ *
+ * The context reports these as `duplicate-id` issues and then resolves the id
+ * to the *exercise's* declaration, so an attempt declaring segment `A` over
+ * given point `A` used to load clean and then have the given graded as the
+ * student's construction (M2.G.2). Refusing the document is the fix: nothing
+ * downstream has to decide what a contested id means, because it never gets
+ * one.
+ */
+export declare function crossDocumentIdCollisionIssues(attempt: EntityDocumentShape, given: Record<EntityId, EntityDefinition>): EntityDocumentIssue[];
+/** `answerEntityIds` and `draggableEntityIds` are the same list rule twice. */
+export declare function entityIdListIssues(ids: readonly EntityId[], field: string, document: EntityDocumentShape, options?: {
+    pointsOnly?: boolean;
+}): EntityDocumentIssue[];

package/dist/schemas/entityDocument.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { EntityDefinition, EntityId, EntityPresentation } from '../geometry/entityModel.js';
+/**
+ * The `entities` / `presentation` record shape, guarded before `z.record()`
+ * sees it.
+ *
+ * `z.record()` reports success and drops a `__proto__` entry, so a v2 document
+ * this engine wrote and read back loses that entity at load with no error at
+ * all. Two tidier places to catch it do not work, and were measured rather than
+ * argued (M2.G.1): a key schema is never asked, because zod skips a `__proto__`
+ * key *before* validating it, and a `superRefine` on the record runs after the
+ * entry is already gone. `z.preprocess` is the one hook that still sees the own
+ * property.
+ *
+ * One helper for all four records — both records of both documents — because a
+ * guard copied four times is a guard three of them will eventually not have.
+ */
+export declare function entityRecordSchema<Value extends z.ZodType>(value: Value): z.ZodType<Record<EntityId, z.output<Value>>, unknown>;
+/** A structural fault, at a path relative to the document that produced it. */
+export interface EntityDocumentIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/** The half of either v2 document these rules read. */
+export interface EntityDocumentShape {
+    entities: Record<EntityId, EntityDefinition>;
+    presentation: Record<EntityId, EntityPresentation>;
+}
+export interface EntityDocumentRules {
+    /**
+     * Whether a parent this document does not declare is an error.
+     *
+     * True for an exercise, which is self-contained. **False for an attempt**: a
+     * student's point sits on a given segment, and since ADR 0008's amendment a
+     * v2 attempt no longer copies the givens, so most of its parents live in the
+     * other document. `validateGeometryStateInput()` completes the check once it
+     * has the exercise — the same staging v1 used for point origins.
+     */
+    parentsMustBeDeclared: boolean;
+}
+/**
+ * Every structural fault a single v2 document can see in itself.
+ *
+ * Returned rather than reported, so both `superRefine` blocks map them onto
+ * their own issue paths and neither owns the rules.
+ */
+export declare function entityDocumentIssues(document: EntityDocumentShape, rules: EntityDocumentRules): EntityDocumentIssue[];
+/**
+ * The parent rules a v2 attempt cannot check alone, completed against the
+ * exercise it is an attempt at.
+ *
+ * `entityDocumentIssues()` skips a parent an attempt does not declare, because
+ * since ADR 0008 § Amendment most of them are given entities living in the
+ * other document. This is the other half, and the reason it is here rather than
+ * in `validateGeometryStateInput()`: a parent that turns out to be a given is
+ * judged by exactly the rules a declared one is, in exactly the same words.
+ *
+ * The *kind* rules are asked only of the parents the attempt does not declare —
+ * the rest have already been reported by the schema, and reporting them twice
+ * would make one fault look like two. One rule reaches the declared ones as
+ * well, because the schema cannot ask it: an entity **the exercise declares**
+ * may not be defined on an entity it does not (M2.G.5), and a parent the
+ * attempt declares is exactly the case that violates it.
+ */
+export declare function crossDocumentParentIssues(attempt: EntityDocumentShape, given: Record<EntityId, EntityDefinition>): EntityDocumentIssue[];
+/**
+ * Whether the two documents declaring the same id is a *collision* rather than
+ * a re-declaration.
+ *
+ * One rule, read by both callers, because they answer for the same document
+ * pair and had no reason to say it twice: `buildGeometryContext()` asks it to
+ * decide whether to drop the attempt's entity and report `duplicate-id`, and
+ * `validateGeometryStateInput()` asks it to refuse the document outright.
+ *
+ * A given **point** re-declared as a **point** is the one shared id that is
+ * not a collision — it is how the student moves a draggable given, and how
+ * every migrated v1 attempt arrives (ADR 0008 § Amendment). Every other pair
+ * is one document claiming an id the other already gave a different meaning.
+ */
+export declare function isCrossDocumentIdCollision(given: EntityDefinition, declared: EntityDefinition): boolean;
+/**
+ * The collisions of `isCrossDocumentIdCollision()`, as load errors.
+ *
+ * The context reports these as `duplicate-id` issues and then resolves the id
+ * to the *exercise's* declaration, so an attempt declaring segment `A` over
+ * given point `A` used to load clean and then have the given graded as the
+ * student's construction (M2.G.2). Refusing the document is the fix: nothing
+ * downstream has to decide what a contested id means, because it never gets
+ * one.
+ */
+export declare function crossDocumentIdCollisionIssues(attempt: EntityDocumentShape, given: Record<EntityId, EntityDefinition>): EntityDocumentIssue[];
+/** `answerEntityIds` and `draggableEntityIds` are the same list rule twice. */
+export declare function entityIdListIssues(ids: readonly EntityId[], field: string, document: EntityDocumentShape, options?: {
+    pointsOnly?: boolean;
+}): EntityDocumentIssue[];
+//# sourceMappingURL=entityDocument.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entityDocument.d.ts","sourceRoot":"","sources":["../../src/schemas/entityDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAqB7F;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,CAAC,CAAC,OAAO,EACxD,KAAK,EAAE,KAAK,GACX,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAmBvD;AAED,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAA;IAC5C,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;OAQG;IACH,qBAAqB,EAAE,OAAO,CAAA;CAC/B;AAuBD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,mBAAmB,EAC7B,KAAK,EAAE,mBAAmB,GACzB,mBAAmB,EAAE,CAuEvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,gBAAgB,CAAC,GACxC,mBAAmB,EAAE,CAwCvB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,gBAAgB,EACvB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,gBAAgB,CAAC,GACxC,mBAAmB,EAAE,CAWvB;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,SAAS,QAAQ,EAAE,EACxB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAO,GACrC,mBAAmB,EAAE,CAevB"}

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const entityRoleSchema: z.ZodEnum<{
+    implicit: "implicit";
+    explicit: "explicit";
+}>;
+export declare const entityPresentationSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        implicit: "implicit";
+        explicit: "explicit";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const entityRoleSchema: z.ZodEnum<{
+    implicit: "implicit";
+    explicit: "explicit";
+}>;
+export declare const entityPresentationSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        implicit: "implicit";
+        explicit: "explicit";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+//# sourceMappingURL=entityPresentation.schema.d.ts.map

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

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

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

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+import { MigrationOutcome, MigrationStep } from './migrate.cjs';
+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;