@longsightgroup/qti3-core 0.9.2 → 0.9.4

package/src/trusted-item-session.ts

@@ -1,7 +1,8 @@
 import { parseQtiXml } from "./parser.js";
+import { itemExpectsAutomatedScore } from "./item-scoring-expectation.js";
+import { validateQtiResponseVariables } from "./response-validation.js";
 import { createItemSession, isQtiAttemptStateV1, type QtiItemSession } from "./session.js";
 import type {
-  QtiAssessmentItem,
   QtiAttemptStateV1,
   QtiAttemptStatus,
   QtiDiagnostic,
@@ -10,20 +11,20 @@ import type {
   QtiValue,
 } from "./types.js";
 import { isQtiPortableCustomStateValue, readQtiJsonValue } from "./value-format.js";
+import {
+  listNamedResponseInputs,
+  type QtiNamedResponseInput,
+  type QtiNamedResponsesInput,
+} from "./response-input.js";
 
-export type QtiTrustedInputDiagnosticPrefix = "serverScoring" | "adaptiveTurn";
+export type QtiTrustedResponseInput = QtiNamedResponseInput;
 
-export interface QtiTrustedResponseInput {
-  identifier: string;
-  value: unknown;
-}
+export type QtiTrustedResponsesInput = QtiNamedResponsesInput;
+
+export type QtiTrustedInputDiagnosticPrefix = "serverScoring" | "adaptiveTurn" | "itemSubmission";
 
-export type QtiTrustedResponsesInput =
-  | Record<string, unknown>
-  | readonly QtiTrustedResponseInput[]
-  | undefined;
+export type QtiTrustedSubmissionValidation = "trusted" | "strict";
 
-/** Trusted candidate responses and portable custom interaction state for one application. */
 export interface QtiTrustedResponseApplication {
   trustedResponses?: QtiTrustedResponsesInput;
   trustedInteractionStates?: Record<string, QtiPortableCustomStateValue> | undefined;
@@ -33,7 +34,7 @@ export interface QtiTrustedItemParseOptions {
   allowedUndeclaredResponseIdentifiers?: readonly string[] | undefined;
 }
 
-interface QtiParsedTrustedItem {
+export interface QtiTrustedItemDocument {
   document: QtiDocument;
   diagnostics: QtiDiagnostic[];
   responseIdentifiers: Set<string>;
@@ -43,6 +44,7 @@ export type QtiTrustedItemScoringPolicy = "always" | "onSubmission";
 
 export interface RunTrustedItemSessionInput extends QtiTrustedItemParseOptions {
   itemXml: string;
+  parsedItem?: QtiTrustedItemDocument | undefined;
   diagnosticPrefix: QtiTrustedInputDiagnosticPrefix;
   submission: QtiTrustedResponseApplication;
   priorState?: QtiAttemptStateV1 | null | undefined;
@@ -50,6 +52,12 @@ export interface RunTrustedItemSessionInput extends QtiTrustedItemParseOptions {
   attemptStatus?: QtiAttemptStatus | undefined;
   scoring: QtiTrustedItemScoringPolicy;
   requireNumericScore: boolean;
+  /**
+   * `strict` rejects undeclared and malformed responses before trusted application.
+   * `trusted` keeps the legacy warning path for undeclared identifiers.
+   */
+  submissionValidation?: QtiTrustedSubmissionValidation | undefined;
+  allowIncompleteResponses?: boolean | undefined;
 }
 
 export interface RunTrustedItemSessionSuccess {
@@ -86,19 +94,58 @@ export function readPriorAttemptState(
       {
         code: `${diagnosticPrefix}.state.value`,
         severity: "error",
-        message: "Prior adaptive turn state is not a valid qti3.attempt-state.v1 value.",
+        message: "Prior attempt state is not a valid qti3.attempt-state.v1 value.",
       },
     ],
   };
 }
 
+export function parseTrustedItemDocument(
+  itemXml: string,
+  allowedUndeclaredResponseIdentifiers: readonly string[] = [],
+): { ok: true; parsed: QtiTrustedItemDocument } | { ok: false; diagnostics: QtiDiagnostic[] } {
+  let parsed: ReturnType<typeof parseQtiXml>;
+  try {
+    parsed = parseQtiXml(itemXml);
+  } catch (error) {
+    return {
+      ok: false,
+      diagnostics: [
+        {
+          code: "xml.parse",
+          severity: "error",
+          message: error instanceof Error ? error.message : String(error),
+        },
+      ],
+    };
+  }
+
+  const allowedUndeclared = new Set(allowedUndeclaredResponseIdentifiers);
+  const diagnostics = parsed.diagnostics.filter(
+    (diagnostic) => !isAllowedUndeclaredVariableReference(diagnostic, allowedUndeclared),
+  );
+  if (!parsed.document || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return { ok: false, diagnostics };
+  }
+
+  return {
+    ok: true,
+    parsed: {
+      document: parsed.document,
+      diagnostics,
+      responseIdentifiers: new Set(
+        parsed.document.item.responseDeclarations.map((declaration) => declaration.identifier),
+      ),
+    },
+  };
+}
+
 export function runTrustedItemSession(
   input: RunTrustedItemSessionInput,
 ): RunTrustedItemSessionResult {
-  const parsedResult = parseTrustedItemXml(
-    input.itemXml,
-    input.allowedUndeclaredResponseIdentifiers,
-  );
+  const parsedResult = input.parsedItem
+    ? { ok: true as const, parsed: input.parsedItem }
+    : parseTrustedItemDocument(input.itemXml, input.allowedUndeclaredResponseIdentifiers);
   if (!parsedResult.ok) {
     return emptyTrustedItemSessionFailure(parsedResult.diagnostics);
   }
@@ -107,6 +154,7 @@ export function runTrustedItemSession(
     parsedResult.parsed,
     input.priorState,
     input.diagnosticPrefix,
+    input.allowedUndeclaredResponseIdentifiers,
     parsedResult.parsed.diagnostics,
   );
   if (!sessionResult.ok) {
@@ -115,6 +163,18 @@ export function runTrustedItemSession(
 
   if (input.attemptStatus) sessionResult.session.setStatus(input.attemptStatus);
 
+  if (input.submissionValidation === "strict") {
+    const validation = validateQtiResponseVariables({
+      item: parsedResult.parsed.document.item,
+      responses: input.submission.trustedResponses ?? {},
+      allowIncompleteResponses: input.allowIncompleteResponses,
+      allowedUndeclaredResponseIdentifiers: input.allowedUndeclaredResponseIdentifiers,
+    });
+    if (!validation.ok) {
+      return emptyTrustedItemSessionFailure(validation.diagnostics);
+    }
+  }
+
   const applicationResult = applyTrustedResponseApplication(
     sessionResult.session,
     parsedResult.parsed,
@@ -127,9 +187,7 @@ export function runTrustedItemSession(
     return emptyTrustedItemSessionFailure(diagnostics);
   }
 
-  const shouldScore =
-    input.scoring === "always" ||
-    (input.scoring === "onSubmission" && applicationResult.appliedSubmission);
+  const shouldScore = input.scoring === "always" || applicationResult.appliedSubmission;
 
   let outcomes = sessionResult.session.serialize().outcomes;
   let state = sessionResult.session.serialize();
@@ -165,7 +223,7 @@ export function runTrustedItemSession(
 
     if (
       input.requireNumericScore &&
-      shouldRequireNumericScore(parsedResult.parsed.document.item) &&
+      itemExpectsAutomatedScore(parsedResult.parsed.document.item) &&
       score === null
     ) {
       return emptyTrustedItemSessionFailure(
@@ -210,56 +268,19 @@ function emptyTrustedItemSessionFailure(
   };
 }
 
-function parseTrustedItemXml(
-  itemXml: string,
-  allowedUndeclaredResponseIdentifiers: readonly string[] = [],
-): { ok: true; parsed: QtiParsedTrustedItem } | { ok: false; diagnostics: QtiDiagnostic[] } {
-  let parsed: ReturnType<typeof parseQtiXml>;
-  try {
-    parsed = parseQtiXml(itemXml);
-  } catch (error) {
-    return {
-      ok: false,
-      diagnostics: [
-        {
-          code: "xml.parse",
-          severity: "error",
-          message: error instanceof Error ? error.message : String(error),
-        },
-      ],
-    };
-  }
-
-  const allowedUndeclared = new Set(allowedUndeclaredResponseIdentifiers);
-  const diagnostics = parsed.diagnostics.filter(
-    (diagnostic) => !isAllowedUndeclaredVariableReference(diagnostic, allowedUndeclared),
-  );
-  if (!parsed.document || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-    return { ok: false, diagnostics };
-  }
-
-  return {
-    ok: true,
-    parsed: {
-      document: parsed.document,
-      diagnostics,
-      responseIdentifiers: new Set(
-        parsed.document.item.responseDeclarations.map((declaration) => declaration.identifier),
-      ),
-    },
-  };
-}
-
 function createTrustedItemSession(
-  parsed: QtiParsedTrustedItem,
+  parsed: QtiTrustedItemDocument,
   priorState: QtiAttemptStateV1 | null | undefined,
   diagnosticPrefix: QtiTrustedInputDiagnosticPrefix,
+  allowedUndeclaredResponseIdentifiers: readonly string[] | undefined,
   existingDiagnostics: QtiDiagnostic[] = [],
 ): { ok: true; session: QtiItemSession } | { ok: false; diagnostics: QtiDiagnostic[] } {
   try {
     return {
       ok: true,
-      session: createItemSession(parsed.document, priorState ?? undefined),
+      session: createItemSession(parsed.document, priorState ?? undefined, {
+        allowedUndeclaredResponseIdentifiers,
+      }),
     };
   } catch (error) {
     return {
@@ -278,7 +299,7 @@ function createTrustedItemSession(
 
 function applyTrustedResponseApplication(
   session: QtiItemSession,
-  parsed: QtiParsedTrustedItem,
+  parsed: QtiTrustedItemDocument,
   submission: QtiTrustedResponseApplication,
   allowedUndeclaredResponseIdentifiers: readonly string[] | undefined,
   diagnosticPrefix: QtiTrustedInputDiagnosticPrefix,
@@ -287,7 +308,7 @@ function applyTrustedResponseApplication(
   const allowedUndeclared = new Set(allowedUndeclaredResponseIdentifiers ?? []);
   let appliedSubmission = false;
 
-  for (const response of normalizeResponseInputs(submission.trustedResponses)) {
+  for (const response of listNamedResponseInputs(submission.trustedResponses)) {
     const identifier = response.identifier.trim();
     if (!identifier) {
       diagnostics.push({
@@ -369,13 +390,6 @@ function scoreTrustedItemSession(
   }
 }
 
-function shouldRequireNumericScore(item: QtiAssessmentItem): boolean {
-  return (
-    Boolean(item.responseProcessing) ||
-    item.outcomeDeclarations.some((declaration) => declaration.identifier === "SCORE")
-  );
-}
-
 function readNumericScore(value: QtiValue | undefined): number | null {
   if (typeof value === "number" && Number.isFinite(value)) return value;
   if (typeof value === "string") {
@@ -409,12 +423,6 @@ function stripUndeclaredResponses(
   };
 }
 
-function normalizeResponseInputs(responses: QtiTrustedResponsesInput): QtiTrustedResponseInput[] {
-  if (!responses) return [];
-  if (Array.isArray(responses)) return [...responses];
-  return Object.entries(responses).map(([identifier, value]) => ({ identifier, value }));
-}
-
 function isAllowedUndeclaredVariableReference(
   diagnostic: QtiDiagnostic,
   allowedUndeclaredResponseIdentifiers: Set<string>,

package/src/trusted-session-materialization.ts

@@ -0,0 +1,67 @@
+import {
+  classifyQtiItemScoringDisposition,
+  type QtiItemSubmissionScoringDisposition,
+} from "./scoring-disposition-policy.js";
+import type { QtiAssessmentItem, QtiAttemptStateV1, QtiDiagnostic, QtiValue } from "./types.js";
+import { snapshotQtiVariableDeclarations, type QtiVariableSnapshot } from "./variable-snapshot.js";
+
+export interface QtiTrustedSessionMaterialization {
+  diagnostics: QtiDiagnostic[];
+  state: QtiAttemptStateV1;
+  responses: Record<string, QtiValue>;
+  outcomes: Record<string, QtiValue>;
+  score: number | null;
+  candidateSafeXml?: string | undefined;
+}
+
+export interface QtiItemSubmissionMaterializationSuccess {
+  ok: true;
+  diagnostics: QtiDiagnostic[];
+  state: QtiAttemptStateV1;
+  responseVariables: QtiVariableSnapshot[];
+  outcomeVariables: QtiVariableSnapshot[];
+  score: number | null;
+  scoringDisposition: Exclude<QtiItemSubmissionScoringDisposition, "invalid">;
+  candidateSafeXml?: string | undefined;
+}
+
+export interface QtiItemSubmissionMaterializationFailure {
+  ok: false;
+  diagnostics: QtiDiagnostic[];
+  state?: QtiAttemptStateV1 | undefined;
+  responseVariables: QtiVariableSnapshot[];
+  outcomeVariables: QtiVariableSnapshot[];
+  score: null;
+  scoringDisposition: "invalid";
+}
+
+export function buildItemSubmissionMaterializationSuccess(
+  item: QtiAssessmentItem,
+  result: QtiTrustedSessionMaterialization,
+): QtiItemSubmissionMaterializationSuccess {
+  return {
+    ok: true,
+    diagnostics: result.diagnostics,
+    state: result.state,
+    responseVariables: snapshotQtiVariableDeclarations(item.responseDeclarations, result.responses),
+    outcomeVariables: snapshotQtiVariableDeclarations(item.outcomeDeclarations, result.outcomes),
+    score: result.score,
+    scoringDisposition: classifyQtiItemScoringDisposition(item, result.score),
+    candidateSafeXml: result.candidateSafeXml,
+  };
+}
+
+export function buildItemSubmissionMaterializationFailure(
+  diagnostics: QtiDiagnostic[],
+  state?: QtiAttemptStateV1,
+): QtiItemSubmissionMaterializationFailure {
+  return {
+    ok: false,
+    diagnostics,
+    state,
+    responseVariables: [],
+    outcomeVariables: [],
+    score: null,
+    scoringDisposition: "invalid",
+  };
+}

package/src/tts.ts

@@ -103,10 +103,17 @@ interface SegmentInput {
 }
 
 const dataSsmlFunctionNames = new Set(["break", "phoneme", "prosody", "say-as", "sub"]);
-const breakStrengths = new Set(["medium", "none", "strong", "weak", "x-strong", "x-weak"]);
-const phonemeAlphabets = new Set(["ipa", "x-sampa"]);
-const phonemeTypes = new Set(["default", "ruby"]);
-const sayAsInterpretations = new Set([
+const breakStrengths = new Set<QtiDataSsmlBreakStrength>([
+  "medium",
+  "none",
+  "strong",
+  "weak",
+  "x-strong",
+  "x-weak",
+]);
+const phonemeAlphabets = new Set<NonNullable<QtiDataSsmlPhoneme["alphabet"]>>(["ipa", "x-sampa"]);
+const phonemeTypes = new Set<NonNullable<QtiDataSsmlPhoneme["type"]>>(["default", "ruby"]);
+const sayAsInterpretations = new Set<QtiDataSsmlSayAs["interpret-as"]>([
   "cardinal",
   "characters",
   "date",
@@ -200,7 +207,7 @@ function validateBreak(value: Record<string, unknown>, errors: string[]): QtiDat
   const result: QtiDataSsmlBreak = {};
   const strength = optionalEnum(value, "strength", "break.strength", breakStrengths, errors);
   const time = optionalString(value, "time", "break.time", errors);
-  if (strength) result.strength = strength as QtiDataSsmlBreakStrength;
+  if (strength) result.strength = strength;
   if (time !== undefined) result.time = time;
   return result;
 }
@@ -215,8 +222,8 @@ function validatePhoneme(
   const type = optionalEnum(value, "type", "phoneme.type", phonemeTypes, errors);
   if (!ph) return undefined;
   const result: QtiDataSsmlPhoneme = { ph };
-  if (alphabet) result.alphabet = alphabet as QtiDataSsmlPhoneme["alphabet"];
-  if (type) result.type = type as QtiDataSsmlPhoneme["type"];
+  if (alphabet) result.alphabet = alphabet;
+  if (type) result.type = type;
   return result;
 }
 
@@ -241,7 +248,7 @@ function validateSayAs(
     errors,
   );
   if (!interpretation) return undefined;
-  return { "interpret-as": interpretation as QtiDataSsmlSayAs["interpret-as"] };
+  return { "interpret-as": interpretation };
 }
 
 function validateSub(value: Record<string, unknown>, errors: string[]): QtiDataSsmlSub | undefined {
@@ -520,29 +527,36 @@ function requiredString(
   return optionalString(value, name, path, errors);
 }
 
-function optionalEnum(
+function isAllowedEnum<T extends string>(value: string, allowed: ReadonlySet<T>): value is T {
+  for (const entry of allowed) {
+    if (entry === value) return true;
+  }
+  return false;
+}
+
+function optionalEnum<T extends string>(
   value: Record<string, unknown>,
   name: string,
   path: string,
-  allowed: Set<string>,
+  allowed: ReadonlySet<T>,
   errors: string[],
-): string | undefined {
+): T | undefined {
   const property = optionalString(value, name, path, errors);
   if (property === undefined) return undefined;
-  if (!allowed.has(property)) {
+  if (!isAllowedEnum(property, allowed)) {
     errors.push(`${path} has unsupported value "${property}".`);
     return undefined;
   }
   return property;
 }
 
-function requiredEnum(
+function requiredEnum<T extends string>(
   value: Record<string, unknown>,
   name: string,
   path: string,
-  allowed: Set<string>,
+  allowed: ReadonlySet<T>,
   errors: string[],
-): string | undefined {
+): T | undefined {
   if (!Object.hasOwn(value, name)) {
     errors.push(`${path} is required.`);
     return undefined;

package/src/validation-geometry.ts

@@ -0,0 +1,204 @@
+import type { QtiChoice, QtiDiagnostic, QtiInteraction } from "./types.js";
+import { assertNever } from "./assert-never.js";
+import { numericTuple3, numericTuple4 } from "./parser-values.js";
+import { isFiniteNumber } from "./validation-primitives.js";
+
+export function validateHotspotGeometry(choice: QtiChoice, diagnostics: QtiDiagnostic[]): void {
+  if (choice.qtiName !== "qti-hotspot-choice" && choice.qtiName !== "qti-associable-hotspot") {
+    return;
+  }
+
+  const shape = choice.attributes.shape;
+  const coords = choice.attributes.coords;
+  if (!shape) {
+    diagnostics.push({
+      code: "choice.shape.required",
+      severity: "error",
+      message: `${choice.qtiName} ${choice.identifier} requires shape.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+  } else if (!isHotspotShape(shape)) {
+    diagnostics.push({
+      code: "choice.shape",
+      severity: "error",
+      message: `${choice.qtiName} ${choice.identifier} has unsupported shape ${shape}.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+  }
+
+  if (!coords) {
+    diagnostics.push({
+      code: "choice.coords.required",
+      severity: "error",
+      message: `${choice.qtiName} ${choice.identifier} requires coords.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+    return;
+  }
+
+  const values = coords.split(",").map((value) => value.trim());
+  if (values.length === 0 || values.some((value) => value.length === 0 || !isFiniteNumber(value))) {
+    diagnostics.push({
+      code: "choice.coords",
+      severity: "error",
+      message: `${choice.qtiName} ${choice.identifier} requires comma-separated numeric coords.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+    return;
+  }
+
+  if (shape && isHotspotShape(shape) && !hasValidShapeCoordinateCount(shape, values.map(Number))) {
+    diagnostics.push({
+      code: "choice.coords.shape",
+      severity: "error",
+      message: `${choice.qtiName} ${choice.identifier} shape ${shape} has invalid coords arity.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+  }
+}
+
+export function validateGraphicHotspotObjectDimensions(
+  interaction: QtiInteraction,
+  diagnostics: QtiDiagnostic[],
+): void {
+  if (!usesGraphicHotspots(interaction)) return;
+  const hotspotChoices = interaction.choices.filter(isHotspotChoice);
+  if (hotspotChoices.length === 0) return;
+
+  const width = positiveDimension(interaction.object?.width);
+  const height = positiveDimension(interaction.object?.height);
+  if (width === undefined || height === undefined) {
+    diagnostics.push({
+      code: "interaction.graphicObjectDimensions",
+      severity: "warning",
+      message: `${interaction.qtiName} should declare object width and height so hotspot coords map to the rendered image.`,
+      path: interaction.object?.source?.path ?? interaction.source?.path,
+      source: interaction.object?.source ?? interaction.source,
+    });
+    return;
+  }
+
+  for (const choice of hotspotChoices) {
+    const bounds = hotspotBounds(choice);
+    if (!bounds) continue;
+    if (bounds.left >= 0 && bounds.top >= 0 && bounds.right <= width && bounds.bottom <= height) {
+      continue;
+    }
+    diagnostics.push({
+      code: "choice.coords.bounds",
+      severity: "warning",
+      message: `${choice.qtiName} ${choice.identifier} coords extend outside the ${width} by ${height} object image.`,
+      path: choice.source?.path,
+      source: choice.source,
+    });
+  }
+}
+
+function usesGraphicHotspots(interaction: QtiInteraction): boolean {
+  return (
+    interaction.type === "graphicOrder" ||
+    interaction.type === "graphicAssociate" ||
+    interaction.type === "graphicGapMatch" ||
+    interaction.type === "hotspot"
+  );
+}
+
+function isHotspotChoice(choice: QtiChoice): boolean {
+  return choice.qtiName === "qti-hotspot-choice" || choice.qtiName === "qti-associable-hotspot";
+}
+
+function positiveDimension(value: string | undefined): number | undefined {
+  if (!value || value.trim().endsWith("%")) return undefined;
+  const match = value.trim().match(/^(\d+(?:\.\d+)?|\.\d+)(?:px)?$/i);
+  if (!match?.[1]) return undefined;
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function hotspotBounds(
+  choice: QtiChoice,
+): { left: number; top: number; right: number; bottom: number } | undefined {
+  const shape = choice.attributes.shape;
+  const coords = choice.attributes.coords;
+  if (!shape || !coords || !isHotspotShape(shape) || !isNumericCsv(coords)) return undefined;
+  const values = numericCsv(coords);
+  if (!hasValidShapeCoordinateCount(shape, values)) return undefined;
+
+  if (shape === "default") return undefined;
+  if (shape === "circle") {
+    const tuple = numericTuple3(values);
+    if (!tuple) return undefined;
+    const [x, y, radius] = tuple;
+    return { left: x - radius, top: y - radius, right: x + radius, bottom: y + radius };
+  }
+  if (shape === "ellipse") {
+    const tuple = numericTuple4(values);
+    if (!tuple) return undefined;
+    const [x, y, radiusX, radiusY] = tuple;
+    return { left: x - radiusX, top: y - radiusY, right: x + radiusX, bottom: y + radiusY };
+  }
+  if (shape === "rect") {
+    const tuple = numericTuple4(values);
+    if (!tuple) return undefined;
+    const [left, top, right, bottom] = tuple;
+    return { left, top, right, bottom };
+  }
+
+  const xs = values.filter((_, index) => index % 2 === 0);
+  const ys = values.filter((_, index) => index % 2 === 1);
+  return {
+    left: Math.min(...xs),
+    top: Math.min(...ys),
+    right: Math.max(...xs),
+    bottom: Math.max(...ys),
+  };
+}
+
+type QtiHotspotShape = "circle" | "default" | "ellipse" | "poly" | "rect";
+
+function isHotspotShape(value: string): value is QtiHotspotShape {
+  return (
+    value === "circle" ||
+    value === "default" ||
+    value === "ellipse" ||
+    value === "poly" ||
+    value === "rect"
+  );
+}
+
+export function isAreaShape(value: string): boolean {
+  return value === "circle" || value === "default" || value === "poly" || value === "rect";
+}
+
+export function isNumericCsv(value: string): boolean {
+  return value
+    .split(",")
+    .map((part) => part.trim())
+    .every((part) => part.length > 0 && isFiniteNumber(part));
+}
+
+export function numericCsv(value: string): number[] {
+  return value.split(",").map((part) => Number(part.trim()));
+}
+
+export function hasValidShapeCoordinateCount(shape: string, coords: number[]): boolean {
+  if (!isHotspotShape(shape)) return false;
+  switch (shape) {
+    case "circle":
+      return coords.length === 3;
+    case "ellipse":
+    case "rect":
+      return coords.length === 4;
+    case "poly":
+      return coords.length >= 6 && coords.length % 2 === 0;
+    case "default":
+      return true;
+    default:
+      return assertNever(shape);
+  }
+}