@conform-ed/contracts 0.0.3

package/src/qti/v3_0_1/shared.ts

@@ -0,0 +1,146 @@
+import { z } from "zod";
+
+export const NonEmptyStringSchema = z.string().min(1);
+export const UriReferenceSchema = NonEmptyStringSchema;
+export const QtiIdentifierSchema = z
+  .string()
+  .min(1)
+  .regex(/^[A-Za-z_][A-Za-z0-9._-]*$/u);
+export const QtiIdentifierListSchema = z.array(QtiIdentifierSchema);
+export const QtiStringListSchema = z.array(NonEmptyStringSchema);
+export const QtiCoordsSchema = NonEmptyStringSchema;
+export const QtiMimeTypeSchema = NonEmptyStringSchema;
+export const QtiStringOrNumberSchema = z.union([z.string(), z.number()]);
+export const QtiIntegerOrVariableSchema = z.union([z.number().int(), NonEmptyStringSchema]);
+export const QtiNumberOrVariableSchema = z.union([z.number(), NonEmptyStringSchema]);
+
+export const QtiCardinalitySchema = z.enum(["single", "multiple", "ordered", "record"]);
+
+export const QtiBaseTypeSchema = z.enum([
+  "boolean",
+  "directedPair",
+  "duration",
+  "file",
+  "float",
+  "identifier",
+  "integer",
+  "pair",
+  "point",
+  "string",
+  "uri",
+]);
+
+export const QtiShowHideSchema = z.enum(["show", "hide"]);
+export const QtiViewSchema = z.enum(["author", "candidate", "proctor", "scorer", "testConstructor", "tutor"]);
+export const QtiDirectionSchema = z.enum(["ltr", "rtl", "auto"]);
+export const QtiOrientationSchema = z.enum(["horizontal", "vertical"]);
+export const QtiNavigationModeSchema = z.enum(["linear", "nonlinear"]);
+export const QtiSubmissionModeSchema = z.enum(["individual", "simultaneous"]);
+export const QtiSuppressTtsSchema = z.enum(["computer-read-aloud", "screen-reader", "all"]);
+export const QtiShapeSchema = z.enum(["circle", "default", "ellipse", "poly", "rect"]);
+export const QtiExternalScoredSchema = z.enum(["externalMachine", "human"]);
+export const QtiSessionStatusSchema = z.enum([
+  "final",
+  "initial",
+  "pendingExternalScoring",
+  "pendingResponseProcessing",
+  "pendingSubmission",
+]);
+export const QtiScoreStatusSchema = z.enum(["notscored", "scored"]);
+export const QtiAnsweredStatusSchema = z.enum(["notpresented", "presented", "attempted", "answered"]);
+export const QtiSupportAssignmentSchema = z.enum(["assigned", "universal", "prohibited", "inherit"]);
+
+export const XmlForeignAttributesSchema = z.record(z.string(), z.unknown());
+
+export const XmlExtensionNodeSchema = z
+  .object({
+    namespace: NonEmptyStringSchema,
+    name: NonEmptyStringSchema,
+    value: z.unknown().optional(),
+    attributes: XmlForeignAttributesSchema.optional(),
+    children: z.array(z.unknown()).optional(),
+  })
+  .strict();
+
+export const XmlExtensionNodeListSchema = z.array(XmlExtensionNodeSchema);
+
+export function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+export function looseObject<T extends z.ZodRawShape>(shape: T) {
+  return strictObject({
+    ...shape,
+    extensions: XmlExtensionNodeListSchema.optional(),
+    foreignAttributes: XmlForeignAttributesSchema.optional(),
+  });
+}
+
+export function createXmlNodeSchema(childSchema: z.ZodTypeAny): z.ZodTypeAny {
+  return z.lazy(() =>
+    strictObject({
+      kind: z.literal("xml"),
+      namespace: z.string().optional(),
+      name: NonEmptyStringSchema,
+      value: z.string().optional(),
+      attributes: XmlForeignAttributesSchema.optional(),
+      children: z.array(childSchema).optional(),
+    }),
+  );
+}
+
+export function addIssue(context: z.RefinementCtx, path: Array<string | number>, message: string) {
+  context.addIssue({
+    code: z.ZodIssueCode.custom,
+    path,
+    message,
+  });
+}
+
+export function collectDuplicates(values: string[]): string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+      continue;
+    }
+    seen.add(value);
+  }
+
+  return [...duplicates];
+}
+
+export function asArray<T>(value: readonly T[] | T[] | undefined | null): T[] {
+  return Array.isArray(value) ? [...value] : [];
+}
+// Inferred types from exported Zod validators.
+export type NonEmptyString = z.infer<typeof NonEmptyStringSchema>;
+export type UriReference = z.infer<typeof UriReferenceSchema>;
+export type QtiIdentifier = z.infer<typeof QtiIdentifierSchema>;
+export type QtiIdentifierList = z.infer<typeof QtiIdentifierListSchema>;
+export type QtiStringList = z.infer<typeof QtiStringListSchema>;
+export type QtiCoords = z.infer<typeof QtiCoordsSchema>;
+export type QtiMimeType = z.infer<typeof QtiMimeTypeSchema>;
+export type QtiStringOrNumber = z.infer<typeof QtiStringOrNumberSchema>;
+export type QtiIntegerOrVariable = z.infer<typeof QtiIntegerOrVariableSchema>;
+export type QtiNumberOrVariable = z.infer<typeof QtiNumberOrVariableSchema>;
+export type QtiCardinality = z.infer<typeof QtiCardinalitySchema>;
+export type QtiBaseType = z.infer<typeof QtiBaseTypeSchema>;
+export type QtiShowHide = z.infer<typeof QtiShowHideSchema>;
+export type QtiView = z.infer<typeof QtiViewSchema>;
+export type QtiDirection = z.infer<typeof QtiDirectionSchema>;
+export type QtiOrientation = z.infer<typeof QtiOrientationSchema>;
+export type QtiNavigationMode = z.infer<typeof QtiNavigationModeSchema>;
+export type QtiSubmissionMode = z.infer<typeof QtiSubmissionModeSchema>;
+export type QtiSuppressTts = z.infer<typeof QtiSuppressTtsSchema>;
+export type QtiShape = z.infer<typeof QtiShapeSchema>;
+export type QtiExternalScored = z.infer<typeof QtiExternalScoredSchema>;
+export type QtiSessionStatus = z.infer<typeof QtiSessionStatusSchema>;
+export type QtiScoreStatus = z.infer<typeof QtiScoreStatusSchema>;
+export type QtiAnsweredStatus = z.infer<typeof QtiAnsweredStatusSchema>;
+export type QtiSupportAssignment = z.infer<typeof QtiSupportAssignmentSchema>;
+export type XmlForeignAttributes = z.infer<typeof XmlForeignAttributesSchema>;
+export type XmlExtensionNode = z.infer<typeof XmlExtensionNodeSchema>;
+export type XmlExtensionNodeList = z.infer<typeof XmlExtensionNodeListSchema>;

package/src/qti/v3_0_1/variables-internal.ts

@@ -0,0 +1,274 @@
+import { z } from "zod";
+
+import {
+  QtiBaseTypeSchema,
+  QtiCardinalitySchema,
+  QtiCoordsSchema,
+  QtiExternalScoredSchema,
+  QtiIdentifierSchema,
+  QtiMimeTypeSchema,
+  QtiShapeSchema,
+  QtiViewSchema,
+  addIssue,
+  looseObject,
+  strictObject,
+} from "./shared";
+
+export const QtiValueSchema = strictObject({
+  value: z.string(),
+  fieldIdentifier: QtiIdentifierSchema.optional(),
+  baseType: QtiBaseTypeSchema.optional(),
+});
+
+export const QtiDefaultValueSchema = strictObject({
+  values: z.array(QtiValueSchema).min(1),
+  interpretation: z.string().optional(),
+});
+
+export const QtiCorrectResponseSchema = strictObject({
+  values: z.array(QtiValueSchema).min(1),
+  interpretation: z.string().optional(),
+});
+
+export const QtiAreaMapEntrySchema = strictObject({
+  shape: QtiShapeSchema,
+  coords: QtiCoordsSchema,
+  mappedValue: z.number(),
+});
+
+export const QtiAreaMappingSchema = strictObject({
+  areaMapEntries: z.array(QtiAreaMapEntrySchema).min(1),
+  lowerBound: z.number().optional(),
+  upperBound: z.number().optional(),
+  defaultValue: z.number().optional(),
+});
+
+export const QtiMapEntrySchema = strictObject({
+  mapKey: z.string(),
+  mappedValue: z.number(),
+  caseSensitive: z.boolean().optional(),
+});
+
+export const QtiMappingSchema = strictObject({
+  mapEntries: z.array(QtiMapEntrySchema).min(1),
+  lowerBound: z.number().optional(),
+  upperBound: z.number().optional(),
+  defaultValue: z.number().optional(),
+});
+
+export const QtiInterpolationTableEntrySchema = strictObject({
+  sourceValue: z.number(),
+  includeBoundary: z.boolean().optional(),
+  targetValue: z.string(),
+});
+
+export const QtiInterpolationTableSchema = strictObject({
+  interpolationTableEntries: z.array(QtiInterpolationTableEntrySchema).min(1),
+  defaultValue: z.string().optional(),
+});
+
+export const QtiMatchTableEntrySchema = strictObject({
+  sourceValue: z.number().int(),
+  targetValue: z.string(),
+});
+
+export const QtiMatchTableSchema = strictObject({
+  matchTableEntries: z.array(QtiMatchTableEntrySchema).min(1),
+  defaultValue: z.string().optional(),
+});
+
+export const QtiStyleSheetSchema = strictObject({
+  href: z.string(),
+  type: QtiMimeTypeSchema,
+  media: z.string().optional(),
+  title: z.string().optional(),
+});
+
+export const QtiCatalogSchema = looseObject({
+  kind: z.literal("catalog"),
+  content: z.array(z.unknown()).optional(),
+});
+
+export const QtiCatalogInfoSchema = strictObject({
+  catalogs: z.array(QtiCatalogSchema).min(1),
+});
+
+export const QtiItemSessionControlSchema = strictObject({
+  maxAttempts: z.number().int().optional(),
+  showFeedback: z.boolean().optional(),
+  allowReview: z.boolean().optional(),
+  showSolution: z.boolean().optional(),
+  allowComment: z.boolean().optional(),
+  allowSkipping: z.boolean().optional(),
+  validateResponses: z.boolean().optional(),
+});
+
+export const QtiTimeLimitsSchema = strictObject({
+  minTime: z.number().nonnegative().optional(),
+  maxTime: z.number().nonnegative().optional(),
+  allowLateSubmission: z.boolean().optional(),
+}).superRefine((value, context) => {
+  if (value.minTime !== undefined && value.maxTime !== undefined && value.minTime > value.maxTime) {
+    addIssue(context, ["maxTime"], "maxTime must be greater than or equal to minTime.");
+  }
+});
+
+export const QtiVariableMappingSchema = strictObject({
+  sourceIdentifier: QtiIdentifierSchema,
+  targetIdentifier: QtiIdentifierSchema,
+});
+
+export const QtiWeightSchema = strictObject({
+  identifier: QtiIdentifierSchema,
+  value: z.number(),
+});
+
+function validateValuesForCardinality(
+  values: readonly z.infer<typeof QtiValueSchema>[] | undefined,
+  cardinality: z.infer<typeof QtiCardinalitySchema>,
+  context: z.RefinementCtx,
+  path: Array<string | number>,
+) {
+  if (!values?.length) {
+    return;
+  }
+
+  if (cardinality === "record") {
+    for (const [index, value] of values.entries()) {
+      if (!value.fieldIdentifier) {
+        addIssue(
+          context,
+          [...path, index, "fieldIdentifier"],
+          "Record cardinality values must define fieldIdentifier.",
+        );
+      }
+    }
+    return;
+  }
+
+  for (const [index, value] of values.entries()) {
+    if (value.fieldIdentifier) {
+      addIssue(
+        context,
+        [...path, index, "fieldIdentifier"],
+        "fieldIdentifier is only valid for record cardinality values.",
+      );
+    }
+  }
+}
+
+function validateDeclarationBaseType(
+  cardinality: z.infer<typeof QtiCardinalitySchema>,
+  baseType: z.infer<typeof QtiBaseTypeSchema> | undefined,
+  context: z.RefinementCtx,
+) {
+  if (cardinality === "record" && baseType) {
+    addIssue(context, ["baseType"], "baseType must be omitted when cardinality is record.");
+  }
+}
+
+const QtiVariableDeclarationBaseShape = {
+  identifier: QtiIdentifierSchema,
+  cardinality: QtiCardinalitySchema,
+  baseType: QtiBaseTypeSchema.optional(),
+};
+
+export const QtiContextDeclarationSchema = strictObject({
+  ...QtiVariableDeclarationBaseShape,
+  defaultValue: QtiDefaultValueSchema.optional(),
+}).superRefine((value, context) => {
+  validateDeclarationBaseType(value.cardinality, value.baseType, context);
+  validateValuesForCardinality(value.defaultValue?.values, value.cardinality, context, ["defaultValue", "values"]);
+});
+
+export const QtiTemplateDeclarationSchema = strictObject({
+  ...QtiVariableDeclarationBaseShape,
+  defaultValue: QtiDefaultValueSchema.optional(),
+  paramVariable: z.boolean().optional(),
+  mathVariable: z.boolean().optional(),
+}).superRefine((value, context) => {
+  validateDeclarationBaseType(value.cardinality, value.baseType, context);
+  validateValuesForCardinality(value.defaultValue?.values, value.cardinality, context, ["defaultValue", "values"]);
+});
+
+export const QtiResponseDeclarationRawSchema = strictObject({
+  ...QtiVariableDeclarationBaseShape,
+  defaultValue: QtiDefaultValueSchema.optional(),
+  correctResponse: QtiCorrectResponseSchema.optional(),
+  mapping: QtiMappingSchema.optional(),
+  areaMapping: QtiAreaMappingSchema.optional(),
+});
+
+export const QtiResponseDeclarationSchema = QtiResponseDeclarationRawSchema.superRefine((value, context) => {
+  validateDeclarationBaseType(value.cardinality, value.baseType, context);
+  validateValuesForCardinality(value.defaultValue?.values, value.cardinality, context, ["defaultValue", "values"]);
+  validateValuesForCardinality(value.correctResponse?.values, value.cardinality, context, [
+    "correctResponse",
+    "values",
+  ]);
+
+  if (value.areaMapping && value.baseType !== "point") {
+    addIssue(context, ["areaMapping"], "areaMapping is only valid for response declarations with baseType 'point'.");
+  }
+
+  if (value.mapping && (value.baseType === "file" || value.baseType === "duration" || value.cardinality === "record")) {
+    addIssue(context, ["mapping"], "mapping is not valid for file, duration, or record-valued response declarations.");
+  }
+});
+
+export const QtiOutcomeDeclarationRawSchema = strictObject({
+  ...QtiVariableDeclarationBaseShape,
+  defaultValue: QtiDefaultValueSchema.optional(),
+  matchTable: QtiMatchTableSchema.optional(),
+  interpolationTable: QtiInterpolationTableSchema.optional(),
+  view: z.array(QtiViewSchema).optional(),
+  interpretation: z.string().optional(),
+  longInterpretation: z.string().optional(),
+  normalMaximum: z.number().optional(),
+  normalMinimum: z.number().optional(),
+  masteryValue: z.number().optional(),
+  externalScored: QtiExternalScoredSchema.optional(),
+  variableIdentifierRef: QtiIdentifierSchema.optional(),
+});
+
+export const QtiOutcomeDeclarationSchema = QtiOutcomeDeclarationRawSchema.superRefine((value, context) => {
+  validateDeclarationBaseType(value.cardinality, value.baseType, context);
+  validateValuesForCardinality(value.defaultValue?.values, value.cardinality, context, ["defaultValue", "values"]);
+
+  if (value.matchTable && value.interpolationTable) {
+    addIssue(context, ["matchTable"], "Only one of matchTable or interpolationTable may be supplied.");
+  }
+
+  if (
+    value.normalMinimum !== undefined &&
+    value.normalMaximum !== undefined &&
+    value.normalMinimum > value.normalMaximum
+  ) {
+    addIssue(context, ["normalMaximum"], "normalMaximum must be greater than or equal to normalMinimum.");
+  }
+});
+// Inferred types from exported Zod validators.
+export type QtiValue = z.infer<typeof QtiValueSchema>;
+export type QtiDefaultValue = z.infer<typeof QtiDefaultValueSchema>;
+export type QtiCorrectResponse = z.infer<typeof QtiCorrectResponseSchema>;
+export type QtiAreaMapEntry = z.infer<typeof QtiAreaMapEntrySchema>;
+export type QtiAreaMapping = z.infer<typeof QtiAreaMappingSchema>;
+export type QtiMapEntry = z.infer<typeof QtiMapEntrySchema>;
+export type QtiMapping = z.infer<typeof QtiMappingSchema>;
+export type QtiInterpolationTableEntry = z.infer<typeof QtiInterpolationTableEntrySchema>;
+export type QtiInterpolationTable = z.infer<typeof QtiInterpolationTableSchema>;
+export type QtiMatchTableEntry = z.infer<typeof QtiMatchTableEntrySchema>;
+export type QtiMatchTable = z.infer<typeof QtiMatchTableSchema>;
+export type QtiStyleSheet = z.infer<typeof QtiStyleSheetSchema>;
+export type QtiCatalog = z.infer<typeof QtiCatalogSchema>;
+export type QtiCatalogInfo = z.infer<typeof QtiCatalogInfoSchema>;
+export type QtiItemSessionControl = z.infer<typeof QtiItemSessionControlSchema>;
+export type QtiTimeLimits = z.infer<typeof QtiTimeLimitsSchema>;
+export type QtiVariableMapping = z.infer<typeof QtiVariableMappingSchema>;
+export type QtiWeight = z.infer<typeof QtiWeightSchema>;
+export type QtiContextDeclaration = z.infer<typeof QtiContextDeclarationSchema>;
+export type QtiTemplateDeclaration = z.infer<typeof QtiTemplateDeclarationSchema>;
+export type QtiResponseDeclarationRaw = z.infer<typeof QtiResponseDeclarationRawSchema>;
+export type QtiResponseDeclaration = z.infer<typeof QtiResponseDeclarationSchema>;
+export type QtiOutcomeDeclarationRaw = z.infer<typeof QtiOutcomeDeclarationRawSchema>;
+export type QtiOutcomeDeclaration = z.infer<typeof QtiOutcomeDeclarationSchema>;

package/src/shared/imsx-status.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+
+const LocaleTagSchema = z.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/u);
+const TextValueSchema = z.union([z.string(), z.record(LocaleTagSchema, z.string())]);
+
+function strictObject<T extends z.ZodRawShape>(shape: T) {
+  return z.object(shape).strict();
+}
+
+export const ImsxCodeMajorSchema = z.enum(["failure", "processing", "success", "unsupported"]);
+export const ImsxSeveritySchema = z.enum(["error", "status", "warning"]);
+export const ImsxCodeMinorFieldValueSchema = z.enum([
+  "forbidden",
+  "fullsuccess",
+  "internal_server_error",
+  "invalid_data",
+  "invalid_query_parameter",
+  "misdirected_request",
+  "not_acceptable",
+  "not_allowed",
+  "not_found",
+  "not_modified",
+  "server_busy",
+  "unauthorizedrequest",
+  "unknown",
+]);
+
+export const ImsxCodeMinorFieldSchema = strictObject({
+  imsx_codeMinorFieldName: TextValueSchema,
+  imsx_codeMinorFieldValue: ImsxCodeMinorFieldValueSchema,
+});
+
+export const ImsxCodeMinorSchema = strictObject({
+  imsx_codeMinorField: z.union([ImsxCodeMinorFieldSchema, z.array(ImsxCodeMinorFieldSchema).min(1)]),
+});
+
+export const ImsxStatusInfoSchema = strictObject({
+  imsx_codeMajor: ImsxCodeMajorSchema,
+  imsx_severity: ImsxSeveritySchema,
+  imsx_description: TextValueSchema.optional(),
+  imsx_codeMinor: ImsxCodeMinorSchema.optional(),
+});
+// Inferred types from exported Zod validators.
+export type ImsxCodeMajor = z.infer<typeof ImsxCodeMajorSchema>;
+export type ImsxSeverity = z.infer<typeof ImsxSeveritySchema>;
+export type ImsxCodeMinorFieldValue = z.infer<typeof ImsxCodeMinorFieldValueSchema>;
+export type ImsxCodeMinorField = z.infer<typeof ImsxCodeMinorFieldSchema>;
+export type ImsxCodeMinor = z.infer<typeof ImsxCodeMinorSchema>;
+export type ImsxStatusInfo = z.infer<typeof ImsxStatusInfoSchema>;

package/src/summary.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+
+export const RunnerSummarySchema = z.object({
+  contractVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
+  runner: z.object({
+    suite: z.string().min(1),
+    version: z.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/u),
+    profileVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
+    target: z.string().min(1),
+  }),
+  startedAt: z.iso.datetime(),
+  finishedAt: z.iso.datetime(),
+  durationMs: z.number().int().nonnegative(),
+  result: z.object({
+    status: z.enum(["passed", "failed", "error"]),
+    passed: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    skipped: z.number().int().nonnegative(),
+  }),
+  adapter: z
+    .object({
+      name: z.string().min(1),
+      version: z.string().min(1),
+      profileVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
+    })
+    .optional(),
+  artifacts: z.object({
+    summaryFile: z.string().min(1),
+    junitFile: z.string().min(1),
+    requirementTraceFile: z.string().min(1),
+    runMetadataFile: z.string().min(1),
+  }),
+});
+
+export const RequirementTraceSchema = z.object({
+  contractVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
+  runId: z.string().min(1),
+  requirements: z.record(
+    z.string().min(1),
+    z.object({
+      status: z.enum(["passed", "failed", "skipped", "error"]),
+      evidence: z.array(z.string().min(1)).default([]),
+      message: z.string().optional(),
+    }),
+  ),
+});
+
+export const RunMetadataSchema = z.object({
+  runId: z.string().min(1),
+  startedAt: z.iso.datetime(),
+  finishedAt: z.iso.datetime(),
+  image: z.object({
+    reference: z.string().min(1),
+    digest: z.string().min(1),
+    source: z.string().min(1),
+  }),
+  standards: z.object({
+    suiteSourceRevision: z.string().min(1),
+    requirementsRevision: z.string().min(1),
+    profileVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
+  }),
+  runner: z.object({
+    version: z.string().min(1),
+    revision: z.string().min(1),
+  }),
+});
+
+export type RunnerSummary = z.infer<typeof RunnerSummarySchema>;
+export type RequirementTrace = z.infer<typeof RequirementTraceSchema>;
+export type RunMetadata = z.infer<typeof RunMetadataSchema>;

package/src/vc-data-model/v2_0/index.ts

@@ -0,0 +1,27 @@
+export * from "./shared";
+
+import {
+  CredentialSchemaSchema,
+  CredentialStatusSchema,
+  CredentialSubjectSchema,
+  EvidenceSchema,
+  HolderSchema,
+  ProofSchema,
+  RefreshServiceSchema,
+  TermsOfUseSchema,
+  VerifiableCredentialSchema,
+  VerifiablePresentationSchema,
+} from "./shared";
+
+export const VcDataModel20DerivedZodTemplates = {
+  verifiableCredential: VerifiableCredentialSchema,
+  verifiablePresentation: VerifiablePresentationSchema,
+  credentialSubject: CredentialSubjectSchema,
+  credentialSchema: CredentialSchemaSchema,
+  credentialStatus: CredentialStatusSchema,
+  refreshService: RefreshServiceSchema,
+  termsOfUse: TermsOfUseSchema,
+  proof: ProofSchema,
+  evidence: EvidenceSchema,
+  holder: HolderSchema,
+} as const;