@intellectif/lk-core 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,11 +1,351 @@
-import { V as ValidationError, C as CriterionScore, A as ActivityData, G as GradeRecord, m as ItemOutcome, r as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, o as MultipleChoiceLearnerResponse, W as WrittenResponseData, u as WrittenResponseLearnerResponse } from './activity-wkzRemHx.js';
-export { a as ActivityDataMap, b as ActivityFeedback, c as ActivityMedia, d as ActivityResult, e as ActivityType, B as BlankConfig, g as Grader, h as GraderKind, i as GraderUsage, j as GradingState, I as InlineCorrection, k as InteractionEvent, l as InteractionKind, L as LearnerResponse, n as LearnerResponseMap, p as MultipleChoiceOption, S as ScoringDetail, q as ScoringOutcome, T as TextMatchPolicy, s as TextMatchResult, t as ValidationResult, v as WrittenResponseRubric, w as WrittenResponseRubricCriterion, X as XAPIActor, x as XAPIConfig, y as XAPIContext, z as XAPIContextActivities, E as XAPIError, H as XAPIObject, J as XAPIResult, K as XAPIScore, N as XAPIStatement, O as XAPIVerbObject, P as levenshteinDistance, Q as matchText } from './activity-wkzRemHx.js';
-import { S as SequenceEntry, l as SequenceSlot, I as ItemGroup } from './index-CLmXzBhB.js';
-export { B as BlankConfigSchema, F as FeedbackSchema, a as FillInTheBlanksDataSchema, b as ItemGroupSchema, M as MediaSchema, c as MediaUrlSchema, d as MultipleChoiceDataSchema, e as MultipleChoiceOptionSchema, R as RedactedBlankConfigSchema, f as RedactedFillInTheBlanksDataSchema, g as RedactedItemGroupSchema, h as RedactedMultipleChoiceDataSchema, i as RedactedMultipleChoiceOptionSchema, j as RedactedStimulusSchema, k as RedactedWrittenResponseDataSchema, m as SequenceSlotGroup, n as Stimulus, o as StimulusKind, p as StimulusSchema, T as TextMatchPolicySchema, W as WrittenResponseDataSchema, q as WrittenResponseRubricCriterionSchema, r as WrittenResponseRubricSchema, s as fillInTheBlanksJsonSchema, t as itemGroupJsonSchema, u as jsonSchemaFor, v as multipleChoiceJsonSchema, w as stimulusJsonSchema, x as validateActivity, y as validateItemGroup, z as writtenResponseJsonSchema } from './index-CLmXzBhB.js';
+import { ScoredItem } from './scoring.js';
+export { AssessmentScore, AssessmentSectionInput, Band, CompositionPolicy, DEFAULT_PASS_THRESHOLD, PassFailureReason, RoundingMode, RoundingPolicy, SectionScore, classifyBand, composeAssessmentScore, computePassThreshold, evaluate, gte, roundGrade, score } from './scoring.js';
+import { m as ItemOutcome, A as ActivityData, L as LearnerResponse, V as ValidationError, C as CriterionScore, G as GradeRecord, r as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, o as MultipleChoiceLearnerResponse, W as WrittenResponseData, u as WrittenResponseLearnerResponse } from './activity-gelWNZ6V.js';
+export { a as ActivityDataMap, b as ActivityFeedback, c as ActivityMedia, d as ActivityResult, e as ActivityType, B as BlankConfig, g as Grader, h as GraderKind, i as GraderUsage, j as GradingState, I as InlineCorrection, k as InteractionEvent, l as InteractionKind, n as LearnerResponseMap, p as MultipleChoiceOption, S as ScoringDetail, q as ScoringOutcome, T as TextMatchPolicy, s as TextMatchResult, t as ValidationResult, v as WrittenResponseRubric, w as WrittenResponseRubricCriterion, X as XAPIActor, x as XAPIConfig, y as XAPIContext, z as XAPIContextActivities, E as XAPIError, H as XAPIObject, J as XAPIResult, K as XAPIScore, N as XAPIStatement, O as XAPIVerbObject, P as levenshteinDistance, Q as matchText } from './activity-gelWNZ6V.js';
+import { s as SequenceSlot, S as SequenceEntry, I as ItemGroup } from './index-B_RLyeEj.js';
+export { B as BlankConfigSchema, F as FeedbackSchema, a as FillInTheBlanksDataSchema, b as ItemGroupSchema, M as MediaSchema, c as MediaUrlSchema, d as MultipleChoiceDataSchema, e as MultipleChoiceOptionSchema, R as RedactedActivity, f as RedactedBlankConfig, g as RedactedBlankConfigSchema, h as RedactedFillInTheBlanksData, i as RedactedFillInTheBlanksDataSchema, j as RedactedItemGroupSchema, k as RedactedMultipleChoiceData, l as RedactedMultipleChoiceDataSchema, m as RedactedMultipleChoiceOption, n as RedactedMultipleChoiceOptionSchema, o as RedactedStimulus, p as RedactedStimulusSchema, q as RedactedWrittenResponseData, r as RedactedWrittenResponseDataSchema, t as SequenceSlotGroup, u as Stimulus, v as StimulusKind, w as StimulusSchema, T as TextMatchPolicySchema, W as WrittenResponseDataSchema, x as WrittenResponseRubricCriterionSchema, y as WrittenResponseRubricSchema, z as fillInTheBlanksJsonSchema, A as itemGroupJsonSchema, C as jsonSchemaFor, D as multipleChoiceJsonSchema, E as stimulusJsonSchema, G as validateActivity, H as validateItemGroup, J as writtenResponseJsonSchema } from './index-B_RLyeEj.js';
 import { z } from 'zod/v4';
-export { AssessmentScore, AssessmentSectionInput, Band, CompositionPolicy, DEFAULT_PASS_THRESHOLD, PassFailureReason, RoundingMode, RoundingPolicy, ScoredItem, SectionScore, classifyBand, composeAssessmentScore, computePassThreshold, evaluate, gte, roundGrade, score } from './scoring.js';
 export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor } from './xapi.js';
 
+/**
+ * The frozen record of what one attempt was served.
+ *
+ * A sequence definition is live content: it gets edited, re-ordered, corrected.
+ * An attempt is a historical fact. Everything that decides a grade — which
+ * questions, in what order, each worth how much, against which version of the
+ * content — has to be pinned at the moment the attempt starts, or a re-grade
+ * six months later silently answers a different question than the learner was
+ * asked.
+ *
+ * This is the thing you persist next to the responses.
+ */
+/** One planned position: an item, its identity, its worth, and its fingerprint. */
+interface AttemptPlanSlot {
+    /**
+     * Slot identity, from `flattenSequence`. Stable under shuffling; stable
+     * under editing too when the entries declare `slotKey`. This is the key to
+     * store responses and scores against.
+     */
+    slotId: string;
+    /** 0-based PRESENTED position in this attempt. */
+    index: number;
+    /** The activity that filled the slot. */
+    activityId: string;
+    /** The activity's `type` discriminator. */
+    activityType: string;
+    /**
+     * What this slot is worth, frozen. Points belong to the PAPER, not the item:
+     * the same question can be worth 1 in a quiz and 3 in a final, so they are
+     * resolved when the attempt is planned and never read from content again.
+     */
+    points: number;
+    /**
+     * Fingerprint of the activity's content as served. Compare it later with
+     * {@link verifyAttemptPlan} to find out whether the item has been edited
+     * since — the difference between "re-grading this attempt" and "grading a
+     * different exam".
+     */
+    contentHash: string;
+    /** Present when the slot came from an item group. */
+    group?: {
+        id: string;
+        title?: string;
+        /** Fingerprint of the stimulus as served — a corrected passage changes the question. */
+        stimulusHash: string;
+    };
+}
+/** Everything needed to reproduce and re-grade one attempt. */
+interface AttemptPlan {
+    /** Version of this envelope, so a stored plan stays readable as it evolves. */
+    planVersion: '1.0';
+    /**
+     * The seed every shuffle in this attempt used, when anything shuffled.
+     * Absent means nothing was shuffled and the order is the authored one.
+     */
+    seed?: string;
+    /**
+     * Whether the top-level entries were shuffled. Recorded because
+     * {@link verifyAttemptPlan} needs to rebuild the SAME presented order: a
+     * re-plan that omitted this returned authored order, every slot compared as
+     * re-ordered, and unchanged content reported as drift.
+     */
+    shuffleEntries?: boolean;
+    /**
+     * Fingerprint of the whole plan's content — every slot's identity, order,
+     * points and content hash. One value to store against an attempt and compare
+     * later; the per-slot hashes then say WHICH item moved.
+     */
+    planHash: string;
+    slots: AttemptPlanSlot[];
+    /** Sum of every slot's `points`, frozen. The denominator of the paper. */
+    totalPoints: number;
+}
+/** What {@link verifyAttemptPlan} found when a plan met current content. */
+interface AttemptPlanDrift {
+    /** True when the plan and the content still agree in every respect. */
+    matches: boolean;
+    /** Slots in the plan that no longer exist in the content at all. */
+    missingSlotIds: string[];
+    /** Slots present now that the plan never held — content added since. */
+    addedSlotIds: string[];
+    /** Slots whose activity content has been edited since the attempt. */
+    changedSlotIds: string[];
+    /** Slots whose item group's stimulus has been edited since the attempt. */
+    changedStimulusSlotIds: string[];
+    /**
+     * Slots now worth a different number of points. A reweight is a paper
+     * change — it moves the grade without touching a single question — so it
+     * cannot be left out of a remark or an appeal.
+     */
+    changedPointsSlotIds: string[];
+    /** Slots presented at a different position now than they were then. */
+    reorderedSlotIds: string[];
+}
+
+/** Options for {@link planAttempt}. */
+interface PlanAttemptOptions<TItem> {
+    /** Shuffle the top-level entries. A group moves as one block. */
+    shuffleEntries?: boolean;
+    /**
+     * Seed for every shuffle in this attempt. Required whenever anything
+     * shuffles — the attempt has to be reproducible, which is the entire point
+     * of writing a plan down. Use the attempt id.
+     */
+    seed?: string;
+    /**
+     * What each slot is worth. Defaults to 1 for every slot.
+     *
+     * Points are resolved HERE, not read from content, because they belong to
+     * the paper rather than the item: the same question is worth 1 in a practice
+     * quiz and 3 in a final. Whatever this returns is frozen into the plan and
+     * is what `composeAssessmentScore` will weight by.
+     *
+     * @throws Error when it returns a value that is not a finite, non-negative
+     *         number — a slot worth `NaN` points would poison the whole total.
+     */
+    points?: (slot: SequenceSlot<TItem>) => number;
+}
+/**
+ * Freezes what an attempt is being served: the presented order, each slot's
+ * identity and worth, and a fingerprint of the content behind it.
+ *
+ * Call this once, when the attempt starts, and store the result beside the
+ * responses. Everything that decides the grade is then a historical fact
+ * rather than a re-read of content that may since have changed — which is what
+ * makes a re-grade, a remark or an appeal answerable.
+ *
+ * Ordering comes from `flattenSequence`, so a plan and a live render of the
+ * same entries with the same seed agree slot for slot.
+ *
+ * @throws Error when a shuffle is requested without a seed, when a group is
+ *         empty, when two entries collide on a `slotKey`, or when `points`
+ *         returns a value that is not finite and non-negative.
+ */
+declare function planAttempt<TItem extends {
+    id: string;
+    type: string;
+}>(entries: readonly SequenceEntry<TItem>[], options?: PlanAttemptOptions<TItem>): AttemptPlan;
+/**
+ * Compares a stored plan with the content as it stands now, and reports every
+ * way they have drifted apart.
+ *
+ * This is the question a remark or an appeal actually asks: *is the paper I am
+ * looking at the paper this learner sat?* Ids alone cannot answer it, because
+ * they survive an edit unchanged.
+ *
+ * Rebuild the comparison plan with the SAME options the stored one recorded —
+ * its `seed`, its `shuffleEntries`, and the same `points` function — or the
+ * differences you see will be your own:
+ *
+ * ```ts
+ * const now = planAttempt(currentEntries, {
+ *   seed: stored.seed,
+ *   shuffleEntries: stored.shuffleEntries,
+ *   points: pointsFor,          // omit it and every slot reweights to 1
+ * });
+ * const drift = verifyAttemptPlan(stored, now);
+ * ```
+ *
+ * A drift is not automatically a problem — a fixed typo changes a hash without
+ * changing what was asked. It is a fact somebody has to be able to see.
+ */
+declare function verifyAttemptPlan(plan: AttemptPlan, current: AttemptPlan): AttemptPlanDrift;
+/** How {@link scoredItemsFromPlan} fills a slot that has no recorded outcome. */
+type MissingOutcomePolicy = 
+/**
+ * Default. `{ status: 'deferred', reason: 'no_response_recorded' }` — a
+ * non-terminal state, so the composed result stays `provisional` and cannot
+ * be recorded as a final pass or fail.
+ */
+'deferred'
+/**
+ * `{ status: 'scored', score: 0 }` — the learner left it blank on a paper
+ * that IS complete. Choose this only when you know the attempt was
+ * submitted; it is a real zero and makes the result final.
+ */
+ | 'zero'
+/** Build the outcome yourself, per slot. */
+ | ((slot: AttemptPlanSlot) => ItemOutcome);
+/**
+ * Turns a plan plus whatever outcomes exist into the `ScoredItem[]`
+ * `composeAssessmentScore` consumes.
+ *
+ * The plan is the source of the denominator, not the outcomes. A slot the
+ * learner never reached still has to appear — otherwise it silently leaves the
+ * denominator and the remaining questions quietly become worth more than the
+ * paper says.
+ *
+ * **A missing outcome defaults to `deferred`, never `unscorable`.** The
+ * distinction decides a grade: `unscorable` means "a grade is never coming",
+ * so `composeAssessmentScore` drops the slot from the denominator AND lets the
+ * result go `final` — which turned a three-question paper with one answer into
+ * a final, passing 100%. `deferred` means "not yet", which holds the result
+ * `provisional` so nothing can be recorded. Pass `'zero'` once you know the
+ * attempt was submitted and the blanks are genuinely blanks.
+ *
+ * Pass outcomes keyed by `slotId`. Keys the plan does not know are ignored:
+ * a plan is the authority on what the attempt contained.
+ */
+declare function scoredItemsFromPlan(plan: AttemptPlan, outcomes: Readonly<Record<string, ItemOutcome>>, options?: {
+    missing?: MissingOutcomePolicy;
+}): ScoredItem[];
+/** Convenience alias: the entry type a plan is built from. */
+type PlannableEntry = SequenceEntry<ActivityData>;
+
+/**
+ * A resumable snapshot of an attempt in progress.
+ *
+ * The plan says what the learner was asked; this says how far they got. It is
+ * deliberately the smallest thing that can reopen an attempt exactly where it
+ * was left: the answers so far, which of them are already submitted, and where
+ * the learner was standing.
+ *
+ * It is bound to a plan by {@link AttemptState.planHash}, because restoring
+ * answers onto a DIFFERENT paper is the failure this type exists to prevent —
+ * slot ids alone would happily line up against the wrong questions.
+ */
+interface AttemptState {
+    /** Version of this envelope, so a stored snapshot stays readable as it evolves. */
+    stateVersion: '1.0';
+    /**
+     * `planHash` of the {@link AttemptPlan} this state belongs to. `restoreAttemptState`
+     * refuses a plan that does not match, rather than restoring a learner's
+     * answers onto a paper they never sat.
+     */
+    planHash: string;
+    /** The learner's answers so far, keyed by `slotId`. */
+    responses: Record<string, LearnerResponse>;
+    /**
+     * Slots the learner has already submitted. Kept apart from `responses`
+     * because they answer different questions: what did they write, and may they
+     * still change it.
+     */
+    submittedSlotIds: string[];
+    /** Presented position the learner was on, so a resume reopens there. */
+    index: number;
+    /** ISO 8601 timestamp of the snapshot, when the caller supplies one. */
+    savedAt?: string;
+}
+/** One slot whose response differs between two snapshots. */
+interface ResponseDiffEntry {
+    slotId: string;
+    /** `added` — answered since; `removed` — cleared; `changed` — a different answer. */
+    change: 'added' | 'removed' | 'changed';
+    before?: LearnerResponse;
+    after?: LearnerResponse;
+}
+
+/** What {@link serializeAttemptState} is given about an attempt in progress. */
+interface AttemptProgress {
+    /** Answers so far, keyed by `slotId`. */
+    responses: Readonly<Record<string, LearnerResponse>>;
+    /** Slots already submitted. Defaults to none. */
+    submittedSlotIds?: readonly string[];
+    /** Presented position the learner is on. Defaults to 0. */
+    index?: number;
+    /** ISO 8601 timestamp to stamp the snapshot with. The SDK does not read a clock. */
+    savedAt?: string;
+}
+/**
+ * Captures an in-progress attempt as a storable snapshot, bound to its plan.
+ *
+ * Validated against the plan on the way in, not on the way out: a response
+ * stored under a slot the paper does not contain is a bug at the moment it is
+ * written, and finding it months later — when a learner tries to resume — is
+ * finding it far too late.
+ *
+ * The SDK reads no clock: pass `savedAt` if you want the snapshot stamped, so
+ * the function stays pure and its output stays reproducible in a test.
+ *
+ * @throws Error when a response or submitted slot is not in the plan, or when
+ *         `index` is not a position the plan actually has.
+ */
+declare function serializeAttemptState(plan: AttemptPlan, progress: AttemptProgress): AttemptState;
+/**
+ * Reopens a stored snapshot against a plan, refusing anything that does not
+ * belong to it.
+ *
+ * The `planHash` check is the point. Slot ids are short and stable by design,
+ * so a snapshot from a DIFFERENT paper — last term's midterm, a sibling
+ * version, a copy-pasted attempt row — will happily line its answers up
+ * against the wrong questions and look entirely plausible doing it. Comparing
+ * the paper's fingerprint is what makes that impossible rather than unlikely.
+ *
+ * @throws Error when the snapshot belongs to a different plan, or references
+ *         slots the plan does not contain.
+ */
+declare function restoreAttemptState(plan: AttemptPlan, state: AttemptState): AttemptState;
+/**
+ * Reports how two snapshots' responses differ, slot by slot.
+ *
+ * Useful for an autosave that should only write what moved, and for an audit
+ * trail that has to show what a learner changed between two saves — including
+ * an answer they cleared, which a naive comparison of the later snapshot
+ * alone cannot see.
+ *
+ * Entries come back sorted by `slotId`, so the output is stable regardless of
+ * the order the two objects happened to be written in.
+ */
+declare function diffResponses(before: Pick<AttemptState, 'responses'>, after: Pick<AttemptState, 'responses'>): ResponseDiffEntry[];
+
+/**
+ * Content fingerprinting — "is this the same content the learner was served?"
+ *
+ * A recorded attempt outlives the content it was taken against. Papers get
+ * corrected, a typo is fixed, an option is reworded — and six months later a
+ * remark, an appeal, or a per-item analysis is run against content that is no
+ * longer what the learner saw. Nothing warns anybody, because the ids all still
+ * match. A fingerprint stored with the attempt turns that silent drift into a
+ * question somebody can answer.
+ */
+/**
+ * Deterministic JSON: object keys sorted, arrays left in order, `undefined`
+ * omitted from objects (matching `JSON.stringify`) and rendered as `null`
+ * inside arrays.
+ *
+ * Key order is the whole point. Two objects that differ only in the order
+ * their keys happened to be written are the SAME content, and a fingerprint
+ * that disagreed would raise a false alarm every time a payload made a
+ * round-trip through a different serializer.
+ */
+declare function canonicalJson(value: unknown, seen?: Set<object>): string;
+/**
+ * FNV-1a over the UTF-8 bytes of `input`, as 16 lowercase hex digits.
+ *
+ * **This is a change-detection fingerprint, not a tamper-evident signature.**
+ * It is deterministic across runtimes and dependency-free, which is what makes
+ * it usable in a stored grade record — but an adversary who can edit content
+ * can also, with effort, preserve the fingerprint. If you need the stronger
+ * property, sign the plan with a key the content author does not hold; this
+ * exists to catch honest edits, which is what actually happens.
+ */
+declare function fingerprint(input: string): string;
+/**
+ * Fingerprints any JSON-serialisable value through {@link canonicalJson}, so
+ * the result depends on the content and not on how it was written.
+ */
+declare function contentHash(value: unknown): string;
+
 /**
  * Canonical word counter for written-response bounds (Req 22.9): tokens are
  * maximal runs of non-whitespace (split on `\s+`), so hyphenated forms
@@ -75,6 +415,20 @@ interface GradeFromRubricOptions {
  * marked `notApplicable`, and those carrying no numeric `score` (a purely
  * banded judgement), are excluded from both numerator and denominator. When
  * nothing scoreable remains the result is `unscorable`, never a zero.
+ *
+ * Scores need not be in [0,1]: set `maxScore` on a criterion to declare what
+ * its score is out of, and each is normalised before weighting. A grader
+ * working out of 100 says so and is done:
+ *
+ * ```ts
+ * gradeFromRubric([
+ *   { name: 'Task achievement', score: 82, maxScore: 100, weight: 2 },
+ *   { name: 'Range',            score: 7,  maxScore: 9,   weight: 1 },
+ * ]);
+ * ```
+ *
+ * The returned `GradeRecord.score` is always scaled [0,1] against
+ * `maxScore: 1`, like every other score in the SDK.
  */
 declare function gradeFromRubric(criteria: readonly CriterionScore[], activityData?: ActivityData, options?: GradeFromRubricOptions): GradeRecord | {
     unscorable: true;
@@ -475,4 +829,4 @@ interface ThemeTokens {
     '--lk-transition-base': string;
 }
 
-export { ActivityData, ActivitySchemaError, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, CriterionScore, DeferredScoringError, DeferredScoringPartial, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type FlattenSequenceOptions, type GradeFromRubricOptions, GradeRecord, ItemGroup, ItemOutcome, MultipleChoiceData, MultipleChoiceLearnerResponse, type PartialScoringResult, type RedactOptions, type RedactedActivityData, type RedactedItemGroup, RedactedScoringError, type RegisteredActivityTypeDescriptor, ScoringResult, type SeededShuffleOptions, type Sensitivity, SequenceEntry, SequenceSlot, type ShuffleVersion, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, assertRedacted, assertRedactedItemGroup, countWords, defineActivityType, fillInTheBlanksType, flattenSequence, getActivityTypeDescriptor, gradeFromRubric, hasGrade, hashSeed, isItemGroup, multipleChoiceType, outcomeFromGrade, redact, redactItemGroup, registerActivityType, registeredActivityTypes, seededShuffle, writtenResponseType };
+export { ActivityData, ActivitySchemaError, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, type AttemptPlan, type AttemptPlanDrift, type AttemptPlanSlot, type AttemptProgress, type AttemptState, CriterionScore, DeferredScoringError, DeferredScoringPartial, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type FlattenSequenceOptions, type GradeFromRubricOptions, GradeRecord, ItemGroup, ItemOutcome, LearnerResponse, type MissingOutcomePolicy, MultipleChoiceData, MultipleChoiceLearnerResponse, type PartialScoringResult, type PlanAttemptOptions, type PlannableEntry, type RedactOptions, type RedactedActivityData, type RedactedItemGroup, RedactedScoringError, type RegisteredActivityTypeDescriptor, type ResponseDiffEntry, ScoredItem, ScoringResult, type SeededShuffleOptions, type Sensitivity, SequenceEntry, SequenceSlot, type ShuffleVersion, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, assertRedacted, assertRedactedItemGroup, canonicalJson, contentHash, countWords, defineActivityType, diffResponses, fillInTheBlanksType, fingerprint, flattenSequence, getActivityTypeDescriptor, gradeFromRubric, hasGrade, hashSeed, isItemGroup, multipleChoiceType, outcomeFromGrade, planAttempt, redact, redactItemGroup, registerActivityType, registeredActivityTypes, restoreAttemptState, scoredItemsFromPlan, seededShuffle, serializeAttemptState, verifyAttemptPlan, writtenResponseType };