@intellectif/lk-core 1.3.0 → 1.5.0

package/dist/{registry-Dsx9mNsS.js → registry-DaZRpqjW.js}

@@ -2732,6 +2732,97 @@ function countWords(text) {
 	if (trimmed === "") return 0;
 	return trimmed.split(/\s+/).length;
 }
+/** A label as labels are compared: composed, trimmed, its spacing collapsed, lower-cased. */
+function levelKey(label) {
+	return label.normalize("NFC").trim().replace(/\s+/gu, " ").toLowerCase();
+}
+/**
+* The levels in `value`, or the first reason they cannot be used. `null` or
+* absent means the criterion has no levels, which is not a problem: it is
+* judged on a score.
+*
+* Each element and each field is read once, so a getter cannot pass the check
+* with one value and hand the grader another. The levels come back as written.
+*/
+function readRubricLevels(value) {
+	if (value === void 0 || value === null) return {
+		ok: true,
+		levels: null
+	};
+	if (!Array.isArray(value)) return {
+		ok: false,
+		problem: "not-a-list"
+	};
+	const count = value.length;
+	if (count < 2) return {
+		ok: false,
+		problem: "too-few"
+	};
+	if (count > 10) return {
+		ok: false,
+		problem: "too-many"
+	};
+	const levels = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let index = 0; index < count; index += 1) {
+		const entry = value[index];
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return {
+			ok: false,
+			problem: "not-a-level",
+			index
+		};
+		const record = entry;
+		const label = record.label;
+		const description = record.description;
+		if (typeof label !== "string" || label.trim() === "") return {
+			ok: false,
+			problem: "no-label",
+			index
+		};
+		if (description !== void 0 && typeof description !== "string") return {
+			ok: false,
+			problem: "bad-description",
+			index
+		};
+		const key = levelKey(label);
+		if (seen.has(key)) return {
+			ok: false,
+			problem: "duplicate-label",
+			index
+		};
+		seen.add(key);
+		levels.push({
+			label,
+			...description !== void 0 ? { description } : {}
+		});
+	}
+	return {
+		ok: true,
+		levels
+	};
+}
+/**
+* How far level probabilities may sum from 1 and still be a distribution:
+* rounding in a grader's output, not a different judgement.
+*/
+const LEVEL_PROBABILITY_TOLERANCE = 1e-6;
+/**
+* `values` as a distribution over `count` levels whose likeliest is level
+* `chosen`, a tie for likeliest included: each a finite number from 0 to 1,
+* together 1 within {@link LEVEL_PROBABILITY_TOLERANCE}. `null` when they are
+* not one.
+*
+* The AI check refuses a reply whose probabilities are not a distribution, and
+* calibration and routing read a grade's the same way, so probabilities the
+* check let through are never ignored downstream. Each element is read once,
+* a hole as `undefined`, into the copy returned.
+*/
+function levelDistribution(values, count, chosen) {
+	const read = Array.from(values);
+	if (read.length !== count || !read.every((p) => typeof p === "number" && p >= 0 && p <= 1)) return null;
+	const sum = read.reduce((total, p) => total + p, 0);
+	return Math.abs(sum - 1) <= 1e-6 && read[chosen] === Math.max(...read) ? read : null;
+}
 //#endregion
 //#region src/scoring/strategies/all-or-nothing.ts
 /**
@@ -2948,6 +3039,7 @@ const ITEM_FINDING_SEVERITY = {
 	gs_bank_no_distractor: "warning",
 	gs_answer_in_passage: "warning",
 	wr_criterion_name_duplicate: "warning",
+	wr_levels_unreadable: "warning",
 	ra_text_long_for_time: "warning",
 	set_key_position_same: "warning"
 };
@@ -3198,14 +3290,38 @@ function critiqueGapSelect(draft) {
 	});
 	return findings;
 }
+/** Why a criterion's levels cannot be graded on, said to the author. */
+const LEVELS_PROBLEM = {
+	"not-a-list": (criterion) => `Criterion ${criterion}'s levels are not a list`,
+	"too-few": (criterion) => `Criterion ${criterion} has fewer than 2 levels`,
+	"too-many": (criterion) => `Criterion ${criterion} has more than 10 levels`,
+	"not-a-level": (criterion, level) => `Level ${level} of criterion ${criterion} is not a level`,
+	"no-label": (criterion, level) => `Level ${level} of criterion ${criterion} has no label`,
+	"bad-description": (criterion, level) => `Level ${level} of criterion ${criterion} has a description that is not text`,
+	"duplicate-label": (criterion, level) => `Level ${level} of criterion ${criterion} has the label of an earlier level`
+};
 function critiqueWrittenResponse(draft) {
 	const rubric = isRecord(draft.rubric) ? draft.rubric : void 0;
-	return duplicates(rubric === void 0 ? [] : listOf(rubric.criteria), (criterion) => isRecord(criterion) ? written(criterion.name) : void 0).map(({ first, second }) => finding("wr_criterion_name_duplicate", [
+	const criteria = rubric === void 0 ? [] : listOf(rubric.criteria);
+	const names = duplicates(criteria, (criterion) => isRecord(criterion) ? written(criterion.name) : void 0).map(({ first, second }) => finding("wr_criterion_name_duplicate", [
 		"rubric",
 		"criteria",
 		second,
 		"name"
 	], `Criteria ${ordinal(first)} and ${ordinal(second)} have the same name. Feedback and grades name a criterion, so one of them cannot be told apart.`));
+	const levels = criteria.flatMap((criterion, index) => {
+		if (!isRecord(criterion)) return [];
+		const read = readRubricLevels(criterion.levels);
+		if (read.ok) return [];
+		const level = ordinal(read.index ?? 0);
+		return [finding("wr_levels_unreadable", [
+			"rubric",
+			"criteria",
+			index,
+			"levels"
+		], `${LEVELS_PROBLEM[read.problem](ordinal(index), level)}, so a grader cannot judge against them.`)];
+	});
+	return [...names, ...levels];
 }
 /** 150 words a minute: a fluent adult reading aloud. A learner is slower. */
 const WORDS_PER_SECOND = 2.5;
@@ -4387,7 +4503,11 @@ const WrittenResponseRubricSchema = z.looseObject({
 const RedactedWrittenResponseRubricCriterionSchema = z.strictObject({
 	name: z.string().min(1),
 	description: z.string().optional(),
-	weight: z.number().min(0)
+	weight: z.number().min(0),
+	levels: z.array(z.strictObject({
+		label: z.string().min(1),
+		description: z.string().optional()
+	})).min(2).max(10).optional()
 });
 const RedactedWrittenResponseRubricSchema = z.strictObject({
 	label: z.string().optional(),
@@ -4829,6 +4949,32 @@ function defineActivityType(descriptor) {
 	return descriptor;
 }
 //#endregion
+//#region src/registry/keep-when.ts
+/**
+* A nested field policy that keeps its field only when the field's value
+* passes a test. Internal: the symbol is never exported, so no host policy can
+* carry one, and `FieldPolicy`'s string keys never see it.
+*
+* It can only drop a field the policy would otherwise emit, never emit one it
+* would drop, so redaction stays fail-closed. It exists for a field
+* `validateActivity` does not check in 1.x — a rubric criterion's `levels` —
+* whose malformed values would otherwise reach the strict redacted schema and
+* make `redact()` throw on content it accepted before.
+*/
+const KEEP_WHEN = Symbol("lk.keepWhen");
+/** `policy`, kept only for values `test` accepts. */
+function keepWhen(policy, test) {
+	const guarded = {
+		...policy,
+		[KEEP_WHEN]: test
+	};
+	return Object.freeze(guarded);
+}
+/** The test a nested policy keeps its field by, when it has one. */
+function guardOf(policy) {
+	return policy[KEEP_WHEN];
+}
+//#endregion
 //#region src/registry/builtins.ts
 /**
 * Field-sensitivity policies for the built-in types (R7). Fail-closed:
@@ -5046,7 +5192,11 @@ const RUBRIC_FIELD_POLICY = {
 	criteria: {
 		name: "public",
 		description: "public",
-		weight: "public"
+		weight: "public",
+		levels: keepWhen({
+			label: "public",
+			description: "public"
+		}, (value) => readRubricLevels(value).ok)
 	}
 };
 const WRITTEN_RESPONSE_FIELD_POLICY = {
@@ -5444,6 +5594,6 @@ function registeredActivityTypes() {
 	return [...registry.keys()];
 }
 //#endregion
-export { dictationReferenceWords as $, matchText as A, issue as B, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as C, keyPositionFinding as D, MultipleChoiceOptionMediaSchema as E, covers as F, groupCaptionsField as G, refusesEmpty as H, isMissingId as I, RedactedScoringError as J, ActivitySchemaError as K, isRecord as L, DRAFT_ISSUE_SEVERITY as M, checkMedia as N, normaliseFinding as O, coveredPathsOf as P, alignSequences as Q, isUnset as R, READ_ALOUD_MAX_TAKES as S, MultipleChoiceDataSchema as T, DictationDataSchema as U, pathKey as V, GROUP_CAPTIONS_REVEAL_DICTATION as W, STEP as X, UnknownActivityTypeError as Y, alignDictation as Z, ReadAloudDataSchema as _, MediaSchema as _t, readSchema as a, codePointLength as at, READ_ALOUD_MAX_REFERENCE_LENGTH as b, dictationType as c, BUILT_IN_ACTIVITY_TYPES as ct, multipleChoiceType as d, containsWords as dt, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as et, readAloudType as f, fold as ft, GapSelectDataSchema as g, FillInTheBlanksDataSchema as gt, WrittenResponseDataSchema as h, revealsAnswer as ht, isOwnSchema as i, DICTATION_MAX_TRANSCRIPT_LENGTH as it, countWords as j, levenshteinDistance as k, fillInTheBlanksType as l, everyBuiltInTypeHandled as lt, defineActivityType as m, placeholderOrder as mt, registerActivityType as n, DICTATION_MAX_EQUIVALENCE_LENGTH as nt, standardJsonSchemaOf as o, normalizeDictationText as ot, writtenResponseType as p, numberedPassage as pt, DeferredScoringError as q, registeredActivityTypes as r, DICTATION_MAX_TEXT_LENGTH as rt, MEDIA_FIELD_POLICY as s, withValidationScope as st, getActivityTypeDescriptor as t, DICTATION_MAX_EQUIVALENCES as tt, gapSelectType as u, isBuiltInActivityType as ut, CANONICAL_LOCALE_RE as v, RedactedMediaSchema as vt, SPEECH_ASSESSMENT_MAX_WORDS as w, READ_ALOUD_MAX_SECONDS as x, READ_ALOUD_MAX_DIMENSION_WEIGHT as y, maxUnits as yt, isUnwritten as z };
+export { RedactedScoringError as $, levenshteinDistance as A, covers as B, READ_ALOUD_MAX_TAKES as C, RedactedMediaSchema as Ct, MultipleChoiceOptionMediaSchema as D, MultipleChoiceDataSchema as E, readRubricLevels as F, issue as G, isRecord as H, countWords as I, DictationDataSchema as J, pathKey as K, DRAFT_ISSUE_SEVERITY as L, LEVEL_PROBABILITY_TOLERANCE as M, levelDistribution as N, keyPositionFinding as O, levelKey as P, DeferredScoringError as Q, checkMedia as R, READ_ALOUD_MAX_SECONDS as S, MediaSchema as St, SPEECH_ASSESSMENT_MAX_WORDS as T, isUnset as U, isMissingId as V, isUnwritten as W, groupCaptionsField as X, GROUP_CAPTIONS_REVEAL_DICTATION as Y, ActivitySchemaError as Z, GapSelectDataSchema as _, fold as _t, readSchema as a, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as at, READ_ALOUD_MAX_DIMENSION_WEIGHT as b, revealsAnswer as bt, dictationType as c, DICTATION_MAX_TEXT_LENGTH as ct, multipleChoiceType as d, normalizeDictationText as dt, UnknownActivityTypeError as et, readAloudType as f, withValidationScope as ft, WrittenResponseDataSchema as g, containsWords as gt, defineActivityType as h, isBuiltInActivityType as ht, isOwnSchema as i, dictationReferenceWords as it, matchText as j, normaliseFinding as k, fillInTheBlanksType as l, DICTATION_MAX_TRANSCRIPT_LENGTH as lt, guardOf as m, everyBuiltInTypeHandled as mt, registerActivityType as n, alignDictation as nt, standardJsonSchemaOf as o, DICTATION_MAX_EQUIVALENCES as ot, writtenResponseType as p, BUILT_IN_ACTIVITY_TYPES as pt, refusesEmpty as q, registeredActivityTypes as r, alignSequences as rt, MEDIA_FIELD_POLICY as s, DICTATION_MAX_EQUIVALENCE_LENGTH as st, getActivityTypeDescriptor as t, STEP as tt, gapSelectType as u, codePointLength as ut, ReadAloudDataSchema as v, numberedPassage as vt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as w, maxUnits as wt, READ_ALOUD_MAX_REFERENCE_LENGTH as x, FillInTheBlanksDataSchema as xt, CANONICAL_LOCALE_RE as y, placeholderOrder as yt, coveredPathsOf as z };
 
-//# sourceMappingURL=registry-Dsx9mNsS.js.map
+//# sourceMappingURL=registry-DaZRpqjW.js.map