@intellectif/lk-core 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 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 { z } from 'zod/v4';
-export { BlankConfigSchema, FeedbackSchema, FillInTheBlanksDataSchema, MediaSchema, MediaUrlSchema, MultipleChoiceDataSchema, MultipleChoiceOptionSchema, RedactedBlankConfigSchema, RedactedFillInTheBlanksDataSchema, RedactedMultipleChoiceDataSchema, RedactedMultipleChoiceOptionSchema, RedactedWrittenResponseDataSchema, TextMatchPolicySchema, WrittenResponseDataSchema, WrittenResponseRubricCriterionSchema, WrittenResponseRubricSchema, fillInTheBlanksJsonSchema, jsonSchemaFor, multipleChoiceJsonSchema, validateActivity, writtenResponseJsonSchema } from './schemas.js';
 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 } from './xapi.js';
+export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder, xapiDefinitionFor } from './xapi.js';
 
 /**
  * Canonical word counter for written-response bounds (Req 22.9): tokens are
@@ -95,6 +96,46 @@ declare function hasGrade(outcome: ItemOutcome): outcome is Extract<ItemOutcome,
     status: 'scored' | 'graded';
 }>;
 
+/** Narrows a sequence entry to an item group. */
+declare function isItemGroup<TItem extends {
+    type: string;
+}>(entry: SequenceEntry<TItem>): entry is ItemGroup<TItem>;
+/** Options for {@link flattenSequence}. */
+interface FlattenSequenceOptions {
+    /**
+     * Shuffle the top-level entries. A group moves as ONE block — its items are
+     * never interleaved with other entries — which is the reason a group exists
+     * as a container rather than as a flag on each item.
+     */
+    shuffleEntries?: boolean;
+    /**
+     * Seed for every shuffle in this call: the entries, and each group whose
+     * `shuffle` is `within-group`. REQUIRED whenever anything shuffles. The SDK
+     * never invents one, because the server that stores an attempt and the
+     * client that renders it must derive the SAME order, and only a shared seed
+     * makes that true. The attempt id is the natural choice.
+     */
+    seed?: string;
+}
+/**
+ * Turns a sequence definition — loose activities and item groups, in authored
+ * order — into the ordered list of slots to present. Pure and deterministic:
+ * call it on the server to record an attempt's order, and on the client to
+ * render it, and the two agree.
+ *
+ * Shuffling is opt-in and seeded. Groups are shuffle-atomic: with
+ * `shuffleEntries` a group changes position but stays one contiguous block,
+ * and only a group that declares `shuffle: 'within-group'` has its items
+ * reordered. Every slot carries a `slotId` derived from the authored
+ * position, so identities survive shuffling.
+ *
+ * @throws Error when a shuffle is requested without a `seed`.
+ */
+declare function flattenSequence<TItem extends {
+    id: string;
+    type: string;
+}>(entries: readonly SequenceEntry<TItem>[], options?: FlattenSequenceOptions): SequenceSlot<TItem>[];
+
 /** ScoringResult without `passed` — the public `score()` / `evaluate()` fill that in. */
 type PartialScoringResult = Omit<ScoringResult, 'passed'>;
 /**
@@ -295,6 +336,32 @@ declare function redact<T extends {
  * that must not hold the key.
  */
 declare function assertRedacted(data: unknown): asserts data is RedactedActivityData;
+/** A learner-safe item group: the container with its marker, holding `redact()` projections. */
+type RedactedItemGroup = ItemGroup<RedactedActivityData> & {
+    redacted: true;
+};
+/**
+ * Produces the learner-safe projection of an item group: the container and
+ * stimulus under their own fail-closed policy (the author transcript goes;
+ * the passage, media and attribution stay — the learner is meant to see
+ * them), and every item through {@link redact} with the same `options`, so
+ * a per-call `policy` tightens each item exactly as it would alone.
+ *
+ * With the default `reveal: 'none'` the container is verified against the
+ * strict redacted schema; each item was already verified by `redact`.
+ */
+declare function redactItemGroup<TItem extends {
+    type: string;
+}>(group: ItemGroup<TItem>, options?: RedactOptions): RedactedItemGroup;
+/**
+ * Asserts that `data` is a learner-safe item group: it carries the marker,
+ * its container and stimulus satisfy the strict redacted schema (so no
+ * transcript, no unclassified field), and EVERY item passes
+ * {@link assertRedacted} against its own type's redacted schema. Item
+ * failures are reported at `items.<index>.…`. Use it at the server boundary
+ * before sending a group to a client that must not hold the key.
+ */
+declare function assertRedactedItemGroup(data: unknown): asserts data is RedactedItemGroup;
 
 /** Built-in Multiple Choice descriptor. */
 declare const multipleChoiceType: ActivityTypeDescriptor<MultipleChoiceData, MultipleChoiceLearnerResponse>;
@@ -309,6 +376,69 @@ declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, F
  */
 declare const writtenResponseType: ActivityTypeDescriptor<WrittenResponseData, WrittenResponseLearnerResponse>;
 
+/**
+ * Seeded, deterministic shuffling — the ONE algorithm every presentation-order
+ * decision in the SDK goes through: option order in a multiple-choice item,
+ * item order inside an item group, entry order in a sequence. A server and a
+ * client holding the same seed derive the same order, and an order recorded
+ * against an attempt can be rebuilt later from nothing but its seed.
+ *
+ * STABILITY: the hash and the generator are part of the wire contract. A
+ * stored attempt may hold only a seed and rely on this function to reproduce
+ * the order it presented; changing either would silently re-order every
+ * recorded attempt. Any change here is a package major, and the pinned
+ * permutation test exists so an accidental one fails loudly.
+ */
+/** FNV-1a hash of a string → unsigned 32-bit integer. */
+declare function hashSeed(input: string): number;
+/**
+ * Which draw the Fisher–Yates step uses.
+ *
+ * - `1` — the original. Takes the index from the LCG's LOW bits (`s % (i+1)`).
+ * - `2` — takes it from the HIGH bits. Same LCG, same seed, different draw.
+ *
+ * The difference is not cosmetic. In a linear congruential generator with a
+ * power-of-two modulus, the low bits have drastically short periods: bit 0
+ * alternates, bit 1 has period 4, and so on. `% (i+1)` reads exactly those
+ * bits, so consecutive draws are correlated and most permutations become
+ * unreachable FOR EVERY SEED THAT WILL EVER EXIST:
+ *
+ * | items | permutations | reachable under v1 | under v2 |
+ * | ----- | ------------ | ------------------ | -------- |
+ * | 4     | 24           | 12                 | 24       |
+ * | 5     | 120          | 60                 | 120      |
+ * | 6     | 720          | 180                | 720      |
+ *
+ * It also biases WHERE an option lands. On a four-option item under v1 the
+ * last authored option takes the first presented position 8.3% of the time
+ * and the second position 41.7%, against 25% each — a systematic advantage to
+ * anyone who notices. For a summative exam that is a fairness defect, not a
+ * curiosity.
+ *
+ * v1 remains the DEFAULT regardless, because these permutations are a wire
+ * contract: an attempt may be stored with nothing but its seed, and a review
+ * render of that attempt has to reproduce the order the learner actually saw.
+ * Switching the default would silently re-order every recorded attempt, so it
+ * is a package major — scheduled, not smuggled in. Choose v2 for new content
+ * where no attempt has been recorded yet.
+ */
+type ShuffleVersion = 1 | 2;
+/** Options for {@link seededShuffle}. */
+interface SeededShuffleOptions {
+    /** Draw algorithm. Defaults to `1` — see {@link ShuffleVersion}. */
+    version?: ShuffleVersion;
+}
+/**
+ * Returns a new array holding a permutation of `items` determined entirely by
+ * `seed` (and the chosen {@link ShuffleVersion}): same inputs, same order —
+ * across processes, runtimes and releases. The input is never mutated.
+ *
+ * Compose the seed from the attempt identity AND the thing being shuffled
+ * (`${attemptId}:${itemId}`), so two shuffles in one attempt do not share an
+ * order.
+ */
+declare function seededShuffle<T>(items: readonly T[], seed: string, options?: SeededShuffleOptions): T[];
+
 /**
  * All CSS custom property tokens consumed by learning-kit components.
  * Every key maps to a `--lk-*` CSS variable name; every value is a CSS value string.
@@ -345,4 +475,4 @@ interface ThemeTokens {
     '--lk-transition-base': string;
 }
 
-export { ActivityData, ActivitySchemaError, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, CriterionScore, DeferredScoringError, DeferredScoringPartial, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, type GradeFromRubricOptions, GradeRecord, ItemOutcome, MultipleChoiceData, MultipleChoiceLearnerResponse, type PartialScoringResult, type RedactOptions, type RedactedActivityData, RedactedScoringError, type RegisteredActivityTypeDescriptor, ScoringResult, type Sensitivity, type ThemeTokens, UnknownActivityTypeError, ValidationError, WrittenResponseData, WrittenResponseLearnerResponse, type XAPIInteractionType, assertRedacted, countWords, defineActivityType, fillInTheBlanksType, getActivityTypeDescriptor, gradeFromRubric, hasGrade, multipleChoiceType, outcomeFromGrade, redact, registerActivityType, registeredActivityTypes, writtenResponseType };
+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 };

package/dist/index.js

@@ -10,22 +10,32 @@ import {
   outcomeFromGrade,
   roundGrade,
   score
-} from "./chunk-A6JXV5GP.js";
+} from "./chunk-DUQVGLQ3.js";
 import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
-  xAPIBuilder
-} from "./chunk-APDLWLYD.js";
+  xAPIBuilder,
+  xapiDefinitionFor
+} from "./chunk-WV5WQ3SZ.js";
 import {
+  ItemGroupSchema,
+  RedactedItemGroupSchema,
+  RedactedStimulusSchema,
+  StimulusSchema,
   fillInTheBlanksJsonSchema,
+  itemGroupJsonSchema,
   jsonSchemaFor,
   multipleChoiceJsonSchema,
+  stimulusJsonSchema,
   validateActivity,
+  validateItemGroup,
   writtenResponseJsonSchema
-} from "./chunk-55O4M45K.js";
+} from "./chunk-LSHDNA2T.js";
 import {
+  ActivitySchemaError,
   BlankConfigSchema,
+  DeferredScoringError,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   MediaSchema,
@@ -36,8 +46,10 @@ import {
   RedactedFillInTheBlanksDataSchema,
   RedactedMultipleChoiceDataSchema,
   RedactedMultipleChoiceOptionSchema,
+  RedactedScoringError,
   RedactedWrittenResponseDataSchema,
   TextMatchPolicySchema,
+  UnknownActivityTypeError,
   WrittenResponseDataSchema,
   WrittenResponseRubricCriterionSchema,
   WrittenResponseRubricSchema,
@@ -51,13 +63,77 @@ import {
   registerActivityType,
   registeredActivityTypes,
   writtenResponseType
-} from "./chunk-5GJJHGY5.js";
-import {
-  ActivitySchemaError,
-  DeferredScoringError,
-  RedactedScoringError,
-  UnknownActivityTypeError
-} from "./chunk-3YAVDV5F.js";
+} from "./chunk-NUCEUU4P.js";
+
+// src/shuffle.ts
+function hashSeed(input) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < input.length; i += 1) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+function shuffleWithSeed(items, seed, version) {
+  const out = [...items];
+  let s = seed >>> 0 || 1;
+  for (let i = out.length - 1; i > 0; i -= 1) {
+    s = Math.imul(s, 1664525) + 1013904223 >>> 0;
+    const j = version === 2 ? Math.floor(s / 4294967296 * (i + 1)) : s % (i + 1);
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+function seededShuffle(items, seed, options = {}) {
+  return shuffleWithSeed(items, hashSeed(seed), options.version ?? 1);
+}
+
+// src/item-group.ts
+function isItemGroup(entry) {
+  return entry.type === "item-group";
+}
+function flattenSequence(entries, options = {}) {
+  const shuffleEntries = options.shuffleEntries === true;
+  const needsSeed = shuffleEntries || entries.some((entry) => isItemGroup(entry) && entry.shuffle === "within-group");
+  if (needsSeed && options.seed === void 0) {
+    throw new Error(
+      'flattenSequence: a seed is required when shuffling (shuffleEntries, or a group with shuffle: "within-group"). Pass the attempt id so the server and the client derive the same order.'
+    );
+  }
+  const seed = options.seed ?? "";
+  const authored = entries.map((entry, entryIndex) => ({ entry, entryIndex }));
+  const ordered = shuffleEntries ? seededShuffle(authored, `${seed}:entries`) : authored;
+  const slots = [];
+  for (const { entry, entryIndex } of ordered) {
+    if (!isItemGroup(entry)) {
+      slots.push({ slotId: String(entryIndex), index: slots.length, activity: entry });
+      continue;
+    }
+    if (entry.items.length === 0) {
+      throw new Error(
+        `flattenSequence: item group "${entry.id}" has no items. An empty group would silently remove its stimulus and its questions from the presented sequence.`
+      );
+    }
+    const items = entry.items.map((item, itemIndex) => ({ item, itemIndex }));
+    const presented = entry.shuffle === "within-group" ? seededShuffle(items, `${seed}:group:${entry.id}`) : items;
+    const size = presented.length;
+    presented.forEach(({ item, itemIndex }, position) => {
+      slots.push({
+        slotId: `${entryIndex}.${itemIndex}`,
+        index: slots.length,
+        activity: item,
+        group: {
+          id: entry.id,
+          ...entry.title !== void 0 ? { title: entry.title } : {},
+          stimulus: entry.stimulus,
+          position,
+          size
+        }
+      });
+    });
+  }
+  return slots;
+}
 
 // src/redact.ts
 function mergePolicy(base, overrides) {
@@ -181,6 +257,93 @@ function assertRedacted(data) {
     );
   }
 }
+var STIMULUS_FIELD_POLICY = {
+  id: "public",
+  kind: "public",
+  title: "public",
+  body: "public",
+  bodyHtml: "public",
+  media: "public",
+  locale: "public",
+  attribution: "public",
+  transcript: "author-only"
+};
+var ITEM_GROUP_FIELD_POLICY = {
+  schemaVersion: "public",
+  type: "public",
+  id: "public",
+  title: "public",
+  shuffle: "public",
+  stimulus: STIMULUS_FIELD_POLICY
+};
+function redactItemGroup(group, options = {}) {
+  const reveal = options.reveal ?? "none";
+  const { items, ...container } = group;
+  const projected = redactValue(container, ITEM_GROUP_FIELD_POLICY, reveal);
+  const result = {
+    ...projected,
+    items: items.map((item) => redact(item, options)),
+    redacted: true
+  };
+  if (reveal === "none") {
+    const parsed = RedactedItemGroupSchema.safeParse(result);
+    if (!parsed.success) {
+      throw new ActivitySchemaError(
+        "item-group",
+        parsed.error.issues.map((issue) => ({
+          path: issue.path.map(String),
+          message: issue.message,
+          code: issue.code
+        }))
+      );
+    }
+  }
+  return result;
+}
+function assertRedactedItemGroup(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new ActivitySchemaError("item-group", [
+      { path: [], message: "Redacted item group must be an object.", code: "invalid_type" }
+    ]);
+  }
+  const candidate = data;
+  if (candidate.redacted !== true) {
+    throw new ActivitySchemaError("item-group", [
+      {
+        path: ["redacted"],
+        message: "Missing redacted marker \u2014 this payload is not a redactItemGroup() projection.",
+        code: "custom"
+      }
+    ]);
+  }
+  const parsed = RedactedItemGroupSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new ActivitySchemaError(
+      "item-group",
+      parsed.error.issues.map((issue) => ({
+        path: issue.path.map(String),
+        message: issue.message,
+        code: issue.code
+      }))
+    );
+  }
+  parsed.data.items.forEach((item, index) => {
+    try {
+      assertRedacted(item);
+    } catch (error) {
+      if (error instanceof ActivitySchemaError) {
+        throw new ActivitySchemaError(
+          "item-group",
+          error.errors.map((issue) => ({
+            ...issue,
+            path: ["items", String(index), ...issue.path]
+          }))
+        );
+      }
+      throw error;
+    }
+  });
+}
 export {
   ActivitySchemaError,
   BlankConfigSchema,
@@ -188,16 +351,20 @@ export {
   DeferredScoringError,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
+  ItemGroupSchema,
   MediaSchema,
   MediaUrlSchema,
   MultipleChoiceDataSchema,
   MultipleChoiceOptionSchema,
   RedactedBlankConfigSchema,
   RedactedFillInTheBlanksDataSchema,
+  RedactedItemGroupSchema,
   RedactedMultipleChoiceDataSchema,
   RedactedMultipleChoiceOptionSchema,
   RedactedScoringError,
+  RedactedStimulusSchema,
   RedactedWrittenResponseDataSchema,
+  StimulusSchema,
   TextMatchPolicySchema,
   UnknownActivityTypeError,
   WrittenResponseDataSchema,
@@ -206,6 +373,7 @@ export {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   assertRedacted,
+  assertRedactedItemGroup,
   classifyBand,
   composeAssessmentScore,
   computePassThreshold,
@@ -214,10 +382,14 @@ export {
   evaluate,
   fillInTheBlanksJsonSchema,
   fillInTheBlanksType,
+  flattenSequence,
   getActivityTypeDescriptor,
   gradeFromRubric,
   gte,
   hasGrade,
+  hashSeed,
+  isItemGroup,
+  itemGroupJsonSchema,
   jsonSchemaFor,
   levenshteinDistance,
   matchText,
@@ -225,14 +397,19 @@ export {
   multipleChoiceType,
   outcomeFromGrade,
   redact,
+  redactItemGroup,
   registerActivityType,
   registeredActivityTypes,
   roundGrade,
   score,
+  seededShuffle,
+  stimulusJsonSchema,
   validateActivity,
+  validateItemGroup,
   validateXAPIStatement,
   writtenResponseJsonSchema,
   writtenResponseType,
-  xAPIBuilder
+  xAPIBuilder,
+  xapiDefinitionFor
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/redact.ts"],"sourcesContent":["import { ActivitySchemaError, UnknownActivityTypeError } from './errors.js';\nimport { getActivityTypeDescriptor } from './registry/index.js';\nimport type { FieldPolicy, Sensitivity } from './registry/registry.js';\n\n/**\n * A learner-safe projection of activity data produced by {@link redact}:\n * the activity's public fields plus the `redacted: true` marker. Renderable\n * and validatable (each built-in type registers a strict redacted schema),\n * but stripped of the answer key, scoring rules, authored feedback, and\n * author-only assets.\n */\nexport interface RedactedActivityData {\n  redacted: true;\n  schemaVersion: string;\n  type: string;\n  id: string;\n  title: string;\n  [key: string]: unknown;\n}\n\n/** Options for {@link redact}. */\nexport interface RedactOptions {\n  /**\n   * Which sensitivity tiers to keep beyond `public`:\n   * - `'none'` (default) — public fields only; the output satisfies the\n   *   type's strict redacted schema and `assertRedacted`.\n   * - `'after-submit'` — public + answer-key fields (for post-submission\n   *   review renders). `author-only` fields and unclassified fields are\n   *   STILL removed; the output will NOT pass `assertRedacted`.\n   */\n  reveal?: 'none' | 'after-submit';\n  /**\n   * Per-call sensitivity overrides, merged over the type's registered\n   * `fieldPolicy` (top-level keys replace; nested objects merge one level).\n   *\n   * Sensitivity is partly a PEDAGOGICAL decision, not purely a security one —\n   * whether a rubric or a hint is learner-visible differs legitimately between\n   * deployments — and the SDK must not freeze that choice. Use this to tighten\n   * a field the SDK ships as `public`:\n   *\n   * ```ts\n   * redact(essay, { policy: { rubric: 'author-only' } });\n   * ```\n   *\n   * Overrides can only be applied to fields; they cannot re-open a field the\n   * caller has not classified, because unclassified still means removed.\n   * Note that tightening below what the type's `redactedSchema` requires is\n   * allowed — the schema check only rejects payloads that reveal MORE than\n   * the learner-safe shape.\n   */\n  policy?: FieldPolicy;\n}\n\n/** Merges per-call overrides over a registered policy, one level deep. */\nfunction mergePolicy(base: FieldPolicy, overrides: FieldPolicy | undefined): FieldPolicy {\n  if (overrides === undefined) {\n    return base;\n  }\n  const merged: Record<string, Sensitivity | FieldPolicy> = { ...base };\n  for (const [key, override] of Object.entries(overrides)) {\n    const current = merged[key];\n    merged[key] =\n      typeof override === 'object' && typeof current === 'object'\n        ? { ...current, ...override }\n        : override;\n  }\n  return merged;\n}\n\nfunction isSensitivity(value: Sensitivity | FieldPolicy): value is Sensitivity {\n  return typeof value === 'string';\n}\n\nfunction keepField(sensitivity: Sensitivity, reveal: 'none' | 'after-submit'): boolean {\n  if (sensitivity === 'public') {\n    return true;\n  }\n  return sensitivity === 'answer-key' && reveal === 'after-submit';\n}\n\nfunction redactValue(\n  value: unknown,\n  policy: FieldPolicy,\n  reveal: 'none' | 'after-submit',\n): unknown {\n  if (Array.isArray(value)) {\n    return value.map((element) => redactValue(element, policy, reveal));\n  }\n  if (value === null || typeof value !== 'object') {\n    // A nested FieldPolicy cannot classify a primitive's sub-fields; the\n    // policy author classified an object shape that is not there. Fail\n    // closed: drop it (handled by the caller returning undefined).\n    return undefined;\n  }\n\n  const source = value as Record<string, unknown>;\n  const output: Record<string, unknown> = {};\n  for (const [key, fieldValue] of Object.entries(source)) {\n    if (fieldValue === undefined) {\n      continue;\n    }\n    const classification = policy[key];\n    if (classification === undefined) {\n      // Fail closed: unclassified fields are never emitted, at any reveal\n      // level. Adding a field without classifying it hides it — never leaks it.\n      continue;\n    }\n    if (isSensitivity(classification)) {\n      if (keepField(classification, reveal)) {\n        output[key] = fieldValue;\n      }\n      continue;\n    }\n    const nested = redactValue(fieldValue, classification, reveal);\n    if (nested !== undefined) {\n      output[key] = nested;\n    }\n  }\n  return output;\n}\n\n/**\n * Produces the learner-safe projection of activity data (R7), driven by the\n * `fieldPolicy` registered for `data.type`. Fail-closed and exhaustive by\n * construction: a field the policy does not classify is removed — including\n * unknown passthrough fields — so a NEW field added by a future SDK or a\n * consumer sidecar can never leak through an out-of-date redactor.\n *\n * With the default `reveal: 'none'`, the output validates against the type's\n * strict redacted schema (verified here; an invalid projection throws\n * {@link ActivitySchemaError} rather than shipping an unproven payload).\n *\n * @throws UnknownActivityTypeError when `data.type` is not registered.\n * @throws Error when the registered descriptor declares no `fieldPolicy`\n *         (redaction cannot guess sensitivities).\n */\nexport function redact<T extends { type: string }>(\n  data: T,\n  options: RedactOptions = {},\n): RedactedActivityData {\n  const reveal = options.reveal ?? 'none';\n  const descriptor = getActivityTypeDescriptor(data.type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(String(data.type));\n  }\n  if (descriptor.fieldPolicy === undefined) {\n    throw new Error(\n      `Activity type \"${descriptor.type}\" has no fieldPolicy; redact() cannot run fail-closed redaction without one.`,\n    );\n  }\n\n  const effectivePolicy = mergePolicy(descriptor.fieldPolicy, options.policy);\n  const projected = redactValue(data, effectivePolicy, reveal) as Record<string, unknown>;\n  const result = { ...projected, redacted: true as const } as RedactedActivityData;\n\n  if (reveal === 'none' && descriptor.redactedSchema !== undefined) {\n    const parsed = descriptor.redactedSchema.safeParse(result);\n    if (!parsed.success) {\n      throw new ActivitySchemaError(\n        descriptor.type,\n        parsed.error.issues.map((issue) => ({\n          path: issue.path.map(String),\n          message: issue.message,\n          code: issue.code,\n        })),\n      );\n    }\n  }\n\n  return result;\n}\n\n/**\n * Asserts that `data` is a learner-safe redacted projection: it carries the\n * `redacted: true` marker and, when its type registers a strict redacted\n * schema, validates against it (proving the absence of answer-key fields).\n * Use this at the server boundary before sending activity data to a client\n * that must not hold the key.\n */\nexport function assertRedacted(data: unknown): asserts data is RedactedActivityData {\n  if (typeof data !== 'object' || data === null) {\n    throw new ActivitySchemaError('unknown', [\n      { path: [], message: 'Redacted activity data must be an object.', code: 'invalid_type' },\n    ]);\n  }\n  const candidate = data as Record<string, unknown>;\n  if (candidate.redacted !== true) {\n    throw new ActivitySchemaError(String(candidate.type ?? 'unknown'), [\n      {\n        path: ['redacted'],\n        message: 'Missing redacted marker — this payload is not a redact() projection.',\n        code: 'custom',\n      },\n    ]);\n  }\n  const type = typeof candidate.type === 'string' ? candidate.type : '';\n  const descriptor = getActivityTypeDescriptor(type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(type);\n  }\n  if (descriptor.redactedSchema === undefined) {\n    // Fail closed: without a registered redacted schema there is no way to\n    // PROVE the absence of answer-key fields, and a marker alone proves\n    // nothing (any object can carry `redacted: true`).\n    throw new ActivitySchemaError(descriptor.type, [\n      {\n        path: [],\n        message: `Activity type \"${descriptor.type}\" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,\n        code: 'custom',\n      },\n    ]);\n  }\n  const parsed = descriptor.redactedSchema.safeParse(candidate);\n  if (!parsed.success) {\n    throw new ActivitySchemaError(\n      descriptor.type,\n      parsed.error.issues.map((issue) => ({\n        path: issue.path.map(String),\n        message: issue.message,\n        code: issue.code,\n      })),\n    );\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/shuffle.ts","../src/item-group.ts","../src/redact.ts"],"sourcesContent":["/**\n * Seeded, deterministic shuffling — the ONE algorithm every presentation-order\n * decision in the SDK goes through: option order in a multiple-choice item,\n * item order inside an item group, entry order in a sequence. A server and a\n * client holding the same seed derive the same order, and an order recorded\n * against an attempt can be rebuilt later from nothing but its seed.\n *\n * STABILITY: the hash and the generator are part of the wire contract. A\n * stored attempt may hold only a seed and rely on this function to reproduce\n * the order it presented; changing either would silently re-order every\n * recorded attempt. Any change here is a package major, and the pinned\n * permutation test exists so an accidental one fails loudly.\n */\n\n/** FNV-1a hash of a string → unsigned 32-bit integer. */\nexport function hashSeed(input: string): number {\n  let h = 2166136261 >>> 0;\n  for (let i = 0; i < input.length; i += 1) {\n    h ^= input.charCodeAt(i);\n    h = Math.imul(h, 16777619) >>> 0;\n  }\n  return h;\n}\n\n/**\n * Which draw the Fisher–Yates step uses.\n *\n * - `1` — the original. Takes the index from the LCG's LOW bits (`s % (i+1)`).\n * - `2` — takes it from the HIGH bits. Same LCG, same seed, different draw.\n *\n * The difference is not cosmetic. In a linear congruential generator with a\n * power-of-two modulus, the low bits have drastically short periods: bit 0\n * alternates, bit 1 has period 4, and so on. `% (i+1)` reads exactly those\n * bits, so consecutive draws are correlated and most permutations become\n * unreachable FOR EVERY SEED THAT WILL EVER EXIST:\n *\n * | items | permutations | reachable under v1 | under v2 |\n * | ----- | ------------ | ------------------ | -------- |\n * | 4     | 24           | 12                 | 24       |\n * | 5     | 120          | 60                 | 120      |\n * | 6     | 720          | 180                | 720      |\n *\n * It also biases WHERE an option lands. On a four-option item under v1 the\n * last authored option takes the first presented position 8.3% of the time\n * and the second position 41.7%, against 25% each — a systematic advantage to\n * anyone who notices. For a summative exam that is a fairness defect, not a\n * curiosity.\n *\n * v1 remains the DEFAULT regardless, because these permutations are a wire\n * contract: an attempt may be stored with nothing but its seed, and a review\n * render of that attempt has to reproduce the order the learner actually saw.\n * Switching the default would silently re-order every recorded attempt, so it\n * is a package major — scheduled, not smuggled in. Choose v2 for new content\n * where no attempt has been recorded yet.\n */\nexport type ShuffleVersion = 1 | 2;\n\n/** Options for {@link seededShuffle}. */\nexport interface SeededShuffleOptions {\n  /** Draw algorithm. Defaults to `1` — see {@link ShuffleVersion}. */\n  version?: ShuffleVersion;\n}\n\n/** LCG-driven Fisher–Yates over a 32-bit seed; returns a permutation (no loss, no duplicate). */\nfunction shuffleWithSeed<T>(items: readonly T[], seed: number, version: ShuffleVersion): T[] {\n  const out = [...items];\n  let s = seed >>> 0 || 1;\n  for (let i = out.length - 1; i > 0; i -= 1) {\n    s = (Math.imul(s, 1664525) + 1013904223) >>> 0;\n    // v1 reads the low bits; v2 scales the whole 32-bit word, which uses the\n    // high bits and reaches every permutation.\n    const j = version === 2 ? Math.floor((s / 4294967296) * (i + 1)) : s % (i + 1);\n    [out[i], out[j]] = [out[j] as T, out[i] as T];\n  }\n  return out;\n}\n\n/**\n * Returns a new array holding a permutation of `items` determined entirely by\n * `seed` (and the chosen {@link ShuffleVersion}): same inputs, same order —\n * across processes, runtimes and releases. The input is never mutated.\n *\n * Compose the seed from the attempt identity AND the thing being shuffled\n * (`${attemptId}:${itemId}`), so two shuffles in one attempt do not share an\n * order.\n */\nexport function seededShuffle<T>(\n  items: readonly T[],\n  seed: string,\n  options: SeededShuffleOptions = {},\n): T[] {\n  return shuffleWithSeed(items, hashSeed(seed), options.version ?? 1);\n}\n","import { seededShuffle } from './shuffle.js';\nimport type { ItemGroup, SequenceEntry, SequenceSlot } from './types/item-group.js';\n\n/** Narrows a sequence entry to an item group. */\nexport function isItemGroup<TItem extends { type: string }>(\n  entry: SequenceEntry<TItem>,\n): entry is ItemGroup<TItem> {\n  return entry.type === 'item-group';\n}\n\n/** Options for {@link flattenSequence}. */\nexport interface FlattenSequenceOptions {\n  /**\n   * Shuffle the top-level entries. A group moves as ONE block — its items are\n   * never interleaved with other entries — which is the reason a group exists\n   * as a container rather than as a flag on each item.\n   */\n  shuffleEntries?: boolean;\n  /**\n   * Seed for every shuffle in this call: the entries, and each group whose\n   * `shuffle` is `within-group`. REQUIRED whenever anything shuffles. The SDK\n   * never invents one, because the server that stores an attempt and the\n   * client that renders it must derive the SAME order, and only a shared seed\n   * makes that true. The attempt id is the natural choice.\n   */\n  seed?: string;\n}\n\n/**\n * Turns a sequence definition — loose activities and item groups, in authored\n * order — into the ordered list of slots to present. Pure and deterministic:\n * call it on the server to record an attempt's order, and on the client to\n * render it, and the two agree.\n *\n * Shuffling is opt-in and seeded. Groups are shuffle-atomic: with\n * `shuffleEntries` a group changes position but stays one contiguous block,\n * and only a group that declares `shuffle: 'within-group'` has its items\n * reordered. Every slot carries a `slotId` derived from the authored\n * position, so identities survive shuffling.\n *\n * @throws Error when a shuffle is requested without a `seed`.\n */\nexport function flattenSequence<TItem extends { id: string; type: string }>(\n  entries: readonly SequenceEntry<TItem>[],\n  options: FlattenSequenceOptions = {},\n): SequenceSlot<TItem>[] {\n  const shuffleEntries = options.shuffleEntries === true;\n  const needsSeed =\n    shuffleEntries ||\n    entries.some((entry) => isItemGroup(entry) && entry.shuffle === 'within-group');\n  if (needsSeed && options.seed === undefined) {\n    throw new Error(\n      'flattenSequence: a seed is required when shuffling (shuffleEntries, or a group with ' +\n        'shuffle: \"within-group\"). Pass the attempt id so the server and the client derive the same order.',\n    );\n  }\n  const seed = options.seed ?? '';\n\n  // Carry the AUTHORED index through the shuffle: slot identity comes from\n  // where an entry was written, never from where it happens to be shown.\n  const authored = entries.map((entry, entryIndex) => ({ entry, entryIndex }));\n  const ordered = shuffleEntries ? seededShuffle(authored, `${seed}:entries`) : authored;\n\n  const slots: SequenceSlot<TItem>[] = [];\n  for (const { entry, entryIndex } of ordered) {\n    if (!isItemGroup(entry)) {\n      slots.push({ slotId: String(entryIndex), index: slots.length, activity: entry });\n      continue;\n    }\n    // An empty group contributes no slots, so it would DISAPPEAR — stimulus,\n    // questions and all — from a sequence that still looks well-formed. A\n    // listening section filtered to nothing upstream would leave an 18-slot\n    // paper presented as 12 slots, and `composeAssessmentScore` would then\n    // report a `final` grade over the survivors with nothing pending. The\n    // type already declares `items` non-empty; this makes that enforceable at\n    // the point where the omission would otherwise become invisible.\n    if (entry.items.length === 0) {\n      throw new Error(\n        `flattenSequence: item group \"${entry.id}\" has no items. An empty group would silently ` +\n          'remove its stimulus and its questions from the presented sequence.',\n      );\n    }\n    const items = entry.items.map((item, itemIndex) => ({ item, itemIndex }));\n    const presented =\n      entry.shuffle === 'within-group' ? seededShuffle(items, `${seed}:group:${entry.id}`) : items;\n    const size = presented.length;\n    presented.forEach(({ item, itemIndex }, position) => {\n      slots.push({\n        slotId: `${entryIndex}.${itemIndex}`,\n        index: slots.length,\n        activity: item,\n        group: {\n          id: entry.id,\n          ...(entry.title !== undefined ? { title: entry.title } : {}),\n          stimulus: entry.stimulus,\n          position,\n          size,\n        },\n      });\n    });\n  }\n  return slots;\n}\n","import { ActivitySchemaError, UnknownActivityTypeError } from './errors.js';\nimport { getActivityTypeDescriptor } from './registry/index.js';\nimport type { FieldPolicy, Sensitivity } from './registry/registry.js';\nimport { RedactedItemGroupSchema } from './schemas/item-group.js';\nimport type { ItemGroup } from './types/item-group.js';\n\n/**\n * A learner-safe projection of activity data produced by {@link redact}:\n * the activity's public fields plus the `redacted: true` marker. Renderable\n * and validatable (each built-in type registers a strict redacted schema),\n * but stripped of the answer key, scoring rules, authored feedback, and\n * author-only assets.\n */\nexport interface RedactedActivityData {\n  redacted: true;\n  schemaVersion: string;\n  type: string;\n  id: string;\n  title: string;\n  [key: string]: unknown;\n}\n\n/** Options for {@link redact}. */\nexport interface RedactOptions {\n  /**\n   * Which sensitivity tiers to keep beyond `public`:\n   * - `'none'` (default) — public fields only; the output satisfies the\n   *   type's strict redacted schema and `assertRedacted`.\n   * - `'after-submit'` — public + answer-key fields (for post-submission\n   *   review renders). `author-only` fields and unclassified fields are\n   *   STILL removed; the output will NOT pass `assertRedacted`.\n   */\n  reveal?: 'none' | 'after-submit';\n  /**\n   * Per-call sensitivity overrides, merged over the type's registered\n   * `fieldPolicy` (top-level keys replace; nested objects merge one level).\n   *\n   * Sensitivity is partly a PEDAGOGICAL decision, not purely a security one —\n   * whether a rubric or a hint is learner-visible differs legitimately between\n   * deployments — and the SDK must not freeze that choice. Use this to tighten\n   * a field the SDK ships as `public`:\n   *\n   * ```ts\n   * redact(essay, { policy: { rubric: 'author-only' } });\n   * ```\n   *\n   * Overrides can only be applied to fields; they cannot re-open a field the\n   * caller has not classified, because unclassified still means removed.\n   * Note that tightening below what the type's `redactedSchema` requires is\n   * allowed — the schema check only rejects payloads that reveal MORE than\n   * the learner-safe shape.\n   */\n  policy?: FieldPolicy;\n}\n\n/** Merges per-call overrides over a registered policy, one level deep. */\nfunction mergePolicy(base: FieldPolicy, overrides: FieldPolicy | undefined): FieldPolicy {\n  if (overrides === undefined) {\n    return base;\n  }\n  const merged: Record<string, Sensitivity | FieldPolicy> = { ...base };\n  for (const [key, override] of Object.entries(overrides)) {\n    const current = merged[key];\n    merged[key] =\n      typeof override === 'object' && typeof current === 'object'\n        ? { ...current, ...override }\n        : override;\n  }\n  return merged;\n}\n\nfunction isSensitivity(value: Sensitivity | FieldPolicy): value is Sensitivity {\n  return typeof value === 'string';\n}\n\nfunction keepField(sensitivity: Sensitivity, reveal: 'none' | 'after-submit'): boolean {\n  if (sensitivity === 'public') {\n    return true;\n  }\n  return sensitivity === 'answer-key' && reveal === 'after-submit';\n}\n\nfunction redactValue(\n  value: unknown,\n  policy: FieldPolicy,\n  reveal: 'none' | 'after-submit',\n): unknown {\n  if (Array.isArray(value)) {\n    return value.map((element) => redactValue(element, policy, reveal));\n  }\n  if (value === null || typeof value !== 'object') {\n    // A nested FieldPolicy cannot classify a primitive's sub-fields; the\n    // policy author classified an object shape that is not there. Fail\n    // closed: drop it (handled by the caller returning undefined).\n    return undefined;\n  }\n\n  const source = value as Record<string, unknown>;\n  const output: Record<string, unknown> = {};\n  for (const [key, fieldValue] of Object.entries(source)) {\n    if (fieldValue === undefined) {\n      continue;\n    }\n    const classification = policy[key];\n    if (classification === undefined) {\n      // Fail closed: unclassified fields are never emitted, at any reveal\n      // level. Adding a field without classifying it hides it — never leaks it.\n      continue;\n    }\n    if (isSensitivity(classification)) {\n      if (keepField(classification, reveal)) {\n        output[key] = fieldValue;\n      }\n      continue;\n    }\n    const nested = redactValue(fieldValue, classification, reveal);\n    if (nested !== undefined) {\n      output[key] = nested;\n    }\n  }\n  return output;\n}\n\n/**\n * Produces the learner-safe projection of activity data (R7), driven by the\n * `fieldPolicy` registered for `data.type`. Fail-closed and exhaustive by\n * construction: a field the policy does not classify is removed — including\n * unknown passthrough fields — so a NEW field added by a future SDK or a\n * consumer sidecar can never leak through an out-of-date redactor.\n *\n * With the default `reveal: 'none'`, the output validates against the type's\n * strict redacted schema (verified here; an invalid projection throws\n * {@link ActivitySchemaError} rather than shipping an unproven payload).\n *\n * @throws UnknownActivityTypeError when `data.type` is not registered.\n * @throws Error when the registered descriptor declares no `fieldPolicy`\n *         (redaction cannot guess sensitivities).\n */\nexport function redact<T extends { type: string }>(\n  data: T,\n  options: RedactOptions = {},\n): RedactedActivityData {\n  const reveal = options.reveal ?? 'none';\n  const descriptor = getActivityTypeDescriptor(data.type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(String(data.type));\n  }\n  if (descriptor.fieldPolicy === undefined) {\n    throw new Error(\n      `Activity type \"${descriptor.type}\" has no fieldPolicy; redact() cannot run fail-closed redaction without one.`,\n    );\n  }\n\n  const effectivePolicy = mergePolicy(descriptor.fieldPolicy, options.policy);\n  const projected = redactValue(data, effectivePolicy, reveal) as Record<string, unknown>;\n  const result = { ...projected, redacted: true as const } as RedactedActivityData;\n\n  if (reveal === 'none' && descriptor.redactedSchema !== undefined) {\n    const parsed = descriptor.redactedSchema.safeParse(result);\n    if (!parsed.success) {\n      throw new ActivitySchemaError(\n        descriptor.type,\n        parsed.error.issues.map((issue) => ({\n          path: issue.path.map(String),\n          message: issue.message,\n          code: issue.code,\n        })),\n      );\n    }\n  }\n\n  return result;\n}\n\n/**\n * Asserts that `data` is a learner-safe redacted projection: it carries the\n * `redacted: true` marker and, when its type registers a strict redacted\n * schema, validates against it (proving the absence of answer-key fields).\n * Use this at the server boundary before sending activity data to a client\n * that must not hold the key.\n */\nexport function assertRedacted(data: unknown): asserts data is RedactedActivityData {\n  if (typeof data !== 'object' || data === null) {\n    throw new ActivitySchemaError('unknown', [\n      { path: [], message: 'Redacted activity data must be an object.', code: 'invalid_type' },\n    ]);\n  }\n  const candidate = data as Record<string, unknown>;\n  if (candidate.redacted !== true) {\n    throw new ActivitySchemaError(String(candidate.type ?? 'unknown'), [\n      {\n        path: ['redacted'],\n        message: 'Missing redacted marker — this payload is not a redact() projection.',\n        code: 'custom',\n      },\n    ]);\n  }\n  const type = typeof candidate.type === 'string' ? candidate.type : '';\n  const descriptor = getActivityTypeDescriptor(type);\n  if (descriptor === undefined) {\n    throw new UnknownActivityTypeError(type);\n  }\n  if (descriptor.redactedSchema === undefined) {\n    // Fail closed: without a registered redacted schema there is no way to\n    // PROVE the absence of answer-key fields, and a marker alone proves\n    // nothing (any object can carry `redacted: true`).\n    throw new ActivitySchemaError(descriptor.type, [\n      {\n        path: [],\n        message: `Activity type \"${descriptor.type}\" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,\n        code: 'custom',\n      },\n    ]);\n  }\n  const parsed = descriptor.redactedSchema.safeParse(candidate);\n  if (!parsed.success) {\n    throw new ActivitySchemaError(\n      descriptor.type,\n      parsed.error.issues.map((issue) => ({\n        path: issue.path.map(String),\n        message: issue.message,\n        code: issue.code,\n      })),\n    );\n  }\n}\n\n/**\n * Sensitivity of a stimulus. Everything is learner-visible — that is what a\n * stimulus IS — except the author transcript. Fail-closed like every other\n * policy: a field added to `Stimulus` without a classification here is\n * dropped, never leaked.\n */\nconst STIMULUS_FIELD_POLICY: FieldPolicy = {\n  id: 'public',\n  kind: 'public',\n  title: 'public',\n  body: 'public',\n  bodyHtml: 'public',\n  media: 'public',\n  locale: 'public',\n  attribution: 'public',\n  transcript: 'author-only',\n};\n\n/** The group container's own fields. `items` is handled separately, per item type. */\nconst ITEM_GROUP_FIELD_POLICY: FieldPolicy = {\n  schemaVersion: 'public',\n  type: 'public',\n  id: 'public',\n  title: 'public',\n  shuffle: 'public',\n  stimulus: STIMULUS_FIELD_POLICY,\n};\n\n/** A learner-safe item group: the container with its marker, holding `redact()` projections. */\nexport type RedactedItemGroup = ItemGroup<RedactedActivityData> & { redacted: true };\n\n/**\n * Produces the learner-safe projection of an item group: the container and\n * stimulus under their own fail-closed policy (the author transcript goes;\n * the passage, media and attribution stay — the learner is meant to see\n * them), and every item through {@link redact} with the same `options`, so\n * a per-call `policy` tightens each item exactly as it would alone.\n *\n * With the default `reveal: 'none'` the container is verified against the\n * strict redacted schema; each item was already verified by `redact`.\n */\nexport function redactItemGroup<TItem extends { type: string }>(\n  group: ItemGroup<TItem>,\n  options: RedactOptions = {},\n): RedactedItemGroup {\n  const reveal = options.reveal ?? 'none';\n  const { items, ...container } = group;\n  const projected = redactValue(container, ITEM_GROUP_FIELD_POLICY, reveal) as Record<\n    string,\n    unknown\n  >;\n  const result = {\n    ...projected,\n    items: items.map((item) => redact(item, options)),\n    redacted: true as const,\n  } as RedactedItemGroup;\n\n  if (reveal === 'none') {\n    const parsed = RedactedItemGroupSchema.safeParse(result);\n    if (!parsed.success) {\n      throw new ActivitySchemaError(\n        'item-group',\n        parsed.error.issues.map((issue) => ({\n          path: issue.path.map(String),\n          message: issue.message,\n          code: issue.code,\n        })),\n      );\n    }\n  }\n  return result;\n}\n\n/**\n * Asserts that `data` is a learner-safe item group: it carries the marker,\n * its container and stimulus satisfy the strict redacted schema (so no\n * transcript, no unclassified field), and EVERY item passes\n * {@link assertRedacted} against its own type's redacted schema. Item\n * failures are reported at `items.<index>.…`. Use it at the server boundary\n * before sending a group to a client that must not hold the key.\n */\nexport function assertRedactedItemGroup(data: unknown): asserts data is RedactedItemGroup {\n  if (typeof data !== 'object' || data === null) {\n    throw new ActivitySchemaError('item-group', [\n      { path: [], message: 'Redacted item group must be an object.', code: 'invalid_type' },\n    ]);\n  }\n  const candidate = data as Record<string, unknown>;\n  if (candidate.redacted !== true) {\n    throw new ActivitySchemaError('item-group', [\n      {\n        path: ['redacted'],\n        message: 'Missing redacted marker — this payload is not a redactItemGroup() projection.',\n        code: 'custom',\n      },\n    ]);\n  }\n  const parsed = RedactedItemGroupSchema.safeParse(candidate);\n  if (!parsed.success) {\n    throw new ActivitySchemaError(\n      'item-group',\n      parsed.error.issues.map((issue) => ({\n        path: issue.path.map(String),\n        message: issue.message,\n        code: issue.code,\n      })),\n    );\n  }\n  parsed.data.items.forEach((item, index) => {\n    try {\n      assertRedacted(item);\n    } catch (error) {\n      if (error instanceof ActivitySchemaError) {\n        throw new ActivitySchemaError(\n          'item-group',\n          error.errors.map((issue) => ({\n            ...issue,\n            path: ['items', String(index), ...issue.path],\n          })),\n        );\n      }\n      throw error;\n    }\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/schemas.cjs

@@ -4,7 +4,6 @@
 
 
 
-var _chunkYNTYWHZIcjs = require('./chunk-YNTYWHZI.cjs');
 
 
 
@@ -12,6 +11,7 @@ var _chunkYNTYWHZIcjs = require('./chunk-YNTYWHZI.cjs');
 
 
 
+var _chunkFCM5VJBScjs = require('./chunk-FCM5VJBS.cjs');
 
 
 
@@ -22,8 +22,6 @@ var _chunkYNTYWHZIcjs = require('./chunk-YNTYWHZI.cjs');
 
 
 
-var _chunkQOAORTA4cjs = require('./chunk-QOAORTA4.cjs');
-require('./chunk-PIMX4B4D.cjs');
 
 
 
@@ -31,6 +29,7 @@ require('./chunk-PIMX4B4D.cjs');
 
 
 
+var _chunk4JR3UXX6cjs = require('./chunk-4JR3UXX6.cjs');
 
 
 
@@ -46,5 +45,19 @@ require('./chunk-PIMX4B4D.cjs');
 
 
 
-exports.BlankConfigSchema = _chunkQOAORTA4cjs.BlankConfigSchema; exports.FeedbackSchema = _chunkQOAORTA4cjs.FeedbackSchema; exports.FillInTheBlanksDataSchema = _chunkQOAORTA4cjs.FillInTheBlanksDataSchema; exports.MediaSchema = _chunkQOAORTA4cjs.MediaSchema; exports.MediaUrlSchema = _chunkQOAORTA4cjs.MediaUrlSchema; exports.MultipleChoiceDataSchema = _chunkQOAORTA4cjs.MultipleChoiceDataSchema; exports.MultipleChoiceOptionSchema = _chunkQOAORTA4cjs.MultipleChoiceOptionSchema; exports.RedactedBlankConfigSchema = _chunkQOAORTA4cjs.RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = _chunkQOAORTA4cjs.RedactedFillInTheBlanksDataSchema; exports.RedactedMultipleChoiceDataSchema = _chunkQOAORTA4cjs.RedactedMultipleChoiceDataSchema; exports.RedactedMultipleChoiceOptionSchema = _chunkQOAORTA4cjs.RedactedMultipleChoiceOptionSchema; exports.RedactedWrittenResponseDataSchema = _chunkQOAORTA4cjs.RedactedWrittenResponseDataSchema; exports.TextMatchPolicySchema = _chunkQOAORTA4cjs.TextMatchPolicySchema; exports.WrittenResponseDataSchema = _chunkQOAORTA4cjs.WrittenResponseDataSchema; exports.WrittenResponseRubricCriterionSchema = _chunkQOAORTA4cjs.WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = _chunkQOAORTA4cjs.WrittenResponseRubricSchema; exports.fillInTheBlanksJsonSchema = _chunkYNTYWHZIcjs.fillInTheBlanksJsonSchema; exports.jsonSchemaFor = _chunkYNTYWHZIcjs.jsonSchemaFor; exports.multipleChoiceJsonSchema = _chunkYNTYWHZIcjs.multipleChoiceJsonSchema; exports.validateActivity = _chunkYNTYWHZIcjs.validateActivity; exports.writtenResponseJsonSchema = _chunkYNTYWHZIcjs.writtenResponseJsonSchema;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BlankConfigSchema = _chunk4JR3UXX6cjs.BlankConfigSchema; exports.FeedbackSchema = _chunk4JR3UXX6cjs.FeedbackSchema; exports.FillInTheBlanksDataSchema = _chunk4JR3UXX6cjs.FillInTheBlanksDataSchema; exports.ItemGroupSchema = _chunkFCM5VJBScjs.ItemGroupSchema; exports.MediaSchema = _chunk4JR3UXX6cjs.MediaSchema; exports.MediaUrlSchema = _chunk4JR3UXX6cjs.MediaUrlSchema; exports.MultipleChoiceDataSchema = _chunk4JR3UXX6cjs.MultipleChoiceDataSchema; exports.MultipleChoiceOptionSchema = _chunk4JR3UXX6cjs.MultipleChoiceOptionSchema; exports.RedactedBlankConfigSchema = _chunk4JR3UXX6cjs.RedactedBlankConfigSchema; exports.RedactedFillInTheBlanksDataSchema = _chunk4JR3UXX6cjs.RedactedFillInTheBlanksDataSchema; exports.RedactedItemGroupSchema = _chunkFCM5VJBScjs.RedactedItemGroupSchema; exports.RedactedMultipleChoiceDataSchema = _chunk4JR3UXX6cjs.RedactedMultipleChoiceDataSchema; exports.RedactedMultipleChoiceOptionSchema = _chunk4JR3UXX6cjs.RedactedMultipleChoiceOptionSchema; exports.RedactedStimulusSchema = _chunkFCM5VJBScjs.RedactedStimulusSchema; exports.RedactedWrittenResponseDataSchema = _chunk4JR3UXX6cjs.RedactedWrittenResponseDataSchema; exports.StimulusSchema = _chunkFCM5VJBScjs.StimulusSchema; exports.TextMatchPolicySchema = _chunk4JR3UXX6cjs.TextMatchPolicySchema; exports.WrittenResponseDataSchema = _chunk4JR3UXX6cjs.WrittenResponseDataSchema; exports.WrittenResponseRubricCriterionSchema = _chunk4JR3UXX6cjs.WrittenResponseRubricCriterionSchema; exports.WrittenResponseRubricSchema = _chunk4JR3UXX6cjs.WrittenResponseRubricSchema; exports.fillInTheBlanksJsonSchema = _chunkFCM5VJBScjs.fillInTheBlanksJsonSchema; exports.itemGroupJsonSchema = _chunkFCM5VJBScjs.itemGroupJsonSchema; exports.jsonSchemaFor = _chunkFCM5VJBScjs.jsonSchemaFor; exports.multipleChoiceJsonSchema = _chunkFCM5VJBScjs.multipleChoiceJsonSchema; exports.stimulusJsonSchema = _chunkFCM5VJBScjs.stimulusJsonSchema; exports.validateActivity = _chunkFCM5VJBScjs.validateActivity; exports.validateItemGroup = _chunkFCM5VJBScjs.validateItemGroup; exports.writtenResponseJsonSchema = _chunkFCM5VJBScjs.writtenResponseJsonSchema;
 //# sourceMappingURL=schemas.cjs.map

package/dist/schemas.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/schemas.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,knDAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/schemas.cjs"}
+{"version":3,"sources":["/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/schemas.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,2kEAAC","file":"/home/runner/work/learning-kit/learning-kit/packages/lk-core/dist/schemas.cjs"}