@superbuilders/primer-tives 1.0.0 → 1.1.1

package/dist/client/index.js

@@ -1,6 +1,316 @@
-// src/client/create.ts
-import * as errors10 from "@superbuilders/errors";
+// src/contracts/validation.ts
+import { z as z2 } from "zod";
+
+// src/contracts/pci-schemas.ts
+import { z } from "zod";
+var DivisionRemainderPropsSchema = z.object({
+  dividend: z.number(),
+  divisor: z.number()
+});
+var DivisionRemainderSubmissionSchema = z.object({
+  quotient: z.string(),
+  remainder: z.string()
+});
+var FractionOperandSchema = z.object({
+  numerator: z.number(),
+  denominator: z.number()
+});
+var FractionAdditionPropsSchema = z.object({
+  left: FractionOperandSchema,
+  right: FractionOperandSchema
+});
+var FractionAdditionSubmissionSchema = z.object({
+  numerator: z.string(),
+  denominator: z.string()
+});
 
+// src/contracts/validation.ts
+var MatchPairSchema = z2.object({
+  source: z2.string(),
+  target: z2.string()
+});
+var ChoiceSubmissionSchema = z2.object({
+  type: z2.literal("choice"),
+  selectedKeys: z2.array(z2.string())
+});
+var TextEntrySubmissionSchema = z2.object({
+  type: z2.literal("text-entry"),
+  value: z2.string()
+});
+var ExtendedTextSubmissionSchema = z2.object({
+  type: z2.literal("extended-text"),
+  values: z2.array(z2.string()).min(1)
+});
+var OrderSubmissionSchema = z2.object({
+  type: z2.literal("order"),
+  orderedKeys: z2.array(z2.string())
+});
+var MatchSubmissionSchema = z2.object({
+  type: z2.literal("match"),
+  pairs: z2.array(MatchPairSchema)
+});
+var DivisionRemainderPciSubmissionSchema = z2.object({
+  type: z2.literal("portable-custom"),
+  pciId: z2.literal("urn:primer:pci:division-remainder"),
+  value: DivisionRemainderSubmissionSchema
+});
+var FractionAdditionPciSubmissionSchema = z2.object({
+  type: z2.literal("portable-custom"),
+  pciId: z2.literal("urn:primer:pci:fraction-addition"),
+  value: FractionAdditionSubmissionSchema
+});
+var RendererSubmissionSchema = z2.union([
+  ChoiceSubmissionSchema,
+  TextEntrySubmissionSchema,
+  ExtendedTextSubmissionSchema,
+  OrderSubmissionSchema,
+  MatchSubmissionSchema,
+  DivisionRemainderPciSubmissionSchema,
+  FractionAdditionPciSubmissionSchema
+]);
+function invalid(issues) {
+  return {
+    ok: false,
+    issues: Array.isArray(issues) ? issues : [issues]
+  };
+}
+function duplicates(values, keyOf) {
+  const seen = new Set;
+  const duplicated = new Set;
+  for (const value of values) {
+    const key = keyOf(value);
+    if (seen.has(key)) {
+      duplicated.add(key);
+      continue;
+    }
+    seen.add(key);
+  }
+  return [...duplicated];
+}
+function findUnknownIds(values, choices) {
+  const ids = new Set(choices.map(function getId(choice) {
+    return choice.identifier;
+  }));
+  return values.filter(function isUnknown(value) {
+    return !ids.has(value);
+  });
+}
+function countByIdentifier(pairs, side) {
+  const counts = new Map;
+  for (const pair of pairs) {
+    const key = pair[side];
+    const currentCount = counts.get(key);
+    if (currentCount === undefined) {
+      counts.set(key, 1);
+      continue;
+    }
+    counts.set(key, currentCount + 1);
+  }
+  return counts;
+}
+function validateUsageBounds(choices, counts, side) {
+  const issues = [];
+  for (const choice of choices) {
+    const maybeCount = counts.get(choice.identifier);
+    const count = maybeCount === undefined ? 0 : maybeCount;
+    if (choice.matchMax !== 0 && count > choice.matchMax) {
+      issues.push(`${side} '${choice.identifier}' used ${count} times, max ${choice.matchMax}`);
+    }
+    if (count < choice.matchMin) {
+      issues.push(`${side} '${choice.identifier}' used ${count} times, min ${choice.matchMin}`);
+    }
+  }
+  return issues;
+}
+function pciSubmissionSchema(pciId) {
+  switch (pciId) {
+    case "urn:primer:pci:division-remainder":
+      return DivisionRemainderSubmissionSchema;
+    case "urn:primer:pci:fraction-addition":
+      return FractionAdditionSubmissionSchema;
+  }
+  const exhaustiveCheck = pciId;
+  return exhaustiveCheck;
+}
+function validateChoiceSubmission(interaction, submission) {
+  if (submission.type !== "choice") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'choice'`);
+  }
+  const issues = [];
+  if (submission.selectedKeys.length < interaction.minChoices) {
+    issues.push(`need at least ${interaction.minChoices} selections`);
+  }
+  if (submission.selectedKeys.length > interaction.maxChoices) {
+    issues.push(`at most ${interaction.maxChoices} selections`);
+  }
+  const duplicateKeys = duplicates(submission.selectedKeys, function keyOf(value) {
+    return value;
+  });
+  if (duplicateKeys.length > 0) {
+    issues.push("duplicate selections");
+  }
+  const unknownKeys = findUnknownIds(submission.selectedKeys, interaction.options);
+  if (unknownKeys.length > 0) {
+    issues.push(`unknown options: ${unknownKeys.join(", ")}`);
+  }
+  if (issues.length > 0) {
+    return invalid(issues);
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validateTextEntrySubmission(interaction, submission) {
+  if (submission.type !== "text-entry") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'text-entry'`);
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validateExtendedTextSubmission(interaction, submission) {
+  if (submission.type !== "extended-text") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'extended-text'`);
+  }
+  const issues = [];
+  if (interaction.cardinality === "single") {
+    if (submission.values.length !== 1) {
+      issues.push("single-cardinality extended-text requires exactly one value");
+    }
+  } else {
+    if (submission.values.length < interaction.minStrings) {
+      issues.push(`need at least ${interaction.minStrings} values`);
+    }
+    if (submission.values.length > interaction.maxStrings) {
+      issues.push(`at most ${interaction.maxStrings} values`);
+    }
+    const duplicateValues = duplicates(submission.values, function keyOf(value) {
+      return value;
+    });
+    if (duplicateValues.length > 0) {
+      issues.push("duplicate values are not allowed for multiple-cardinality extended-text");
+    }
+  }
+  if (issues.length > 0) {
+    return invalid(issues);
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validateOrderSubmission(interaction, submission) {
+  if (submission.type !== "order") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'order'`);
+  }
+  const issues = [];
+  if (submission.orderedKeys.length < interaction.minChoices) {
+    issues.push(`need at least ${interaction.minChoices} selections`);
+  }
+  if (submission.orderedKeys.length > interaction.maxChoices) {
+    issues.push(`at most ${interaction.maxChoices} selections`);
+  }
+  const duplicateKeys = duplicates(submission.orderedKeys, function keyOf(value) {
+    return value;
+  });
+  if (duplicateKeys.length > 0) {
+    issues.push("duplicate selections");
+  }
+  const unknownKeys = findUnknownIds(submission.orderedKeys, interaction.choices);
+  if (unknownKeys.length > 0) {
+    issues.push(`unknown choices: ${unknownKeys.join(", ")}`);
+  }
+  if (issues.length > 0) {
+    return invalid(issues);
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validateMatchSubmission(interaction, submission) {
+  if (submission.type !== "match") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'match'`);
+  }
+  const issues = [];
+  if (submission.pairs.length < interaction.minAssociations) {
+    issues.push(`need at least ${interaction.minAssociations} associations`);
+  }
+  if (submission.pairs.length > interaction.maxAssociations) {
+    issues.push(`at most ${interaction.maxAssociations} associations`);
+  }
+  const duplicatePairs = duplicates(submission.pairs, function keyOf(pair) {
+    return `${pair.source}->${pair.target}`;
+  });
+  if (duplicatePairs.length > 0) {
+    issues.push("duplicate associations are not allowed");
+  }
+  const sourceIds = new Set(interaction.sourceChoices.map(function getId(choice) {
+    return choice.identifier;
+  }));
+  const targetIds = new Set(interaction.targetChoices.map(function getId(choice) {
+    return choice.identifier;
+  }));
+  for (const pair of submission.pairs) {
+    if (!sourceIds.has(pair.source)) {
+      issues.push(`unknown source '${pair.source}'`);
+    }
+    if (!targetIds.has(pair.target)) {
+      issues.push(`unknown target '${pair.target}'`);
+    }
+  }
+  const sourceCounts = countByIdentifier(submission.pairs, "source");
+  const targetCounts = countByIdentifier(submission.pairs, "target");
+  issues.push(...validateUsageBounds(interaction.sourceChoices, sourceCounts, "source"));
+  issues.push(...validateUsageBounds(interaction.targetChoices, targetCounts, "target"));
+  if (issues.length > 0) {
+    return invalid(issues);
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validatePortableCustomSubmission(interaction, submission) {
+  if (submission.type !== "portable-custom") {
+    return invalid(`submission type '${submission.type}' does not match interaction type 'portable-custom'`);
+  }
+  if (submission.pciId !== interaction.pciId) {
+    return invalid(`submission PCI '${submission.pciId}' does not match interaction PCI '${interaction.pciId}'`);
+  }
+  const schema = pciSubmissionSchema(interaction.pciId);
+  const result = schema.safeParse(submission.value);
+  if (!result.success) {
+    return invalid(result.error.issues.map(function toIssue(issue) {
+      return issue.message;
+    }));
+  }
+  return {
+    ok: true,
+    value: { ...submission }
+  };
+}
+function validateSubmissionForInteraction(interaction, submission) {
+  switch (interaction.type) {
+    case "choice":
+      return validateChoiceSubmission(interaction, submission);
+    case "text-entry":
+      return validateTextEntrySubmission(interaction, submission);
+    case "extended-text":
+      return validateExtendedTextSubmission(interaction, submission);
+    case "order":
+      return validateOrderSubmission(interaction, submission);
+    case "match":
+      return validateMatchSubmission(interaction, submission);
+    case "portable-custom":
+      return validatePortableCustomSubmission(interaction, submission);
+  }
+}
+function submissionValidationMessage(result) {
+  return result.issues.join("; ");
+}
 // src/errors.ts
 import * as errors from "@superbuilders/errors";
 var ErrNetwork = errors.new("network");
@@ -24,15 +334,48 @@ var ErrInvalidSecretKey = errors.new("invalid secret key");
 var ErrStudentNotFound = errors.new("student not found");
 var ErrUnsupportedGrade = errors.new("unsupported grade");
 var ErrTimebackUnavailable = errors.new("timeback unavailable");
+// src/client/create.ts
+import * as errors10 from "@superbuilders/errors";
 
 // src/client/transport.ts
 import * as errors2 from "@superbuilders/errors";
 var ADVANCE_PATH = "/api/v0/advance";
-function httpSentinel(status) {
+function isAdvanceErrorBody(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if ("error" in value && value.error !== undefined && typeof value.error !== "string") {
+    return false;
+  }
+  if ("detail" in value && value.detail !== undefined && typeof value.detail !== "string") {
+    return false;
+  }
+  return true;
+}
+function parseAdvanceErrorBody(body) {
+  if (body.length === 0) {
+    return null;
+  }
+  const parsed = errors2.trySync(function parseJson() {
+    return JSON.parse(body);
+  });
+  if (parsed.error) {
+    return null;
+  }
+  if (!isAdvanceErrorBody(parsed.data)) {
+    return null;
+  }
+  return parsed.data;
+}
+function httpSentinel(status, body) {
   if (status === 400) {
     return ErrBadRequest;
   }
   if (status === 401) {
+    const parsed = parseAdvanceErrorBody(body);
+    if (parsed?.detail === "token_expired") {
+      return ErrTokenExpired;
+    }
     return ErrInvalidAccessToken;
   }
   if (status === 403) {
@@ -106,7 +449,7 @@ function createTransport(tc) {
       const text = await res.text().catch(function fallback() {
         return "";
       });
-      const sentinel = res.status === 422 ? ErrUnsupportedPci : httpSentinel(res.status);
+      const sentinel = res.status === 422 ? ErrUnsupportedPci : httpSentinel(res.status, text);
       log?.error("transport http error", {
         status: res.status
       });
@@ -141,38 +484,6 @@ function poisonToJSON() {
 
 // src/client/choice-state.ts
 import * as errors3 from "@superbuilders/errors";
-function findUnknownKey(selectedKeys, options) {
-  const optionIds = new Set(options.map(function getId(o) {
-    return o.identifier;
-  }));
-  for (const key of selectedKeys) {
-    if (!optionIds.has(key)) {
-      return key;
-    }
-  }
-  return null;
-}
-function validateChoiceSubmission(log, selectedKeys, options, maxChoices, minChoices) {
-  if (selectedKeys.length < minChoices) {
-    log?.error("choice submit below minChoices", { selectedKeys, minChoices });
-    return errors3.wrap(ErrInvalidSubmission, `need at least ${minChoices} selections`);
-  }
-  if (selectedKeys.length > maxChoices) {
-    log?.error("choice submit above maxChoices", { selectedKeys, maxChoices });
-    return errors3.wrap(ErrInvalidSubmission, `at most ${maxChoices} selections`);
-  }
-  const uniqueKeys = new Set(selectedKeys);
-  if (uniqueKeys.size !== selectedKeys.length) {
-    log?.error("choice submit has duplicates", { selectedKeys });
-    return errors3.wrap(ErrInvalidSubmission, "duplicate selections");
-  }
-  const unknownKey = findUnknownKey(selectedKeys, options);
-  if (unknownKey) {
-    log?.error("choice submit has unknown key", { key: unknownKey });
-    return errors3.wrap(ErrInvalidSubmission, `unknown option '${unknownKey}'`);
-  }
-  return null;
-}
 function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices) {
   let submitPending;
   let submitKey;
@@ -189,9 +500,10 @@ function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices
       }
       return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot submit a different choice payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
-    const validationError = validateChoiceSubmission(ctx.log, selectedKeys, options, maxChoices, minChoices);
-    if (validationError) {
-      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    const validation = validateSubmissionForInteraction(interaction, submission);
+    if (!validation.ok) {
+      ctx.log?.error("choice submit invalid", { selectedKeys, issues: validation.issues });
+      return Promise.resolve(ctx.errored(errors3.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
     }
     submitKey = key;
     submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
@@ -229,17 +541,6 @@ function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices
 
 // src/client/extended-text-state.ts
 import * as errors4 from "@superbuilders/errors";
-function validateExtendedTextSubmission(log, values, minStrings, maxStrings) {
-  if (values.length < minStrings) {
-    log?.error("extended-text submit below minStrings", { count: values.length, minStrings });
-    return errors4.wrap(ErrInvalidSubmission, `need at least ${minStrings} values`);
-  }
-  if (values.length > maxStrings) {
-    log?.error("extended-text submit above maxStrings", { count: values.length, maxStrings });
-    return errors4.wrap(ErrInvalidSubmission, `at most ${maxStrings} values`);
-  }
-  return null;
-}
 function extendedTextState(ctx, stimulus, interaction) {
   if (interaction.cardinality === "single") {
     let submitText = function(value) {
@@ -254,6 +555,11 @@ function extendedTextState(ctx, stimulus, interaction) {
         }
         return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
       }
+      const validation = validateSubmissionForInteraction(interaction, submission);
+      if (!validation.ok) {
+        ctx.log?.error("extended-text submit invalid", { value, issues: validation.issues });
+        return Promise.resolve(ctx.errored(errors4.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
+      }
       submitKey2 = key;
       submitPending2 = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
         submitPending2 = undefined;
@@ -303,9 +609,10 @@ function extendedTextState(ctx, stimulus, interaction) {
       }
       return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
-    const validationError = validateExtendedTextSubmission(ctx.log, values, multi.minStrings, multi.maxStrings);
-    if (validationError) {
-      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    const validation = validateSubmissionForInteraction(multi, submission);
+    if (!validation.ok) {
+      ctx.log?.error("extended-text submit invalid", { values, issues: validation.issues });
+      return Promise.resolve(ctx.errored(errors4.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
     }
     submitKey = key;
     submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
@@ -365,92 +672,6 @@ function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedba
 
 // src/client/match-state.ts
 import * as errors5 from "@superbuilders/errors";
-function bumpCount(counts, key) {
-  const prev = counts.get(key);
-  const next = prev === undefined ? 1 : prev + 1;
-  counts.set(key, next);
-}
-function getCount(counts, key) {
-  const recorded = counts.get(key);
-  return recorded === undefined ? 0 : recorded;
-}
-function validateAssociationBounds(log, pairs, minAssociations, maxAssociations) {
-  if (pairs.length < minAssociations) {
-    log?.error("match submit below minAssociations", { pairs, minAssociations });
-    return errors5.wrap(ErrInvalidSubmission, `need at least ${minAssociations} associations`);
-  }
-  if (pairs.length > maxAssociations) {
-    log?.error("match submit above maxAssociations", { pairs, maxAssociations });
-    return errors5.wrap(ErrInvalidSubmission, `at most ${maxAssociations} associations`);
-  }
-  return null;
-}
-function validatePairsReferToKnownChoices(log, pairs, sourceIds, targetIds) {
-  for (const pair of pairs) {
-    if (!sourceIds.has(pair.source)) {
-      log?.error("match submit has unknown source", { source: pair.source });
-      return errors5.wrap(ErrInvalidSubmission, `unknown source '${pair.source}'`);
-    }
-    if (!targetIds.has(pair.target)) {
-      log?.error("match submit has unknown target", { target: pair.target });
-      return errors5.wrap(ErrInvalidSubmission, `unknown target '${pair.target}'`);
-    }
-  }
-  return null;
-}
-function validateChoiceCaps(log, side, choices, counts) {
-  for (const choice of choices) {
-    const count = getCount(counts, choice.identifier);
-    if (choice.matchMax !== 0 && count > choice.matchMax) {
-      log?.error(`match submit exceeds ${side} matchMax`, {
-        identifier: choice.identifier,
-        count,
-        matchMax: choice.matchMax
-      });
-      return errors5.wrap(ErrInvalidSubmission, `${side} '${choice.identifier}' used ${count} times, max ${choice.matchMax}`);
-    }
-    if (count < choice.matchMin) {
-      log?.error(`match submit below ${side} matchMin`, {
-        identifier: choice.identifier,
-        count,
-        matchMin: choice.matchMin
-      });
-      return errors5.wrap(ErrInvalidSubmission, `${side} '${choice.identifier}' used ${count} times, min ${choice.matchMin}`);
-    }
-  }
-  return null;
-}
-function validateMatchSubmission(log, pairs, sourceChoices, targetChoices, minAssociations, maxAssociations) {
-  const boundsError = validateAssociationBounds(log, pairs, minAssociations, maxAssociations);
-  if (boundsError) {
-    return boundsError;
-  }
-  const sourceIds = new Set(sourceChoices.map(function getId(c) {
-    return c.identifier;
-  }));
-  const targetIds = new Set(targetChoices.map(function getId(c) {
-    return c.identifier;
-  }));
-  const referenceError = validatePairsReferToKnownChoices(log, pairs, sourceIds, targetIds);
-  if (referenceError) {
-    return referenceError;
-  }
-  const sourceCounts = new Map;
-  const targetCounts = new Map;
-  for (const pair of pairs) {
-    bumpCount(sourceCounts, pair.source);
-    bumpCount(targetCounts, pair.target);
-  }
-  const sourceCapError = validateChoiceCaps(log, "source", sourceChoices, sourceCounts);
-  if (sourceCapError) {
-    return sourceCapError;
-  }
-  const targetCapError = validateChoiceCaps(log, "target", targetChoices, targetCounts);
-  if (targetCapError) {
-    return targetCapError;
-  }
-  return null;
-}
 function matchState(ctx, stimulus, interaction) {
   let submitPending;
   let submitKey;
@@ -467,9 +688,10 @@ function matchState(ctx, stimulus, interaction) {
       }
       return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot submit a different match payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
-    const validationError = validateMatchSubmission(ctx.log, pairs, interaction.sourceChoices, interaction.targetChoices, interaction.minAssociations, interaction.maxAssociations);
-    if (validationError) {
-      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    const validation = validateSubmissionForInteraction(interaction, submission);
+    if (!validation.ok) {
+      ctx.log?.error("match submit invalid", { pairs, issues: validation.issues });
+      return Promise.resolve(ctx.errored(errors5.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
     }
     submitKey = key;
     submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
@@ -525,38 +747,6 @@ function observationState(ctx, stimulus) {
 
 // src/client/order-state.ts
 import * as errors6 from "@superbuilders/errors";
-function findUnknownKey2(orderedKeys, choices) {
-  const choiceIds = new Set(choices.map(function getId(c) {
-    return c.identifier;
-  }));
-  for (const key of orderedKeys) {
-    if (!choiceIds.has(key)) {
-      return key;
-    }
-  }
-  return null;
-}
-function validateOrderSubmission(log, orderedKeys, choices, minChoices, maxChoices) {
-  if (orderedKeys.length < minChoices) {
-    log?.error("order submit below minChoices", { orderedKeys, minChoices });
-    return errors6.wrap(ErrInvalidSubmission, `need at least ${minChoices} selections`);
-  }
-  if (orderedKeys.length > maxChoices) {
-    log?.error("order submit above maxChoices", { orderedKeys, maxChoices });
-    return errors6.wrap(ErrInvalidSubmission, `at most ${maxChoices} selections`);
-  }
-  const uniqueKeys = new Set(orderedKeys);
-  if (uniqueKeys.size !== orderedKeys.length) {
-    log?.error("order submit has duplicates", { orderedKeys });
-    return errors6.wrap(ErrInvalidSubmission, "duplicate selections");
-  }
-  const unknownKey = findUnknownKey2(orderedKeys, choices);
-  if (unknownKey) {
-    log?.error("order submit has unknown key", { key: unknownKey });
-    return errors6.wrap(ErrInvalidSubmission, `unknown choice '${unknownKey}'`);
-  }
-  return null;
-}
 function orderState(ctx, stimulus, interaction) {
   let submitPending;
   let submitKey;
@@ -573,9 +763,10 @@ function orderState(ctx, stimulus, interaction) {
       }
       return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different order payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
-    const validationError = validateOrderSubmission(ctx.log, orderedKeys, interaction.choices, interaction.minChoices, interaction.maxChoices);
-    if (validationError) {
-      return Promise.resolve(ctx.errored(validationError, "interaction", { kind: "interaction", submission }));
+    const validation = validateSubmissionForInteraction(interaction, submission);
+    if (!validation.ok) {
+      ctx.log?.error("order submit invalid", { orderedKeys, issues: validation.issues });
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
     }
     submitKey = key;
     submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
@@ -683,6 +874,11 @@ function textEntryState(ctx, stimulus, interaction) {
       }
       return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot submit a different text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
     }
+    const validation = validateSubmissionForInteraction(interaction, submission);
+    if (!validation.ok) {
+      ctx.log?.error("text-entry submit invalid", { value, issues: validation.issues });
+      return Promise.resolve(ctx.errored(errors8.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
+    }
     submitKey = key;
     submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
       submitPending = undefined;
@@ -924,4 +1120,4 @@ export {
   ErrBadRequest
 };
 
-//# debugId=03C66069BFA6BE2F64756E2164756E21
+//# debugId=3AF97B3EB454BA4764756E2164756E21