@intellectif/lk-core 0.2.1 → 0.3.1

package/dist/index.d.ts

@@ -1,9 +1,18 @@
-import { V as ValidationError } from './activity-D5tqgx8A.js';
-export { A as ActivityData, a as ActivityDataMap, b as ActivityFeedback, c as ActivityMedia, d as ActivityResult, e as ActivityType, B as BlankConfig, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, I as InteractionEvent, L as LearnerResponse, M as MultipleChoiceData, g as MultipleChoiceLearnerResponse, h as MultipleChoiceOption, S as ScoringDetail, i as ScoringResult, j as ValidationResult, X as XAPIActor, k as XAPIConfig, l as XAPIContext, m as XAPIError, n as XAPIObject, o as XAPIResult, p as XAPIScore, q as XAPIStatement, r as XAPIVerbObject } from './activity-D5tqgx8A.js';
-export { BlankConfigSchema, FeedbackSchema, FillInTheBlanksDataSchema, MediaSchema, MultipleChoiceDataSchema, MultipleChoiceOptionSchema, fillInTheBlanksJsonSchema, multipleChoiceJsonSchema, validateActivity } from './schemas.js';
-export { computePassThreshold, score } from './scoring.js';
-export { AnsweredStatementParams, CompletedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder } from './xapi.js';
-import 'zod/v4';
+import { V as ValidationError, m as ScoringResult, D as DeferredScoringPartial, F as FillInTheBlanksData, f as FillInTheBlanksLearnerResponse, M as MultipleChoiceData, j as MultipleChoiceLearnerResponse, W as WrittenResponseData, p as WrittenResponseLearnerResponse } from './activity-zdcAMtFB.js';
+export { A as ActivityData, a as ActivityDataMap, b as ActivityFeedback, c as ActivityMedia, d as ActivityResult, e as ActivityType, B as BlankConfig, I as InteractionEvent, g as InteractionKind, h as ItemOutcome, L as LearnerResponse, i as LearnerResponseMap, k as MultipleChoiceOption, S as ScoringDetail, l as ScoringOutcome, T as TextMatchPolicy, n as TextMatchResult, o as ValidationResult, q as WrittenResponseRubric, r as WrittenResponseRubricCriterion, X as XAPIActor, s as XAPIConfig, t as XAPIContext, u as XAPIContextActivities, v as XAPIError, w as XAPIObject, x as XAPIResult, y as XAPIScore, z as XAPIStatement, C as XAPIVerbObject, E as levenshteinDistance, G as matchText } from './activity-zdcAMtFB.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 { DEFAULT_PASS_THRESHOLD, computePassThreshold, evaluate, score } from './scoring.js';
+export { AnsweredStatementParams, CompletedStatementParams, SubmittedStatementParams, XAPIObjectParams, XAPIStatementParams, XAPIVerb, XAPIVerbKey, XAPI_VERB_DISPLAY, validateXAPIStatement, xAPIBuilder } from './xapi.js';
+
+/**
+ * Canonical word counter for written-response bounds (Req 22.9): tokens are
+ * maximal runs of non-whitespace (split on `\s+`), so hyphenated forms
+ * (`well-known`) count as one word. The empty / whitespace-only string counts
+ * 0. Consumers must use this helper rather than re-implementing the split so
+ * client previews, SDK scoring, and stored `wordCount` values always agree.
+ */
+declare function countWords(text: string): number;
 
 /** Thrown when activity data fails schema validation at a component boundary. */
 declare class ActivitySchemaError extends Error {
@@ -16,6 +25,243 @@ declare class UnknownActivityTypeError extends Error {
     readonly activityType: string;
     constructor(activityType: string);
 }
+/**
+ * Thrown when `score()` is asked to grade a `redact()` projection (or any
+ * activity data whose answer key is missing, yielding a non-finite score).
+ * Redacted data is learner-safe precisely because the key was removed, so a
+ * score derived from it is meaningless — previously this produced a silent
+ * `NaN` that serialized to `null` in a grade column. `evaluate()` returns
+ * `{ status: 'unscorable' }` for the same input instead of throwing.
+ */
+declare class RedactedScoringError extends Error {
+    readonly activityType: string;
+    constructor(activityType: string);
+}
+/**
+ * Thrown when `score()` is called for an activity type whose grading is
+ * deferred (asynchronous AI/human grading, e.g. `written-response`). A
+ * deferred submission has no synchronous score — treating it as 0 would show
+ * a learner a failing grade for work that simply has not been graded yet.
+ * Call `evaluate()` instead, which returns `{ status: 'deferred', ... }`.
+ */
+declare class DeferredScoringError extends Error {
+    readonly activityType: string;
+    constructor(activityType: string);
+}
+
+/** ScoringResult without `passed` — the public `score()` / `evaluate()` fill that in. */
+type PartialScoringResult = Omit<ScoringResult, 'passed'>;
+/**
+ * Sensitivity classification of a single activity-data field, driving
+ * `redact()`:
+ * - `public` — safe to send to a learner before they answer.
+ * - `answer-key` — reveals (or helps infer) the correct answer or the scoring
+ *   rules; removed unless `reveal: 'after-submit'` is requested.
+ * - `author-only` — never leaves the authoring/grading context (e.g. rubrics).
+ */
+type Sensitivity = 'public' | 'answer-key' | 'author-only';
+/**
+ * Per-field sensitivity map for an activity type. A `Sensitivity` value
+ * classifies the whole field (objects and arrays included); a nested
+ * `FieldPolicy` recurses into an object field — and, for an array field,
+ * applies to every element. Fail-closed: any field a policy does not mention
+ * is treated as `author-only` and removed by `redact()` — adding a field
+ * without classifying it hides it, never leaks it.
+ */
+interface FieldPolicy {
+    readonly [field: string]: Sensitivity | FieldPolicy;
+}
+/** xAPI interaction types defined by xAPI 1.0.3 (cmi.interaction vocabulary). */
+type XAPIInteractionType = 'choice' | 'fill-in' | 'long-fill-in' | 'matching' | 'sequencing' | 'performance' | 'true-false' | 'other';
+/** Interop facts a generic statement builder cannot infer from data alone. */
+interface ActivityTypeInterop<TData> {
+    /** IRI for the xAPI Activity `definition.type`. */
+    readonly xapiActivityTypeIri?: string;
+    /** xAPI `definition.interactionType` for this activity type. */
+    readonly xapiInteractionType?: XAPIInteractionType;
+    /** Builds the xAPI `correctResponsesPattern` strings for an item. */
+    readonly correctResponsesPattern?: (data: TData) => string[];
+}
+/**
+ * How responses to an activity type are graded:
+ * - `sync` — a pure function produces the grade at submit time.
+ * - `deferred` — grading happens asynchronously (AI or human) after
+ *   submission; `partial` reports the facts computable synchronously
+ *   (e.g. word counts), surfaced in `ItemOutcome.partial`.
+ */
+type ActivityTypeScoring<TData, TResponse> = {
+    readonly kind: 'sync';
+    readonly score: (data: TData, response: TResponse) => PartialScoringResult;
+} | {
+    readonly kind: 'deferred';
+    readonly reason: 'requires_async_grading';
+    readonly partial?: (data: TData, response: TResponse | undefined) => DeferredScoringPartial;
+};
+/**
+ * A value-level description of an activity type: its contract (schema), its
+ * grading, its redaction policy, and its interop facts. Registering a
+ * descriptor makes `validateActivity`, `score`, `evaluate`, `redact`, and
+ * `jsonSchemaFor` work for the type — an activity type is a value, not a
+ * hardcoded union member (R1).
+ */
+interface ActivityTypeDescriptor<TData extends {
+    type: string;
+}, TResponse> {
+    /** The `type` discriminator string (kebab-case by convention). */
+    readonly type: TData['type'];
+    /** Zod schema validating the activity's data contract. */
+    readonly schema: z.ZodType<TData>;
+    /** How responses are graded. */
+    readonly scoring: ActivityTypeScoring<TData, TResponse>;
+    /** Whether a response counts as an answer (vs. blank/untouched). */
+    readonly isAnswered?: (response: TResponse | undefined) => boolean;
+    /** Per-field sensitivity map driving `redact()`. Fail-closed. */
+    readonly fieldPolicy?: FieldPolicy;
+    /**
+     * Schema the output of `redact(data)` (with default `reveal: 'none'`) must
+     * satisfy. Strict by design: it proves the ABSENCE of answer-key fields,
+     * so `assertRedacted` can guarantee a payload is safe to send to a learner.
+     */
+    readonly redactedSchema?: z.ZodType<unknown>;
+    /** Interop facts for xAPI (and later QTI) statement building. */
+    readonly interop?: ActivityTypeInterop<TData>;
+    /** The interaction-event kinds components for this type emit. */
+    readonly interactions?: readonly string[];
+}
+/**
+ * Internal type-erased descriptor shape stored in the registry. Dispatch call
+ * sites cast payloads back; the public generic API preserves inference.
+ */
+interface RegisteredActivityTypeDescriptor {
+    readonly type: string;
+    readonly schema: z.ZodType<unknown>;
+    readonly scoring: {
+        readonly kind: 'sync';
+        readonly score: (data: unknown, response: unknown) => PartialScoringResult;
+    } | {
+        readonly kind: 'deferred';
+        readonly reason: 'requires_async_grading';
+        readonly partial?: (data: unknown, response: unknown) => DeferredScoringPartial;
+    };
+    readonly isAnswered?: (response: unknown) => boolean;
+    readonly fieldPolicy?: FieldPolicy;
+    readonly redactedSchema?: z.ZodType<unknown>;
+    readonly interop?: ActivityTypeInterop<unknown>;
+    readonly interactions?: readonly string[];
+}
+/**
+ * Identity helper that gives full type inference when authoring a descriptor:
+ *
+ * ```ts
+ * const myType = defineActivityType<MyTypeData, MyTypeLearnerResponse>({ ... });
+ * registerActivityType(myType);
+ * ```
+ */
+declare function defineActivityType<TData extends {
+    type: string;
+}, TResponse>(descriptor: ActivityTypeDescriptor<TData, TResponse>): ActivityTypeDescriptor<TData, TResponse>;
+/**
+ * Registers an activity type on the default registry, making it live for
+ * `validateActivity`, `score`, `evaluate`, `redact`, and `jsonSchemaFor`.
+ * Re-registering the same descriptor object is a no-op; registering a
+ * DIFFERENT descriptor under an existing type throws — silently replacing a
+ * type's contract or scoring is exactly the class of accident a summative
+ * SDK must not allow.
+ */
+declare function registerActivityType<TData extends {
+    type: string;
+}, TResponse>(descriptor: ActivityTypeDescriptor<TData, TResponse>): void;
+/** Returns the registered descriptor for `type`, or `undefined`. */
+declare function getActivityTypeDescriptor(type: string): RegisteredActivityTypeDescriptor | undefined;
+/** The type strings currently registered (built-ins plus consumer-registered). */
+declare function registeredActivityTypes(): string[];
+
+/**
+ * A learner-safe projection of activity data produced by {@link redact}:
+ * the activity's public fields plus the `redacted: true` marker. Renderable
+ * and validatable (each built-in type registers a strict redacted schema),
+ * but stripped of the answer key, scoring rules, authored feedback, and
+ * author-only assets.
+ */
+interface RedactedActivityData {
+    redacted: true;
+    schemaVersion: string;
+    type: string;
+    id: string;
+    title: string;
+    [key: string]: unknown;
+}
+/** Options for {@link redact}. */
+interface RedactOptions {
+    /**
+     * Which sensitivity tiers to keep beyond `public`:
+     * - `'none'` (default) — public fields only; the output satisfies the
+     *   type's strict redacted schema and `assertRedacted`.
+     * - `'after-submit'` — public + answer-key fields (for post-submission
+     *   review renders). `author-only` fields and unclassified fields are
+     *   STILL removed; the output will NOT pass `assertRedacted`.
+     */
+    reveal?: 'none' | 'after-submit';
+    /**
+     * Per-call sensitivity overrides, merged over the type's registered
+     * `fieldPolicy` (top-level keys replace; nested objects merge one level).
+     *
+     * Sensitivity is partly a PEDAGOGICAL decision, not purely a security one —
+     * whether a rubric or a hint is learner-visible differs legitimately between
+     * deployments — and the SDK must not freeze that choice. Use this to tighten
+     * a field the SDK ships as `public`:
+     *
+     * ```ts
+     * redact(essay, { policy: { rubric: 'author-only' } });
+     * ```
+     *
+     * Overrides can only be applied to fields; they cannot re-open a field the
+     * caller has not classified, because unclassified still means removed.
+     * Note that tightening below what the type's `redactedSchema` requires is
+     * allowed — the schema check only rejects payloads that reveal MORE than
+     * the learner-safe shape.
+     */
+    policy?: FieldPolicy;
+}
+/**
+ * Produces the learner-safe projection of activity data (R7), driven by the
+ * `fieldPolicy` registered for `data.type`. Fail-closed and exhaustive by
+ * construction: a field the policy does not classify is removed — including
+ * unknown passthrough fields — so a NEW field added by a future SDK or a
+ * consumer sidecar can never leak through an out-of-date redactor.
+ *
+ * With the default `reveal: 'none'`, the output validates against the type's
+ * strict redacted schema (verified here; an invalid projection throws
+ * {@link ActivitySchemaError} rather than shipping an unproven payload).
+ *
+ * @throws UnknownActivityTypeError when `data.type` is not registered.
+ * @throws Error when the registered descriptor declares no `fieldPolicy`
+ *         (redaction cannot guess sensitivities).
+ */
+declare function redact<T extends {
+    type: string;
+}>(data: T, options?: RedactOptions): RedactedActivityData;
+/**
+ * Asserts that `data` is a learner-safe redacted projection: it carries the
+ * `redacted: true` marker and, when its type registers a strict redacted
+ * schema, validates against it (proving the absence of answer-key fields).
+ * Use this at the server boundary before sending activity data to a client
+ * that must not hold the key.
+ */
+declare function assertRedacted(data: unknown): asserts data is RedactedActivityData;
+
+/** Built-in Multiple Choice descriptor. */
+declare const multipleChoiceType: ActivityTypeDescriptor<MultipleChoiceData, MultipleChoiceLearnerResponse>;
+/** Built-in Fill-in-the-Blanks descriptor. */
+declare const fillInTheBlanksType: ActivityTypeDescriptor<FillInTheBlanksData, FillInTheBlanksLearnerResponse>;
+/**
+ * Built-in Written Response descriptor. Grading is DEFERRED: submissions are
+ * graded asynchronously (AI or human) by the consumer; the synchronous
+ * outcome reports only word-count facts. `wordCount` is recomputed from the
+ * submitted text with the canonical `countWords()` — the client-supplied
+ * count is informational, never trusted.
+ */
+declare const writtenResponseType: ActivityTypeDescriptor<WrittenResponseData, WrittenResponseLearnerResponse>;
 
 /**
  * All CSS custom property tokens consumed by learning-kit components.
@@ -53,4 +299,4 @@ interface ThemeTokens {
     '--lk-transition-base': string;
 }
 
-export { ActivitySchemaError, type ThemeTokens, UnknownActivityTypeError, ValidationError };
+export { ActivitySchemaError, type ActivityTypeDescriptor, type ActivityTypeInterop, type ActivityTypeScoring, DeferredScoringError, DeferredScoringPartial, type FieldPolicy, FillInTheBlanksData, FillInTheBlanksLearnerResponse, 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, multipleChoiceType, redact, registerActivityType, registeredActivityTypes, writtenResponseType };

package/dist/index.js

@@ -1,45 +1,224 @@
 import {
+  DEFAULT_PASS_THRESHOLD,
   computePassThreshold,
+  evaluate,
   score
-} from "./chunk-GZ73G2TS.js";
+} from "./chunk-QSVBYTNM.js";
 import {
   XAPIVerb,
   XAPI_VERB_DISPLAY,
   validateXAPIStatement,
   xAPIBuilder
-} from "./chunk-ZHOX6TO4.js";
+} from "./chunk-HS7BYCGE.js";
 import {
-  ActivitySchemaError,
-  UnknownActivityTypeError
-} from "./chunk-6VOCV4EX.js";
+  fillInTheBlanksJsonSchema,
+  jsonSchemaFor,
+  multipleChoiceJsonSchema,
+  validateActivity,
+  writtenResponseJsonSchema
+} from "./chunk-55O4M45K.js";
 import {
   BlankConfigSchema,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   MediaSchema,
+  MediaUrlSchema,
   MultipleChoiceDataSchema,
   MultipleChoiceOptionSchema,
-  fillInTheBlanksJsonSchema,
-  multipleChoiceJsonSchema,
-  validateActivity
-} from "./chunk-2T3IL7VL.js";
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedWrittenResponseDataSchema,
+  TextMatchPolicySchema,
+  WrittenResponseDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema,
+  countWords,
+  defineActivityType,
+  fillInTheBlanksType,
+  getActivityTypeDescriptor,
+  levenshteinDistance,
+  matchText,
+  multipleChoiceType,
+  registerActivityType,
+  registeredActivityTypes,
+  writtenResponseType
+} from "./chunk-5GJJHGY5.js";
+import {
+  ActivitySchemaError,
+  DeferredScoringError,
+  RedactedScoringError,
+  UnknownActivityTypeError
+} from "./chunk-3YAVDV5F.js";
+
+// src/redact.ts
+function mergePolicy(base, overrides) {
+  if (overrides === void 0) {
+    return base;
+  }
+  const merged = { ...base };
+  for (const [key, override] of Object.entries(overrides)) {
+    const current = merged[key];
+    merged[key] = typeof override === "object" && typeof current === "object" ? { ...current, ...override } : override;
+  }
+  return merged;
+}
+function isSensitivity(value) {
+  return typeof value === "string";
+}
+function keepField(sensitivity, reveal) {
+  if (sensitivity === "public") {
+    return true;
+  }
+  return sensitivity === "answer-key" && reveal === "after-submit";
+}
+function redactValue(value, policy, reveal) {
+  if (Array.isArray(value)) {
+    return value.map((element) => redactValue(element, policy, reveal));
+  }
+  if (value === null || typeof value !== "object") {
+    return void 0;
+  }
+  const source = value;
+  const output = {};
+  for (const [key, fieldValue] of Object.entries(source)) {
+    if (fieldValue === void 0) {
+      continue;
+    }
+    const classification = policy[key];
+    if (classification === void 0) {
+      continue;
+    }
+    if (isSensitivity(classification)) {
+      if (keepField(classification, reveal)) {
+        output[key] = fieldValue;
+      }
+      continue;
+    }
+    const nested = redactValue(fieldValue, classification, reveal);
+    if (nested !== void 0) {
+      output[key] = nested;
+    }
+  }
+  return output;
+}
+function redact(data, options = {}) {
+  const reveal = options.reveal ?? "none";
+  const descriptor = getActivityTypeDescriptor(data.type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(String(data.type));
+  }
+  if (descriptor.fieldPolicy === void 0) {
+    throw new Error(
+      `Activity type "${descriptor.type}" has no fieldPolicy; redact() cannot run fail-closed redaction without one.`
+    );
+  }
+  const effectivePolicy = mergePolicy(descriptor.fieldPolicy, options.policy);
+  const projected = redactValue(data, effectivePolicy, reveal);
+  const result = { ...projected, redacted: true };
+  if (reveal === "none" && descriptor.redactedSchema !== void 0) {
+    const parsed = descriptor.redactedSchema.safeParse(result);
+    if (!parsed.success) {
+      throw new ActivitySchemaError(
+        descriptor.type,
+        parsed.error.issues.map((issue) => ({
+          path: issue.path.map(String),
+          message: issue.message,
+          code: issue.code
+        }))
+      );
+    }
+  }
+  return result;
+}
+function assertRedacted(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new ActivitySchemaError("unknown", [
+      { path: [], message: "Redacted activity data must be an object.", code: "invalid_type" }
+    ]);
+  }
+  const candidate = data;
+  if (candidate.redacted !== true) {
+    throw new ActivitySchemaError(String(candidate.type ?? "unknown"), [
+      {
+        path: ["redacted"],
+        message: "Missing redacted marker \u2014 this payload is not a redact() projection.",
+        code: "custom"
+      }
+    ]);
+  }
+  const type = typeof candidate.type === "string" ? candidate.type : "";
+  const descriptor = getActivityTypeDescriptor(type);
+  if (descriptor === void 0) {
+    throw new UnknownActivityTypeError(type);
+  }
+  if (descriptor.redactedSchema === void 0) {
+    throw new ActivitySchemaError(descriptor.type, [
+      {
+        path: [],
+        message: `Activity type "${descriptor.type}" registers no redactedSchema; assertRedacted cannot prove this payload is learner-safe.`,
+        code: "custom"
+      }
+    ]);
+  }
+  const parsed = descriptor.redactedSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new ActivitySchemaError(
+      descriptor.type,
+      parsed.error.issues.map((issue) => ({
+        path: issue.path.map(String),
+        message: issue.message,
+        code: issue.code
+      }))
+    );
+  }
+}
 export {
   ActivitySchemaError,
   BlankConfigSchema,
+  DEFAULT_PASS_THRESHOLD,
+  DeferredScoringError,
   FeedbackSchema,
   FillInTheBlanksDataSchema,
   MediaSchema,
+  MediaUrlSchema,
   MultipleChoiceDataSchema,
   MultipleChoiceOptionSchema,
+  RedactedBlankConfigSchema,
+  RedactedFillInTheBlanksDataSchema,
+  RedactedMultipleChoiceDataSchema,
+  RedactedMultipleChoiceOptionSchema,
+  RedactedScoringError,
+  RedactedWrittenResponseDataSchema,
+  TextMatchPolicySchema,
   UnknownActivityTypeError,
+  WrittenResponseDataSchema,
+  WrittenResponseRubricCriterionSchema,
+  WrittenResponseRubricSchema,
   XAPIVerb,
   XAPI_VERB_DISPLAY,
+  assertRedacted,
   computePassThreshold,
+  countWords,
+  defineActivityType,
+  evaluate,
   fillInTheBlanksJsonSchema,
+  fillInTheBlanksType,
+  getActivityTypeDescriptor,
+  jsonSchemaFor,
+  levenshteinDistance,
+  matchText,
   multipleChoiceJsonSchema,
+  multipleChoiceType,
+  redact,
+  registerActivityType,
+  registeredActivityTypes,
   score,
   validateActivity,
   validateXAPIStatement,
+  writtenResponseJsonSchema,
+  writtenResponseType,
   xAPIBuilder
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"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":[]}

package/dist/schemas.cjs

@@ -4,11 +4,11 @@
 
 
 
+var _chunkYNTYWHZIcjs = require('./chunk-YNTYWHZI.cjs');
 
 
 
 
-var _chunkDCDOTQNHcjs = require('./chunk-DCDOTQNH.cjs');
 
 
 
@@ -19,5 +19,32 @@ var _chunkDCDOTQNHcjs = require('./chunk-DCDOTQNH.cjs');
 
 
 
-exports.BlankConfigSchema = _chunkDCDOTQNHcjs.BlankConfigSchema; exports.FeedbackSchema = _chunkDCDOTQNHcjs.FeedbackSchema; exports.FillInTheBlanksDataSchema = _chunkDCDOTQNHcjs.FillInTheBlanksDataSchema; exports.MediaSchema = _chunkDCDOTQNHcjs.MediaSchema; exports.MultipleChoiceDataSchema = _chunkDCDOTQNHcjs.MultipleChoiceDataSchema; exports.MultipleChoiceOptionSchema = _chunkDCDOTQNHcjs.MultipleChoiceOptionSchema; exports.fillInTheBlanksJsonSchema = _chunkDCDOTQNHcjs.fillInTheBlanksJsonSchema; exports.multipleChoiceJsonSchema = _chunkDCDOTQNHcjs.multipleChoiceJsonSchema; exports.validateActivity = _chunkDCDOTQNHcjs.validateActivity;
+
+
+
+var _chunkQOAORTA4cjs = require('./chunk-QOAORTA4.cjs');
+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;
 //# 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;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,koBAAC","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;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"}