@mathscan/geometry-engine 0.1.0

package/dist/validation/validateGeometryExercise.d.ts

@@ -0,0 +1,31 @@
+import { GeometryExercise } from '../schemas/exercise.schema.js';
+import { GeometryExerciseWarning } from './getGeometryExerciseWarnings.js';
+export interface GeometryExerciseValidationIssue {
+    path: Array<string | number>;
+    message: string;
+}
+export type GeometryExerciseValidationResult = {
+    success: true;
+    data: GeometryExercise;
+    errors: [];
+    warnings: GeometryExerciseWarning[];
+} | {
+    success: false;
+    data: null;
+    errors: GeometryExerciseValidationIssue[];
+    warnings: [];
+};
+/**
+ * The whole stored exercise, authored solution included. Stored exercises are
+ * brought up to the current version before their structure is checked, exactly
+ * as attempts are (M2.6.b), and an embedded `solution` is then migrated and
+ * checked against the exercise as an attempt (ADR 0015), with its issues rooted
+ * at `solution`. On success `data.solution` is that normalized attempt.
+ *
+ * Grading does not go through here: Check and the student component load the
+ * solution-free projection, so a broken solution never disables them. An
+ * authoring tool does, and learns about it at save time.
+ */
+export declare function validateGeometryExercise(input: unknown): GeometryExerciseValidationResult;
+export declare function validateGeometryExerciseJson(json: string): GeometryExerciseValidationResult;
+//# sourceMappingURL=validateGeometryExercise.d.ts.map

package/dist/validation/validateGeometryExercise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateGeometryExercise.d.ts","sourceRoot":"","sources":["../../src/validation/validateGeometryExercise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAE5E,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IAC5B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,gCAAgC,GACxC;IACE,OAAO,EAAE,IAAI,CAAA;IACb,IAAI,EAAE,gBAAgB,CAAA;IACtB,MAAM,EAAE,EAAE,CAAA;IACV,QAAQ,EAAE,uBAAuB,EAAE,CAAA;CACpC,GACD;IACE,OAAO,EAAE,KAAK,CAAA;IACd,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,+BAA+B,EAAE,CAAA;IACzC,QAAQ,EAAE,EAAE,CAAA;CACb,CAAA;AAEL;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,gCAAgC,CAmBzF;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,gCAAgC,CAgB3F"}

package/dist/validation/validateGeometryState.d.cts

@@ -0,0 +1,16 @@
+import { GeometryExercise } from '../schemas/exercise.schema.cjs';
+import { GeometryState } from '../schemas/geometryState.schema.cjs';
+import { DetailedGeometryFeedback, GeometryValidationFeedback, ValidationResult } from './types.cjs';
+export declare function validateGeometryState(exercise: GeometryExercise, geometry: GeometryState): ValidationResult;
+export declare function evaluateGeometryState(exercise: GeometryExercise, geometry: GeometryState): GeometryValidationFeedback;
+/**
+ * The same grading, reported rather than summarized: why each goal landed where
+ * it did, as stable codes and entity ids (RFC 0004 § Decision 5). It measures
+ * nothing the plain evaluation does not — the codes are read off the existing
+ * goal handlers' own predicates — so the two can never disagree.
+ *
+ * `feedback` is exactly what `evaluateGeometryState()` returns for the same
+ * inputs. The extra work is one relevance pass per satisfied goal and the
+ * unresolved bookkeeping, which the plain path still skips.
+ */
+export declare function evaluateGeometryStateDetailed(exercise: GeometryExercise, geometry: GeometryState): DetailedGeometryFeedback;

package/dist/validation/validateGeometryState.d.ts

@@ -0,0 +1,17 @@
+import { GeometryExercise } from '../schemas/exercise.schema.js';
+import { GeometryState } from '../schemas/geometryState.schema.js';
+import { DetailedGeometryFeedback, GeometryValidationFeedback, ValidationResult } from './types.js';
+export declare function validateGeometryState(exercise: GeometryExercise, geometry: GeometryState): ValidationResult;
+export declare function evaluateGeometryState(exercise: GeometryExercise, geometry: GeometryState): GeometryValidationFeedback;
+/**
+ * The same grading, reported rather than summarized: why each goal landed where
+ * it did, as stable codes and entity ids (RFC 0004 § Decision 5). It measures
+ * nothing the plain evaluation does not — the codes are read off the existing
+ * goal handlers' own predicates — so the two can never disagree.
+ *
+ * `feedback` is exactly what `evaluateGeometryState()` returns for the same
+ * inputs. The extra work is one relevance pass per satisfied goal and the
+ * unresolved bookkeeping, which the plain path still skips.
+ */
+export declare function evaluateGeometryStateDetailed(exercise: GeometryExercise, geometry: GeometryState): DetailedGeometryFeedback;
+//# sourceMappingURL=validateGeometryState.d.ts.map

package/dist/validation/validateGeometryState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateGeometryState.d.ts","sourceRoot":"","sources":["../../src/validation/validateGeometryState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,OAAO,KAAK,EACV,wBAAwB,EAGxB,0BAA0B,EAG1B,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAGhB,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,gBAAgB,CAElB;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,0BAA0B,CAE5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,aAAa,GACtB,wBAAwB,CAE1B"}

package/dist/validation/validateGeometryStateInput.d.cts

@@ -0,0 +1,22 @@
+import { GeometryExercise } from '../schemas/exercise.schema.cjs';
+import { GeometryState } from '../schemas/geometryState.schema.cjs';
+import { GeometryExerciseValidationIssue } from './validateGeometryExercise.cjs';
+export type GeometryStateInputValidationResult = {
+    success: true;
+    data: GeometryState;
+    errors: [];
+} | {
+    success: false;
+    data: null;
+    errors: GeometryExerciseValidationIssue[];
+};
+export declare function validateGeometryStateInput(input: unknown, exercise?: GeometryExercise): GeometryStateInputValidationResult;
+/**
+ * Restores an attempt from stored JSON — the counterpart to
+ * validateGeometryExerciseJson(). Pass the exercise to also check the attempt
+ * against it — only allowed object types, parents naming entities that exist in
+ * one of the two documents — and to normalize it, which is what drops the given
+ * points a migrated v1 attempt still carries.
+ */
+export declare function validateGeometryStateJson(json: string, exercise?: GeometryExercise): GeometryStateInputValidationResult;
+export declare function serializeGeometryState(geometry: GeometryState): string;

package/dist/validation/validateGeometryStateInput.d.ts

@@ -0,0 +1,23 @@
+import { GeometryExercise } from '../schemas/exercise.schema.js';
+import { GeometryState } from '../schemas/geometryState.schema.js';
+import { GeometryExerciseValidationIssue } from './validateGeometryExercise.js';
+export type GeometryStateInputValidationResult = {
+    success: true;
+    data: GeometryState;
+    errors: [];
+} | {
+    success: false;
+    data: null;
+    errors: GeometryExerciseValidationIssue[];
+};
+export declare function validateGeometryStateInput(input: unknown, exercise?: GeometryExercise): GeometryStateInputValidationResult;
+/**
+ * Restores an attempt from stored JSON — the counterpart to
+ * validateGeometryExerciseJson(). Pass the exercise to also check the attempt
+ * against it — only allowed object types, parents naming entities that exist in
+ * one of the two documents — and to normalize it, which is what drops the given
+ * points a migrated v1 attempt still carries.
+ */
+export declare function validateGeometryStateJson(json: string, exercise?: GeometryExercise): GeometryStateInputValidationResult;
+export declare function serializeGeometryState(geometry: GeometryState): string;
+//# sourceMappingURL=validateGeometryStateInput.d.ts.map

package/dist/validation/validateGeometryStateInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateGeometryStateInput.d.ts","sourceRoot":"","sources":["../../src/validation/validateGeometryStateInput.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAGL,KAAK,aAAa,EACnB,MAAM,iCAAiC,CAAA;AACxC,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAA;AAwDjF,MAAM,MAAM,kCAAkC,GAC1C;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,EAAE,CAAA;CAAE,GAClD;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,+BAA+B,EAAE,CAAA;CAAE,CAAA;AAE7E,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kCAAkC,CAgEpC;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kCAAkC,CAepC;AAID,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEtE"}

package/dist/validation.cjs

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./geometryState.schema-DKQ-durx.cjs"),t=require("./goals-CxR5qPDC.cjs"),n=require("./geometryAttemptStatus-N_XHIkiS.cjs");function r(e,t){return i(e,t).result}function i(e,t){return o(e,t,!1).feedback}function a(e,t){return o(e,t,!0)}function o(n,r,i){let a=n.goals.length===0,o=n.grading?.extraObjects===`reject`,l=i||o;if(a&&!i)return{feedback:{result:{status:`incorrect`,goals:[]},goals:[]},goals:[],diagnostics:[],extraEntityIds:[]};let u=t.d(n,r),d={exercise:n,points:u.points},f=[],p=[],m=[];for(let t of r.answerEntityIds){if(e.O(n.entities,t))continue;let r=u.definitionOf(t);if(r){if(l&&m.push(t),u.resolvedOf(t)===void 0){l&&p.push({id:t,definition:r});continue}f.push({id:t,definition:r})}}let h=[],g=[],_=new Set;for(let e of n.goals){let n=f.filter(n=>t.r(n,e,d));if(l)for(let e of n)_.add(e.id);let r=n.length>0,a=r&&!i?[]:f.filter(n=>t.i(n,e,d)),o=r?n:a;if(h.push({id:e.id,status:r?`correct`:`incorrect`,constructionIds:o.filter(e=>!t.f(e)).map(e=>e.id),pointIds:o.filter(t.f).map(e=>e.id)}),!i)continue;let s=p.filter(n=>t.n(n,e));g.push({id:e.id,status:r?`correct`:`incorrect`,code:r?`goal-satisfied`:f.some(n=>t.n(n,e))?`goal-not-satisfied`:s.length>0?`unresolved-candidate`:`no-candidate`,matchedEntityIds:c(n),relevantEntityIds:c(a),unresolvedEntityIds:c(s)})}let v=l?s(m,_,u):[],y={status:!a&&h.every(e=>e.status===`correct`)&&!(o&&v.length>0)?`correct`:`incorrect`,goals:h.map(({id:e,status:t})=>({id:e,status:t}))},b=[];return a&&b.push({code:`no-goals`,entityIds:[]}),p.length>0&&b.push({code:`unresolved-entity`,entityIds:c(p)}),o&&v.length>0&&b.push({code:`extra-objects`,entityIds:v}),{feedback:{result:y,goals:h},goals:g,diagnostics:b,extraEntityIds:v}}function s(e,t,n){let r=new Set(t),i=[...t];for(;i.length>0;){let e=i.pop();if(e!==void 0)for(let t of n.parentsOf(e))r.has(t)||(r.add(t),i.push(t))}return[...new Set(e)].filter(e=>!r.has(e))}function c(e){return[...new Set(e.map(e=>e.id))]}function l(e,t){let r=n.r(e);if(!r.success)return{success:!1,data:null,errors:r.errors.map(e=>({...e,source:`exercise`})),warnings:[]};let a=n.u(t,r.data);return a.success?{success:!0,data:i(r.data,a.data),fingerprints:{exercise:n.s(r.data),attempt:n.o(a.data)},errors:[],warnings:r.warnings}:{success:!1,data:null,errors:a.errors.map(e=>({...e,source:`geometry`})),warnings:[]}}function u(e,t){let r=n.r(e);if(!r.success)return{success:!1,data:null,errors:r.errors.map(e=>({...e,source:`exercise`,code:`invalid-exercise`})),warnings:[]};let i=n.u(t,r.data);return i.success?{success:!0,data:a(r.data,i.data),fingerprints:{exercise:n.s(r.data),attempt:n.o(i.data)},errors:[],warnings:r.warnings}:{success:!1,data:null,errors:i.errors.map(e=>({...e,source:`geometry`,code:`invalid-attempt`})),warnings:[]}}function d(e){let n=t.l(e);return e.goals.map(r=>({id:r.id,shape:t.o(r,{exercise:e,points:n})}))}function f(e){return{success:!1,data:null,errors:e}}function p(e){let t=n.r(e);if(!t.success)return f(t.errors.map(e=>({code:`invalid-exercise`,...e})));if(t.solution===void 0)return f([{code:`invalid-canonical-attempt`,path:[`solution`],message:`this exercise has no canonical solution`}]);let i=n.i(t.solution,t.data);return i.success?r(t.data,i.data).status===`correct`?{success:!0,data:i.data,errors:[]}:f([{code:`canonical-attempt-incorrect`,path:[`solution`],message:`the canonical solution does not satisfy this exercise`}]):f(i.errors.map(e=>({code:`invalid-canonical-attempt`,...e})))}function m(e){let t=n.r(e);if(!t.success)return{success:!1,data:null,errors:t.errors,warnings:[]};if(t.solution===void 0)return{success:!0,data:t.data,errors:[],warnings:t.warnings};let r=n.i(t.solution,t.data);return r.success?{success:!0,data:{...t.data,solution:r.data},errors:[],warnings:t.warnings}:{success:!1,data:null,errors:r.errors,warnings:[]}}function h(e){try{return m(JSON.parse(e))}catch(e){return{success:!1,data:null,errors:[{path:[],message:e instanceof Error?e.message:`Invalid JSON syntax`}],warnings:[]}}}exports.checkGeometryAnswer=l,exports.checkGeometryAnswerDetailed=u,exports.createEmptyGeometryAttempt=n.t,exports.deriveGeometryCanvasFeedback=n.c,exports.evaluateGeometryState=i,exports.evaluateGeometryStateDetailed=a,exports.getGeometryExerciseWarnings=n.a,exports.getGoalKindHandler=t.t,exports.hasGeometryWork=n.n,exports.intersectionsOf=e.V,exports.revealGeometryAnswers=d,exports.revealGeometryAttempt=p,exports.serializeGeometryState=n.l,exports.validateGeometryExercise=m,exports.validateGeometryExerciseJson=h,exports.validateGeometryState=r,exports.validateGeometryStateInput=n.u,exports.validateGeometryStateJson=n.d;
+//# sourceMappingURL=validation.cjs.map

package/dist/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.cjs","names":[],"sources":["../src/validation/validateGeometryState.ts","../src/validation/checkGeometryAnswer.ts","../src/validation/revealGeometryAnswers.ts","../src/validation/revealGeometryAttempt.ts","../src/validation/validateGeometryExercise.ts"],"sourcesContent":["import { entryOf } from '../geometry/entityRecord'\nimport type { EntityId } from '../geometry/entityModel'\nimport type { GeometryExercise } from '../schemas/exercise.schema'\nimport type { GeometryState } from '../schemas/geometryState.schema'\nimport { isCandidatePoint, type GoalCandidate } from '../geometry/goalCandidate'\nimport { buildGeometryContext } from '../state/geometryContext'\nimport type {\n  DetailedGeometryFeedback,\n  DetailedGoalResult,\n  GeometryDiagnostic,\n  GeometryValidationFeedback,\n  GoalGeometryFeedback,\n  ValidationContext,\n  ValidationResult,\n} from './types'\nimport { goalAcceptsCandidate, goalSatisfiedBy, isRelevantGoalAttempt } from './goals'\n\nexport function validateGeometryState(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): ValidationResult {\n  return evaluateGeometryState(exercise, geometry).result\n}\n\nexport function evaluateGeometryState(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): GeometryValidationFeedback {\n  return evaluate(exercise, geometry, false).feedback\n}\n\n/**\n * The same grading, reported rather than summarized: why each goal landed where\n * it did, as stable codes and entity ids (RFC 0004 § Decision 5). It measures\n * nothing the plain evaluation does not — the codes are read off the existing\n * goal handlers' own predicates — so the two can never disagree.\n *\n * `feedback` is exactly what `evaluateGeometryState()` returns for the same\n * inputs. The extra work is one relevance pass per satisfied goal and the\n * unresolved bookkeeping, which the plain path still skips.\n */\nexport function evaluateGeometryStateDetailed(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): DetailedGeometryFeedback {\n  return evaluate(exercise, geometry, true)\n}\n\nfunction evaluate(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n  detailed: boolean,\n): DetailedGeometryFeedback {\n  // An exercise nobody can answer is incorrect, and the report now says so in\n  // one word rather than leaving a host to infer it from an empty goal list.\n  // The plain path stops here, as it always has; the report does not, because\n  // an unresolved answer entity is reported whatever the goals say — there is\n  // simply no goal loop to run below.\n  const noGoals = exercise.goals.length === 0\n  // Absence means `allow` (ADR 0013), so an exercise authored before v3 keeps\n  // exactly the verdict it had. The extra-object sets cost a closure walk, so\n  // the plain path computes them only when the policy actually reads them:\n  // under `allow` they are reported and never graded on.\n  const strict = exercise.grading?.extraObjects === 'reject'\n  const needsExtras = detailed || strict\n  if (noGoals && !detailed) {\n    return {\n      feedback: { result: { status: 'incorrect', goals: [] }, goals: [] },\n      goals: [],\n      diagnostics: [],\n      extraEntityIds: [],\n    }\n  }\n\n  // Coordinates come from the dependency graph, not from storage: a derived\n  // point is wherever its parents currently put it. A point that cannot be\n  // resolved (its object was deleted, its intersection vanished) is absent\n  // here and therefore cannot satisfy anything.\n  const scene = buildGeometryContext(exercise, geometry)\n  // The scene's own index, not a copy: `ValidationContext.points` is read-only\n  // by contract (M2.3.c), so there is nothing to defend it against. The copy\n  // this replaced was one `Map` allocation and one full rehash per validation.\n  const context: ValidationContext = { exercise, points: scene.points }\n  // One list for every kind, which is what `answerEntityIds` is: v1 kept a\n  // candidacy list for points only and treated every construction as a\n  // candidate, and the migration reproduces that by naming both. A goal kind\n  // decides for itself which candidates it can be satisfied by (a midpoint goal\n  // wants a point, a perpendicular goal wants a segment or line); points the\n  // student only used as scaffolding are not named here and are never\n  // candidates.\n  //\n  // An entity that no longer resolves has no coordinates to measure, so it is\n  // dropped here rather than left for a handler to trip over: handlers may\n  // assume every candidate they are handed can be looked up in `points`. An\n  // entity resolves exactly when everything it is built on does, which is the\n  // index's answer rather than a second scan.\n  const candidates: GoalCandidate[] = []\n  // Answer entities that exist but have no coordinates this evaluation. The\n  // plain path drops them silently; the report names them, because \"you built\n  // it and then deleted what it stood on\" is not the same as \"you built\n  // nothing\".\n  const unresolved: GoalCandidate[] = []\n  // Set `A` of RFC 0004 § Decision 6, in answer order: every id the attempt\n  // owns and names as an answer, resolved or not. The extra-object policy\n  // subtracts from this list and nothing else, so scaffolding the student never\n  // offered as an answer cannot be an extra.\n  const answered: EntityId[] = []\n  for (const id of geometry.answerEntityIds) {\n    // A given is not an answer to anything (ADR 0008 § Amendment), whatever\n    // the list says. `validateGeometryStateInput()` already strips these on\n    // load, but grading takes both documents directly — a host holding a\n    // migrated v1 attempt it never loaded through the engine, or a store still\n    // in memory, would otherwise have the exercise's own given graded as the\n    // student's construction (M2.G.2).\n    if (entryOf(exercise.entities, id)) continue\n    const definition = scene.definitionOf(id)\n    if (!definition) continue\n    if (needsExtras) answered.push(id)\n    if (scene.resolvedOf(id) === undefined) {\n      if (needsExtras) unresolved.push({ id, definition })\n      continue\n    }\n    candidates.push({ id, definition })\n  }\n  const goals: GoalGeometryFeedback[] = []\n  const detailedGoals: DetailedGoalResult[] = []\n  // Set `M`: every candidate that satisfies *some* goal. A union, not an\n  // assignment — one entity may answer two goals and two entities may answer\n  // one, and this policy deliberately does not count solutions.\n  const matched = new Set<EntityId>()\n  for (const goal of exercise.goals) {\n    const matching = candidates.filter((candidate) => goalSatisfiedBy(candidate, goal, context))\n    if (needsExtras) for (const candidate of matching) matched.add(candidate.id)\n    const correct = matching.length > 0\n    // Highlighting wants relevance only when the goal is unsatisfied; the\n    // report wants it either way, so a correct goal still says which other\n    // attempts were aimed at it.\n    const relevant =\n      correct && !detailed\n        ? []\n        : candidates.filter((candidate) => isRelevantGoalAttempt(candidate, goal, context))\n    const shown = correct ? matching : relevant\n    goals.push({\n      id: goal.id,\n      status: correct ? 'correct' : 'incorrect',\n      constructionIds: shown.filter((candidate) => !isCandidatePoint(candidate)).map((c) => c.id),\n      pointIds: shown.filter(isCandidatePoint).map((candidate) => candidate.id),\n    })\n    if (!detailed) continue\n    const unresolvedForGoal = unresolved.filter((candidate) =>\n      goalAcceptsCandidate(candidate, goal),\n    )\n    detailedGoals.push({\n      id: goal.id,\n      status: correct ? 'correct' : 'incorrect',\n      code: correct\n        ? 'goal-satisfied'\n        : candidates.some((candidate) => goalAcceptsCandidate(candidate, goal))\n          ? 'goal-not-satisfied'\n          : unresolvedForGoal.length > 0\n            ? 'unresolved-candidate'\n            : 'no-candidate',\n      matchedEntityIds: distinctIds(matching),\n      relevantEntityIds: distinctIds(relevant),\n      unresolvedEntityIds: distinctIds(unresolvedForGoal),\n    })\n  }\n  // `A − (M ∪ S)`: answer entities no goal needed, and that nothing a goal\n  // needed was built on. Empty unless the policy or the report asked for it.\n  const extraEntityIds = needsExtras ? withoutSupport(answered, matched, scene) : []\n  const goalsMet = !noGoals && goals.every((goal) => goal.status === 'correct')\n  const result: ValidationResult = {\n    // `every` on an empty list is vacuously true, and a goalless exercise is\n    // incorrect — the one place the two disagree.\n    //\n    // Under `reject`, an extra answer entity makes the attempt incorrect while\n    // every goal stays as its own predicate found it: \"the goals are met and\n    // something unused is still on the canvas\" is a different thing from a\n    // failed goal, and the diagnostic below is where it is said.\n    status: goalsMet && !(strict && extraEntityIds.length > 0) ? 'correct' : 'incorrect',\n    goals: goals.map(({ id, status }) => ({ id, status })),\n  }\n  const diagnostics: GeometryDiagnostic[] = []\n  if (noGoals) diagnostics.push({ code: 'no-goals', entityIds: [] })\n  // Informational: an unresolved entity does not make a satisfied exercise\n  // incorrect. Reporting it regardless is what lets a host say \"this one is\n  // no longer on the canvas\" instead of leaving it unexplained.\n  if (unresolved.length > 0) {\n    diagnostics.push({ code: 'unresolved-entity', entityIds: distinctIds(unresolved) })\n  }\n  // Only under `reject`: the list is reported either way, but it is a finding\n  // about the attempt only where the author asked for strictness. Last, because\n  // an unresolved extra is explained by the diagnostic above it.\n  if (strict && extraEntityIds.length > 0) {\n    diagnostics.push({ code: 'extra-objects', entityIds: extraEntityIds })\n  }\n  return { feedback: { result, goals }, goals: detailedGoals, diagnostics, extraEntityIds }\n}\n\n/**\n * `answered` minus the matched entities and minus set `S`, their transitive\n * parents — the support closure.\n *\n * Support is exempt because it is not an alternative answer: the two points a\n * correct segment is drawn between, and the helper objects a correct derived\n * point stands on, are the construction, however the student named them. That\n * is why the walk goes *up* the graph from what satisfied a goal rather than\n * down from every answer entity.\n *\n * An unresolved answer entity cannot be in `matched` — nothing measured it —\n * and it can only be support if something that did resolve was built on it,\n * which is impossible. So it stays, which is the reported outcome RFC 0004 §\n * Decision 6 names.\n */\nfunction withoutSupport(\n  answered: readonly EntityId[],\n  matched: ReadonlySet<EntityId>,\n  scene: { parentsOf(id: EntityId): readonly EntityId[] },\n): EntityId[] {\n  const exempt = new Set<EntityId>(matched)\n  const pending = [...matched]\n  // Visited-bounded, because the graph is walked by id: a cycle is\n  // unrepresentable in a stored document, but this must not depend on that.\n  while (pending.length > 0) {\n    const id = pending.pop()\n    if (id === undefined) continue\n    for (const parent of scene.parentsOf(id)) {\n      if (exempt.has(parent)) continue\n      exempt.add(parent)\n      pending.push(parent)\n    }\n  }\n  return [...new Set(answered)].filter((id) => !exempt.has(id))\n}\n\n/** `answerEntityIds` order, each id once — the reporting order RFC 0004 fixes. */\nfunction distinctIds(candidates: readonly GoalCandidate[]): string[] {\n  return [...new Set(candidates.map((candidate) => candidate.id))]\n}\n","import type { DetailedGeometryFeedback, GeometryValidationFeedback } from './types'\nimport type { GeometryExerciseWarning } from './getGeometryExerciseWarnings'\nimport { fingerprintGeometryAttempt, fingerprintGeometryExercise } from './gradingFingerprints'\nimport { loadExerciseDocument } from './exerciseLoad'\nimport type { GeometryExerciseValidationIssue } from './validateGeometryExercise'\nimport { evaluateGeometryState, evaluateGeometryStateDetailed } from './validateGeometryState'\nimport { validateGeometryStateInput } from './validateGeometryStateInput'\n\nexport interface CheckGeometryAnswerIssue extends GeometryExerciseValidationIssue {\n  source: 'exercise' | 'geometry'\n}\n\n/**\n * Which grading inputs a successful check described (RFC 0005 § Decision 2).\n * Both are opaque and engine-produced: equal for equal normalized content,\n * whatever the object identity or key order, and the exercise member ignores\n * the authored solution. A host passes the whole result on and never computes\n * or compares these itself.\n */\nexport interface CheckGeometryAnswerFingerprints {\n  exercise: string\n  attempt: string\n}\n\nexport type CheckGeometryAnswerResult =\n  | {\n      success: true\n      data: GeometryValidationFeedback\n      fingerprints: CheckGeometryAnswerFingerprints\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: CheckGeometryAnswerIssue[]\n      warnings: []\n    }\n\n/**\n * Safe public Check entry point for untrusted application data. Structure is\n * validated first; valid geometry is then evaluated by the JSXGraph-backed\n * goal handlers used by validateGeometryState().\n */\nexport function checkGeometryAnswer(\n  exerciseInput: unknown,\n  geometryInput: unknown,\n): CheckGeometryAnswerResult {\n  // The solution-free load: grading ignores the authored solution, so a\n  // malformed one cannot fail a check (ADR 0015).\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return {\n      success: false,\n      data: null,\n      errors: exercise.errors.map((issue) => ({ ...issue, source: 'exercise' })),\n      warnings: [],\n    }\n  }\n\n  const geometry = validateGeometryStateInput(geometryInput, exercise.data)\n  if (!geometry.success) {\n    return {\n      success: false,\n      data: null,\n      errors: geometry.errors.map((issue) => ({ ...issue, source: 'geometry' })),\n      warnings: [],\n    }\n  }\n\n  return {\n    success: true,\n    data: evaluateGeometryState(exercise.data, geometry.data),\n    fingerprints: {\n      exercise: fingerprintGeometryExercise(exercise.data),\n      attempt: fingerprintGeometryAttempt(geometry.data),\n    },\n    errors: [],\n    warnings: exercise.warnings,\n  }\n}\n\n/**\n * Which document was rejected, as a code rather than a sentence. `message`\n * stays the schema's human-readable detail and is never a reason code: a\n * malformed document is not a student's wrong answer, and nothing here reaches\n * geometry evaluation (RFC 0004 § Decision 5).\n */\nexport type CheckGeometryAnswerErrorCode = 'invalid-exercise' | 'invalid-attempt'\n\nexport interface DetailedCheckGeometryAnswerIssue extends CheckGeometryAnswerIssue {\n  code: CheckGeometryAnswerErrorCode\n}\n\nexport type DetailedCheckGeometryAnswerResult =\n  | {\n      success: true\n      data: DetailedGeometryFeedback\n      fingerprints: CheckGeometryAnswerFingerprints\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: DetailedCheckGeometryAnswerIssue[]\n      warnings: []\n    }\n\n/**\n * `checkGeometryAnswer()` with the structured report: same untrusted inputs,\n * same success discriminant, fingerprints and warnings, detailed data on\n * success.\n */\nexport function checkGeometryAnswerDetailed(\n  exerciseInput: unknown,\n  geometryInput: unknown,\n): DetailedCheckGeometryAnswerResult {\n  // The solution-free load: grading ignores the authored solution, so a\n  // malformed one cannot fail a check (ADR 0015).\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return {\n      success: false,\n      data: null,\n      errors: exercise.errors.map((issue) => ({\n        ...issue,\n        source: 'exercise',\n        code: 'invalid-exercise',\n      })),\n      warnings: [],\n    }\n  }\n\n  const geometry = validateGeometryStateInput(geometryInput, exercise.data)\n  if (!geometry.success) {\n    return {\n      success: false,\n      data: null,\n      errors: geometry.errors.map((issue) => ({\n        ...issue,\n        source: 'geometry',\n        code: 'invalid-attempt',\n      })),\n      warnings: [],\n    }\n  }\n\n  return {\n    success: true,\n    data: evaluateGeometryStateDetailed(exercise.data, geometry.data),\n    fingerprints: {\n      exercise: fingerprintGeometryExercise(exercise.data),\n      attempt: fingerprintGeometryAttempt(geometry.data),\n    },\n    errors: [],\n    warnings: exercise.warnings,\n  }\n}\n","import type { GeometryExercise } from '../schemas/exercise.schema'\nimport { resolveExercisePoints } from '../state/resolvePoints'\nimport { revealedAnswerFor } from './goals'\nimport type { RevealedAnswer } from './types'\n\nexport function revealGeometryAnswers(exercise: GeometryExercise): RevealedAnswer[] {\n  // The exercise's own points, resolved: a canonical answer is measured\n  // against the givens and nothing else, so there is no attempt to index here.\n  const points = resolveExercisePoints(exercise)\n\n  return exercise.goals.map((goal) => ({\n    id: goal.id,\n    shape: revealedAnswerFor(goal, { exercise, points }),\n  }))\n}\n","import type { GeometryState } from '../schemas/geometryState.schema'\nimport { loadExerciseDocument, validateEmbeddedSolution } from './exerciseLoad'\nimport { validateGeometryState } from './validateGeometryState'\n\n/**\n * Why no canonical attempt came back, as a code rather than a sentence (RFC\n * 0005 § Decision 4). The three are kept apart because a host acts on them\n * differently: a broken exercise is the whole widget's problem, a missing or\n * malformed solution is an authoring gap, and an incorrect one means the\n * authored answer and the goals disagree.\n */\nexport type RevealGeometryAttemptErrorCode =\n  'invalid-exercise' | 'invalid-canonical-attempt' | 'canonical-attempt-incorrect'\n\nexport interface RevealGeometryAttemptIssue {\n  code: RevealGeometryAttemptErrorCode\n  path: Array<string | number>\n  message: string\n}\n\nexport type RevealGeometryAttemptResult =\n  | { success: true; data: GeometryState; errors: [] }\n  | { success: false; data: null; errors: RevealGeometryAttemptIssue[] }\n\nfunction refused(errors: RevealGeometryAttemptIssue[]): RevealGeometryAttemptResult {\n  return { success: false, data: null, errors }\n}\n\n/**\n * The authored canonical attempt an exercise embeds, for a host's Reveal\n * (ADR 0015). Synchronous and DOM-free, and safe on untrusted input: the\n * exercise is migrated and parsed, then its `solution` is migrated, parsed and\n * normalized as an attempt against that exercise, then graded under the\n * exercise's own policy. Only a solution that grades correct is returned.\n *\n * Nothing is synthesized from goals and nothing is merged with student work:\n * the host replaces its attempt value with `data`. Paths of a malformed\n * solution are rooted at `solution`, so they point into the exercise document\n * the host holds.\n */\nexport function revealGeometryAttempt(exerciseInput: unknown): RevealGeometryAttemptResult {\n  // The same two stages `validateGeometryExercise()` runs, kept apart here only\n  // so each failure gets its own code.\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return refused(exercise.errors.map((issue) => ({ code: 'invalid-exercise', ...issue })))\n  }\n\n  if (exercise.solution === undefined) {\n    return refused([\n      {\n        code: 'invalid-canonical-attempt',\n        path: ['solution'],\n        message: 'this exercise has no canonical solution',\n      },\n    ])\n  }\n\n  const attempt = validateEmbeddedSolution(exercise.solution, exercise.data)\n  if (!attempt.success) {\n    return refused(attempt.errors.map((issue) => ({ code: 'invalid-canonical-attempt', ...issue })))\n  }\n\n  if (validateGeometryState(exercise.data, attempt.data).status !== 'correct') {\n    return refused([\n      {\n        code: 'canonical-attempt-incorrect',\n        path: ['solution'],\n        message: 'the canonical solution does not satisfy this exercise',\n      },\n    ])\n  }\n\n  return { success: true, data: attempt.data, errors: [] }\n}\n","import type { GeometryExercise } from '../schemas/exercise.schema'\nimport { loadExerciseDocument, validateEmbeddedSolution } from './exerciseLoad'\nimport type { GeometryExerciseWarning } from './getGeometryExerciseWarnings'\n\nexport interface GeometryExerciseValidationIssue {\n  path: Array<string | number>\n  message: string\n}\n\nexport type GeometryExerciseValidationResult =\n  | {\n      success: true\n      data: GeometryExercise\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: GeometryExerciseValidationIssue[]\n      warnings: []\n    }\n\n/**\n * The whole stored exercise, authored solution included. Stored exercises are\n * brought up to the current version before their structure is checked, exactly\n * as attempts are (M2.6.b), and an embedded `solution` is then migrated and\n * checked against the exercise as an attempt (ADR 0015), with its issues rooted\n * at `solution`. On success `data.solution` is that normalized attempt.\n *\n * Grading does not go through here: Check and the student component load the\n * solution-free projection, so a broken solution never disables them. An\n * authoring tool does, and learns about it at save time.\n */\nexport function validateGeometryExercise(input: unknown): GeometryExerciseValidationResult {\n  const loaded = loadExerciseDocument(input)\n  if (!loaded.success) {\n    return { success: false, data: null, errors: loaded.errors, warnings: [] }\n  }\n  if (loaded.solution === undefined) {\n    return { success: true, data: loaded.data, errors: [], warnings: loaded.warnings }\n  }\n\n  const solution = validateEmbeddedSolution(loaded.solution, loaded.data)\n  if (!solution.success) {\n    return { success: false, data: null, errors: solution.errors, warnings: [] }\n  }\n  return {\n    success: true,\n    data: { ...loaded.data, solution: solution.data },\n    errors: [],\n    warnings: loaded.warnings,\n  }\n}\n\nexport function validateGeometryExerciseJson(json: string): GeometryExerciseValidationResult {\n  try {\n    return validateGeometryExercise(JSON.parse(json))\n  } catch (error) {\n    return {\n      success: false,\n      data: null,\n      errors: [\n        {\n          path: [],\n          message: error instanceof Error ? error.message : 'Invalid JSON syntax',\n        },\n      ],\n      warnings: [],\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/validation.mjs

@@ -0,0 +1,269 @@
+import { O as e, V as t } from "./geometryState.schema-D0ixyGYE.js";
+import { d as n, f as r, i, l as a, n as o, o as s, r as c, t as l } from "./goals-C3ZwbEh_.js";
+import { a as u, c as d, d as f, i as p, l as m, n as h, o as g, r as _, s as v, t as y, u as b } from "./geometryAttemptStatus-5L_q6-9l.js";
+//#region src/validation/validateGeometryState.ts
+function x(e, t) {
+	return S(e, t).result;
+}
+function S(e, t) {
+	return w(e, t, !1).feedback;
+}
+function C(e, t) {
+	return w(e, t, !0);
+}
+function w(t, a, s) {
+	let l = t.goals.length === 0, u = t.grading?.extraObjects === "reject", d = s || u;
+	if (l && !s) return {
+		feedback: {
+			result: {
+				status: "incorrect",
+				goals: []
+			},
+			goals: []
+		},
+		goals: [],
+		diagnostics: [],
+		extraEntityIds: []
+	};
+	let f = n(t, a), p = {
+		exercise: t,
+		points: f.points
+	}, m = [], h = [], g = [];
+	for (let n of a.answerEntityIds) {
+		if (e(t.entities, n)) continue;
+		let r = f.definitionOf(n);
+		if (r) {
+			if (d && g.push(n), f.resolvedOf(n) === void 0) {
+				d && h.push({
+					id: n,
+					definition: r
+				});
+				continue;
+			}
+			m.push({
+				id: n,
+				definition: r
+			});
+		}
+	}
+	let _ = [], v = [], y = /* @__PURE__ */ new Set();
+	for (let e of t.goals) {
+		let t = m.filter((t) => c(t, e, p));
+		if (d) for (let e of t) y.add(e.id);
+		let n = t.length > 0, a = n && !s ? [] : m.filter((t) => i(t, e, p)), l = n ? t : a;
+		if (_.push({
+			id: e.id,
+			status: n ? "correct" : "incorrect",
+			constructionIds: l.filter((e) => !r(e)).map((e) => e.id),
+			pointIds: l.filter(r).map((e) => e.id)
+		}), !s) continue;
+		let u = h.filter((t) => o(t, e));
+		v.push({
+			id: e.id,
+			status: n ? "correct" : "incorrect",
+			code: n ? "goal-satisfied" : m.some((t) => o(t, e)) ? "goal-not-satisfied" : u.length > 0 ? "unresolved-candidate" : "no-candidate",
+			matchedEntityIds: E(t),
+			relevantEntityIds: E(a),
+			unresolvedEntityIds: E(u)
+		});
+	}
+	let b = d ? T(g, y, f) : [], x = {
+		status: !l && _.every((e) => e.status === "correct") && !(u && b.length > 0) ? "correct" : "incorrect",
+		goals: _.map(({ id: e, status: t }) => ({
+			id: e,
+			status: t
+		}))
+	}, S = [];
+	return l && S.push({
+		code: "no-goals",
+		entityIds: []
+	}), h.length > 0 && S.push({
+		code: "unresolved-entity",
+		entityIds: E(h)
+	}), u && b.length > 0 && S.push({
+		code: "extra-objects",
+		entityIds: b
+	}), {
+		feedback: {
+			result: x,
+			goals: _
+		},
+		goals: v,
+		diagnostics: S,
+		extraEntityIds: b
+	};
+}
+function T(e, t, n) {
+	let r = new Set(t), i = [...t];
+	for (; i.length > 0;) {
+		let e = i.pop();
+		if (e !== void 0) for (let t of n.parentsOf(e)) r.has(t) || (r.add(t), i.push(t));
+	}
+	return [...new Set(e)].filter((e) => !r.has(e));
+}
+function E(e) {
+	return [...new Set(e.map((e) => e.id))];
+}
+//#endregion
+//#region src/validation/checkGeometryAnswer.ts
+function D(e, t) {
+	let n = _(e);
+	if (!n.success) return {
+		success: !1,
+		data: null,
+		errors: n.errors.map((e) => ({
+			...e,
+			source: "exercise"
+		})),
+		warnings: []
+	};
+	let r = b(t, n.data);
+	return r.success ? {
+		success: !0,
+		data: S(n.data, r.data),
+		fingerprints: {
+			exercise: v(n.data),
+			attempt: g(r.data)
+		},
+		errors: [],
+		warnings: n.warnings
+	} : {
+		success: !1,
+		data: null,
+		errors: r.errors.map((e) => ({
+			...e,
+			source: "geometry"
+		})),
+		warnings: []
+	};
+}
+function O(e, t) {
+	let n = _(e);
+	if (!n.success) return {
+		success: !1,
+		data: null,
+		errors: n.errors.map((e) => ({
+			...e,
+			source: "exercise",
+			code: "invalid-exercise"
+		})),
+		warnings: []
+	};
+	let r = b(t, n.data);
+	return r.success ? {
+		success: !0,
+		data: C(n.data, r.data),
+		fingerprints: {
+			exercise: v(n.data),
+			attempt: g(r.data)
+		},
+		errors: [],
+		warnings: n.warnings
+	} : {
+		success: !1,
+		data: null,
+		errors: r.errors.map((e) => ({
+			...e,
+			source: "geometry",
+			code: "invalid-attempt"
+		})),
+		warnings: []
+	};
+}
+//#endregion
+//#region src/validation/revealGeometryAnswers.ts
+function k(e) {
+	let t = a(e);
+	return e.goals.map((n) => ({
+		id: n.id,
+		shape: s(n, {
+			exercise: e,
+			points: t
+		})
+	}));
+}
+//#endregion
+//#region src/validation/revealGeometryAttempt.ts
+function A(e) {
+	return {
+		success: !1,
+		data: null,
+		errors: e
+	};
+}
+function j(e) {
+	let t = _(e);
+	if (!t.success) return A(t.errors.map((e) => ({
+		code: "invalid-exercise",
+		...e
+	})));
+	if (t.solution === void 0) return A([{
+		code: "invalid-canonical-attempt",
+		path: ["solution"],
+		message: "this exercise has no canonical solution"
+	}]);
+	let n = p(t.solution, t.data);
+	return n.success ? x(t.data, n.data).status === "correct" ? {
+		success: !0,
+		data: n.data,
+		errors: []
+	} : A([{
+		code: "canonical-attempt-incorrect",
+		path: ["solution"],
+		message: "the canonical solution does not satisfy this exercise"
+	}]) : A(n.errors.map((e) => ({
+		code: "invalid-canonical-attempt",
+		...e
+	})));
+}
+//#endregion
+//#region src/validation/validateGeometryExercise.ts
+function M(e) {
+	let t = _(e);
+	if (!t.success) return {
+		success: !1,
+		data: null,
+		errors: t.errors,
+		warnings: []
+	};
+	if (t.solution === void 0) return {
+		success: !0,
+		data: t.data,
+		errors: [],
+		warnings: t.warnings
+	};
+	let n = p(t.solution, t.data);
+	return n.success ? {
+		success: !0,
+		data: {
+			...t.data,
+			solution: n.data
+		},
+		errors: [],
+		warnings: t.warnings
+	} : {
+		success: !1,
+		data: null,
+		errors: n.errors,
+		warnings: []
+	};
+}
+function N(e) {
+	try {
+		return M(JSON.parse(e));
+	} catch (e) {
+		return {
+			success: !1,
+			data: null,
+			errors: [{
+				path: [],
+				message: e instanceof Error ? e.message : "Invalid JSON syntax"
+			}],
+			warnings: []
+		};
+	}
+}
+//#endregion
+export { D as checkGeometryAnswer, O as checkGeometryAnswerDetailed, y as createEmptyGeometryAttempt, d as deriveGeometryCanvasFeedback, S as evaluateGeometryState, C as evaluateGeometryStateDetailed, u as getGeometryExerciseWarnings, l as getGoalKindHandler, h as hasGeometryWork, t as intersectionsOf, k as revealGeometryAnswers, j as revealGeometryAttempt, m as serializeGeometryState, M as validateGeometryExercise, N as validateGeometryExerciseJson, x as validateGeometryState, b as validateGeometryStateInput, f as validateGeometryStateJson };
+
+//# sourceMappingURL=validation.mjs.map

package/dist/validation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.mjs","names":[],"sources":["../src/validation/validateGeometryState.ts","../src/validation/checkGeometryAnswer.ts","../src/validation/revealGeometryAnswers.ts","../src/validation/revealGeometryAttempt.ts","../src/validation/validateGeometryExercise.ts"],"sourcesContent":["import { entryOf } from '../geometry/entityRecord'\nimport type { EntityId } from '../geometry/entityModel'\nimport type { GeometryExercise } from '../schemas/exercise.schema'\nimport type { GeometryState } from '../schemas/geometryState.schema'\nimport { isCandidatePoint, type GoalCandidate } from '../geometry/goalCandidate'\nimport { buildGeometryContext } from '../state/geometryContext'\nimport type {\n  DetailedGeometryFeedback,\n  DetailedGoalResult,\n  GeometryDiagnostic,\n  GeometryValidationFeedback,\n  GoalGeometryFeedback,\n  ValidationContext,\n  ValidationResult,\n} from './types'\nimport { goalAcceptsCandidate, goalSatisfiedBy, isRelevantGoalAttempt } from './goals'\n\nexport function validateGeometryState(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): ValidationResult {\n  return evaluateGeometryState(exercise, geometry).result\n}\n\nexport function evaluateGeometryState(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): GeometryValidationFeedback {\n  return evaluate(exercise, geometry, false).feedback\n}\n\n/**\n * The same grading, reported rather than summarized: why each goal landed where\n * it did, as stable codes and entity ids (RFC 0004 § Decision 5). It measures\n * nothing the plain evaluation does not — the codes are read off the existing\n * goal handlers' own predicates — so the two can never disagree.\n *\n * `feedback` is exactly what `evaluateGeometryState()` returns for the same\n * inputs. The extra work is one relevance pass per satisfied goal and the\n * unresolved bookkeeping, which the plain path still skips.\n */\nexport function evaluateGeometryStateDetailed(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n): DetailedGeometryFeedback {\n  return evaluate(exercise, geometry, true)\n}\n\nfunction evaluate(\n  exercise: GeometryExercise,\n  geometry: GeometryState,\n  detailed: boolean,\n): DetailedGeometryFeedback {\n  // An exercise nobody can answer is incorrect, and the report now says so in\n  // one word rather than leaving a host to infer it from an empty goal list.\n  // The plain path stops here, as it always has; the report does not, because\n  // an unresolved answer entity is reported whatever the goals say — there is\n  // simply no goal loop to run below.\n  const noGoals = exercise.goals.length === 0\n  // Absence means `allow` (ADR 0013), so an exercise authored before v3 keeps\n  // exactly the verdict it had. The extra-object sets cost a closure walk, so\n  // the plain path computes them only when the policy actually reads them:\n  // under `allow` they are reported and never graded on.\n  const strict = exercise.grading?.extraObjects === 'reject'\n  const needsExtras = detailed || strict\n  if (noGoals && !detailed) {\n    return {\n      feedback: { result: { status: 'incorrect', goals: [] }, goals: [] },\n      goals: [],\n      diagnostics: [],\n      extraEntityIds: [],\n    }\n  }\n\n  // Coordinates come from the dependency graph, not from storage: a derived\n  // point is wherever its parents currently put it. A point that cannot be\n  // resolved (its object was deleted, its intersection vanished) is absent\n  // here and therefore cannot satisfy anything.\n  const scene = buildGeometryContext(exercise, geometry)\n  // The scene's own index, not a copy: `ValidationContext.points` is read-only\n  // by contract (M2.3.c), so there is nothing to defend it against. The copy\n  // this replaced was one `Map` allocation and one full rehash per validation.\n  const context: ValidationContext = { exercise, points: scene.points }\n  // One list for every kind, which is what `answerEntityIds` is: v1 kept a\n  // candidacy list for points only and treated every construction as a\n  // candidate, and the migration reproduces that by naming both. A goal kind\n  // decides for itself which candidates it can be satisfied by (a midpoint goal\n  // wants a point, a perpendicular goal wants a segment or line); points the\n  // student only used as scaffolding are not named here and are never\n  // candidates.\n  //\n  // An entity that no longer resolves has no coordinates to measure, so it is\n  // dropped here rather than left for a handler to trip over: handlers may\n  // assume every candidate they are handed can be looked up in `points`. An\n  // entity resolves exactly when everything it is built on does, which is the\n  // index's answer rather than a second scan.\n  const candidates: GoalCandidate[] = []\n  // Answer entities that exist but have no coordinates this evaluation. The\n  // plain path drops them silently; the report names them, because \"you built\n  // it and then deleted what it stood on\" is not the same as \"you built\n  // nothing\".\n  const unresolved: GoalCandidate[] = []\n  // Set `A` of RFC 0004 § Decision 6, in answer order: every id the attempt\n  // owns and names as an answer, resolved or not. The extra-object policy\n  // subtracts from this list and nothing else, so scaffolding the student never\n  // offered as an answer cannot be an extra.\n  const answered: EntityId[] = []\n  for (const id of geometry.answerEntityIds) {\n    // A given is not an answer to anything (ADR 0008 § Amendment), whatever\n    // the list says. `validateGeometryStateInput()` already strips these on\n    // load, but grading takes both documents directly — a host holding a\n    // migrated v1 attempt it never loaded through the engine, or a store still\n    // in memory, would otherwise have the exercise's own given graded as the\n    // student's construction (M2.G.2).\n    if (entryOf(exercise.entities, id)) continue\n    const definition = scene.definitionOf(id)\n    if (!definition) continue\n    if (needsExtras) answered.push(id)\n    if (scene.resolvedOf(id) === undefined) {\n      if (needsExtras) unresolved.push({ id, definition })\n      continue\n    }\n    candidates.push({ id, definition })\n  }\n  const goals: GoalGeometryFeedback[] = []\n  const detailedGoals: DetailedGoalResult[] = []\n  // Set `M`: every candidate that satisfies *some* goal. A union, not an\n  // assignment — one entity may answer two goals and two entities may answer\n  // one, and this policy deliberately does not count solutions.\n  const matched = new Set<EntityId>()\n  for (const goal of exercise.goals) {\n    const matching = candidates.filter((candidate) => goalSatisfiedBy(candidate, goal, context))\n    if (needsExtras) for (const candidate of matching) matched.add(candidate.id)\n    const correct = matching.length > 0\n    // Highlighting wants relevance only when the goal is unsatisfied; the\n    // report wants it either way, so a correct goal still says which other\n    // attempts were aimed at it.\n    const relevant =\n      correct && !detailed\n        ? []\n        : candidates.filter((candidate) => isRelevantGoalAttempt(candidate, goal, context))\n    const shown = correct ? matching : relevant\n    goals.push({\n      id: goal.id,\n      status: correct ? 'correct' : 'incorrect',\n      constructionIds: shown.filter((candidate) => !isCandidatePoint(candidate)).map((c) => c.id),\n      pointIds: shown.filter(isCandidatePoint).map((candidate) => candidate.id),\n    })\n    if (!detailed) continue\n    const unresolvedForGoal = unresolved.filter((candidate) =>\n      goalAcceptsCandidate(candidate, goal),\n    )\n    detailedGoals.push({\n      id: goal.id,\n      status: correct ? 'correct' : 'incorrect',\n      code: correct\n        ? 'goal-satisfied'\n        : candidates.some((candidate) => goalAcceptsCandidate(candidate, goal))\n          ? 'goal-not-satisfied'\n          : unresolvedForGoal.length > 0\n            ? 'unresolved-candidate'\n            : 'no-candidate',\n      matchedEntityIds: distinctIds(matching),\n      relevantEntityIds: distinctIds(relevant),\n      unresolvedEntityIds: distinctIds(unresolvedForGoal),\n    })\n  }\n  // `A − (M ∪ S)`: answer entities no goal needed, and that nothing a goal\n  // needed was built on. Empty unless the policy or the report asked for it.\n  const extraEntityIds = needsExtras ? withoutSupport(answered, matched, scene) : []\n  const goalsMet = !noGoals && goals.every((goal) => goal.status === 'correct')\n  const result: ValidationResult = {\n    // `every` on an empty list is vacuously true, and a goalless exercise is\n    // incorrect — the one place the two disagree.\n    //\n    // Under `reject`, an extra answer entity makes the attempt incorrect while\n    // every goal stays as its own predicate found it: \"the goals are met and\n    // something unused is still on the canvas\" is a different thing from a\n    // failed goal, and the diagnostic below is where it is said.\n    status: goalsMet && !(strict && extraEntityIds.length > 0) ? 'correct' : 'incorrect',\n    goals: goals.map(({ id, status }) => ({ id, status })),\n  }\n  const diagnostics: GeometryDiagnostic[] = []\n  if (noGoals) diagnostics.push({ code: 'no-goals', entityIds: [] })\n  // Informational: an unresolved entity does not make a satisfied exercise\n  // incorrect. Reporting it regardless is what lets a host say \"this one is\n  // no longer on the canvas\" instead of leaving it unexplained.\n  if (unresolved.length > 0) {\n    diagnostics.push({ code: 'unresolved-entity', entityIds: distinctIds(unresolved) })\n  }\n  // Only under `reject`: the list is reported either way, but it is a finding\n  // about the attempt only where the author asked for strictness. Last, because\n  // an unresolved extra is explained by the diagnostic above it.\n  if (strict && extraEntityIds.length > 0) {\n    diagnostics.push({ code: 'extra-objects', entityIds: extraEntityIds })\n  }\n  return { feedback: { result, goals }, goals: detailedGoals, diagnostics, extraEntityIds }\n}\n\n/**\n * `answered` minus the matched entities and minus set `S`, their transitive\n * parents — the support closure.\n *\n * Support is exempt because it is not an alternative answer: the two points a\n * correct segment is drawn between, and the helper objects a correct derived\n * point stands on, are the construction, however the student named them. That\n * is why the walk goes *up* the graph from what satisfied a goal rather than\n * down from every answer entity.\n *\n * An unresolved answer entity cannot be in `matched` — nothing measured it —\n * and it can only be support if something that did resolve was built on it,\n * which is impossible. So it stays, which is the reported outcome RFC 0004 §\n * Decision 6 names.\n */\nfunction withoutSupport(\n  answered: readonly EntityId[],\n  matched: ReadonlySet<EntityId>,\n  scene: { parentsOf(id: EntityId): readonly EntityId[] },\n): EntityId[] {\n  const exempt = new Set<EntityId>(matched)\n  const pending = [...matched]\n  // Visited-bounded, because the graph is walked by id: a cycle is\n  // unrepresentable in a stored document, but this must not depend on that.\n  while (pending.length > 0) {\n    const id = pending.pop()\n    if (id === undefined) continue\n    for (const parent of scene.parentsOf(id)) {\n      if (exempt.has(parent)) continue\n      exempt.add(parent)\n      pending.push(parent)\n    }\n  }\n  return [...new Set(answered)].filter((id) => !exempt.has(id))\n}\n\n/** `answerEntityIds` order, each id once — the reporting order RFC 0004 fixes. */\nfunction distinctIds(candidates: readonly GoalCandidate[]): string[] {\n  return [...new Set(candidates.map((candidate) => candidate.id))]\n}\n","import type { DetailedGeometryFeedback, GeometryValidationFeedback } from './types'\nimport type { GeometryExerciseWarning } from './getGeometryExerciseWarnings'\nimport { fingerprintGeometryAttempt, fingerprintGeometryExercise } from './gradingFingerprints'\nimport { loadExerciseDocument } from './exerciseLoad'\nimport type { GeometryExerciseValidationIssue } from './validateGeometryExercise'\nimport { evaluateGeometryState, evaluateGeometryStateDetailed } from './validateGeometryState'\nimport { validateGeometryStateInput } from './validateGeometryStateInput'\n\nexport interface CheckGeometryAnswerIssue extends GeometryExerciseValidationIssue {\n  source: 'exercise' | 'geometry'\n}\n\n/**\n * Which grading inputs a successful check described (RFC 0005 § Decision 2).\n * Both are opaque and engine-produced: equal for equal normalized content,\n * whatever the object identity or key order, and the exercise member ignores\n * the authored solution. A host passes the whole result on and never computes\n * or compares these itself.\n */\nexport interface CheckGeometryAnswerFingerprints {\n  exercise: string\n  attempt: string\n}\n\nexport type CheckGeometryAnswerResult =\n  | {\n      success: true\n      data: GeometryValidationFeedback\n      fingerprints: CheckGeometryAnswerFingerprints\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: CheckGeometryAnswerIssue[]\n      warnings: []\n    }\n\n/**\n * Safe public Check entry point for untrusted application data. Structure is\n * validated first; valid geometry is then evaluated by the JSXGraph-backed\n * goal handlers used by validateGeometryState().\n */\nexport function checkGeometryAnswer(\n  exerciseInput: unknown,\n  geometryInput: unknown,\n): CheckGeometryAnswerResult {\n  // The solution-free load: grading ignores the authored solution, so a\n  // malformed one cannot fail a check (ADR 0015).\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return {\n      success: false,\n      data: null,\n      errors: exercise.errors.map((issue) => ({ ...issue, source: 'exercise' })),\n      warnings: [],\n    }\n  }\n\n  const geometry = validateGeometryStateInput(geometryInput, exercise.data)\n  if (!geometry.success) {\n    return {\n      success: false,\n      data: null,\n      errors: geometry.errors.map((issue) => ({ ...issue, source: 'geometry' })),\n      warnings: [],\n    }\n  }\n\n  return {\n    success: true,\n    data: evaluateGeometryState(exercise.data, geometry.data),\n    fingerprints: {\n      exercise: fingerprintGeometryExercise(exercise.data),\n      attempt: fingerprintGeometryAttempt(geometry.data),\n    },\n    errors: [],\n    warnings: exercise.warnings,\n  }\n}\n\n/**\n * Which document was rejected, as a code rather than a sentence. `message`\n * stays the schema's human-readable detail and is never a reason code: a\n * malformed document is not a student's wrong answer, and nothing here reaches\n * geometry evaluation (RFC 0004 § Decision 5).\n */\nexport type CheckGeometryAnswerErrorCode = 'invalid-exercise' | 'invalid-attempt'\n\nexport interface DetailedCheckGeometryAnswerIssue extends CheckGeometryAnswerIssue {\n  code: CheckGeometryAnswerErrorCode\n}\n\nexport type DetailedCheckGeometryAnswerResult =\n  | {\n      success: true\n      data: DetailedGeometryFeedback\n      fingerprints: CheckGeometryAnswerFingerprints\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: DetailedCheckGeometryAnswerIssue[]\n      warnings: []\n    }\n\n/**\n * `checkGeometryAnswer()` with the structured report: same untrusted inputs,\n * same success discriminant, fingerprints and warnings, detailed data on\n * success.\n */\nexport function checkGeometryAnswerDetailed(\n  exerciseInput: unknown,\n  geometryInput: unknown,\n): DetailedCheckGeometryAnswerResult {\n  // The solution-free load: grading ignores the authored solution, so a\n  // malformed one cannot fail a check (ADR 0015).\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return {\n      success: false,\n      data: null,\n      errors: exercise.errors.map((issue) => ({\n        ...issue,\n        source: 'exercise',\n        code: 'invalid-exercise',\n      })),\n      warnings: [],\n    }\n  }\n\n  const geometry = validateGeometryStateInput(geometryInput, exercise.data)\n  if (!geometry.success) {\n    return {\n      success: false,\n      data: null,\n      errors: geometry.errors.map((issue) => ({\n        ...issue,\n        source: 'geometry',\n        code: 'invalid-attempt',\n      })),\n      warnings: [],\n    }\n  }\n\n  return {\n    success: true,\n    data: evaluateGeometryStateDetailed(exercise.data, geometry.data),\n    fingerprints: {\n      exercise: fingerprintGeometryExercise(exercise.data),\n      attempt: fingerprintGeometryAttempt(geometry.data),\n    },\n    errors: [],\n    warnings: exercise.warnings,\n  }\n}\n","import type { GeometryExercise } from '../schemas/exercise.schema'\nimport { resolveExercisePoints } from '../state/resolvePoints'\nimport { revealedAnswerFor } from './goals'\nimport type { RevealedAnswer } from './types'\n\nexport function revealGeometryAnswers(exercise: GeometryExercise): RevealedAnswer[] {\n  // The exercise's own points, resolved: a canonical answer is measured\n  // against the givens and nothing else, so there is no attempt to index here.\n  const points = resolveExercisePoints(exercise)\n\n  return exercise.goals.map((goal) => ({\n    id: goal.id,\n    shape: revealedAnswerFor(goal, { exercise, points }),\n  }))\n}\n","import type { GeometryState } from '../schemas/geometryState.schema'\nimport { loadExerciseDocument, validateEmbeddedSolution } from './exerciseLoad'\nimport { validateGeometryState } from './validateGeometryState'\n\n/**\n * Why no canonical attempt came back, as a code rather than a sentence (RFC\n * 0005 § Decision 4). The three are kept apart because a host acts on them\n * differently: a broken exercise is the whole widget's problem, a missing or\n * malformed solution is an authoring gap, and an incorrect one means the\n * authored answer and the goals disagree.\n */\nexport type RevealGeometryAttemptErrorCode =\n  'invalid-exercise' | 'invalid-canonical-attempt' | 'canonical-attempt-incorrect'\n\nexport interface RevealGeometryAttemptIssue {\n  code: RevealGeometryAttemptErrorCode\n  path: Array<string | number>\n  message: string\n}\n\nexport type RevealGeometryAttemptResult =\n  | { success: true; data: GeometryState; errors: [] }\n  | { success: false; data: null; errors: RevealGeometryAttemptIssue[] }\n\nfunction refused(errors: RevealGeometryAttemptIssue[]): RevealGeometryAttemptResult {\n  return { success: false, data: null, errors }\n}\n\n/**\n * The authored canonical attempt an exercise embeds, for a host's Reveal\n * (ADR 0015). Synchronous and DOM-free, and safe on untrusted input: the\n * exercise is migrated and parsed, then its `solution` is migrated, parsed and\n * normalized as an attempt against that exercise, then graded under the\n * exercise's own policy. Only a solution that grades correct is returned.\n *\n * Nothing is synthesized from goals and nothing is merged with student work:\n * the host replaces its attempt value with `data`. Paths of a malformed\n * solution are rooted at `solution`, so they point into the exercise document\n * the host holds.\n */\nexport function revealGeometryAttempt(exerciseInput: unknown): RevealGeometryAttemptResult {\n  // The same two stages `validateGeometryExercise()` runs, kept apart here only\n  // so each failure gets its own code.\n  const exercise = loadExerciseDocument(exerciseInput)\n  if (!exercise.success) {\n    return refused(exercise.errors.map((issue) => ({ code: 'invalid-exercise', ...issue })))\n  }\n\n  if (exercise.solution === undefined) {\n    return refused([\n      {\n        code: 'invalid-canonical-attempt',\n        path: ['solution'],\n        message: 'this exercise has no canonical solution',\n      },\n    ])\n  }\n\n  const attempt = validateEmbeddedSolution(exercise.solution, exercise.data)\n  if (!attempt.success) {\n    return refused(attempt.errors.map((issue) => ({ code: 'invalid-canonical-attempt', ...issue })))\n  }\n\n  if (validateGeometryState(exercise.data, attempt.data).status !== 'correct') {\n    return refused([\n      {\n        code: 'canonical-attempt-incorrect',\n        path: ['solution'],\n        message: 'the canonical solution does not satisfy this exercise',\n      },\n    ])\n  }\n\n  return { success: true, data: attempt.data, errors: [] }\n}\n","import type { GeometryExercise } from '../schemas/exercise.schema'\nimport { loadExerciseDocument, validateEmbeddedSolution } from './exerciseLoad'\nimport type { GeometryExerciseWarning } from './getGeometryExerciseWarnings'\n\nexport interface GeometryExerciseValidationIssue {\n  path: Array<string | number>\n  message: string\n}\n\nexport type GeometryExerciseValidationResult =\n  | {\n      success: true\n      data: GeometryExercise\n      errors: []\n      warnings: GeometryExerciseWarning[]\n    }\n  | {\n      success: false\n      data: null\n      errors: GeometryExerciseValidationIssue[]\n      warnings: []\n    }\n\n/**\n * The whole stored exercise, authored solution included. Stored exercises are\n * brought up to the current version before their structure is checked, exactly\n * as attempts are (M2.6.b), and an embedded `solution` is then migrated and\n * checked against the exercise as an attempt (ADR 0015), with its issues rooted\n * at `solution`. On success `data.solution` is that normalized attempt.\n *\n * Grading does not go through here: Check and the student component load the\n * solution-free projection, so a broken solution never disables them. An\n * authoring tool does, and learns about it at save time.\n */\nexport function validateGeometryExercise(input: unknown): GeometryExerciseValidationResult {\n  const loaded = loadExerciseDocument(input)\n  if (!loaded.success) {\n    return { success: false, data: null, errors: loaded.errors, warnings: [] }\n  }\n  if (loaded.solution === undefined) {\n    return { success: true, data: loaded.data, errors: [], warnings: loaded.warnings }\n  }\n\n  const solution = validateEmbeddedSolution(loaded.solution, loaded.data)\n  if (!solution.success) {\n    return { success: false, data: null, errors: solution.errors, warnings: [] }\n  }\n  return {\n    success: true,\n    data: { ...loaded.data, solution: solution.data },\n    errors: [],\n    warnings: loaded.warnings,\n  }\n}\n\nexport function validateGeometryExerciseJson(json: string): GeometryExerciseValidationResult {\n  try {\n    return validateGeometryExercise(JSON.parse(json))\n  } catch (error) {\n    return {\n      success: false,\n      data: null,\n      errors: [\n        {\n          path: [],\n          message: error instanceof Error ? error.message : 'Invalid JSON syntax',\n        },\n      ],\n      warnings: [],\n    }\n  }\n}\n"],"mappings":"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"}