@intellectif/lk-core 1.8.0 → 1.9.0

package/dist/{registry-Cymq7Ah0.cjs → registry-C9O9txy5.cjs}

@@ -463,7 +463,8 @@ const BUILT_IN_ACTIVITY_TYPES = [
 	"written-response",
 	"gap-select",
 	"dictation",
-	"read-aloud"
+	"read-aloud",
+	"speaking-response"
 ];
 /** Whether `type` names an activity type the SDK ships. */
 function isBuiltInActivityType(type) {
@@ -2371,7 +2372,24 @@ const DRAFT_ISSUE_SEVERITY = {
 	ra_media_kind: "invalid",
 	ra_slow_media_without_media: "incomplete",
 	ra_slow_media_same_recording: "invalid",
-	ra_slow_media_beside_play_limit: "invalid"
+	ra_slow_media_beside_play_limit: "invalid",
+	sr_prompt_required: "incomplete",
+	sr_locale_required: "incomplete",
+	sr_locale_invalid: "invalid",
+	sr_max_seconds_required: "incomplete",
+	sr_max_seconds_out_of_range: "invalid",
+	sr_min_seconds_out_of_range: "invalid",
+	sr_max_takes_out_of_range: "invalid",
+	sr_rubric_required: "incomplete",
+	sr_rubric_criteria_required: "incomplete",
+	sr_criterion_name_required: "incomplete",
+	sr_criterion_name_duplicate: "invalid",
+	sr_criterion_weight_required: "incomplete",
+	sr_criterion_weight_invalid: "invalid",
+	sr_criterion_measure_invalid: "invalid",
+	sr_criterion_measure_duplicate: "invalid",
+	sr_rubric_weights_zero: "incomplete",
+	sr_rubric_weights_too_large: "invalid"
 };
 function issue(code, path, message) {
 	return {
@@ -2586,7 +2604,7 @@ function checkDictationDraft(draft) {
 	const normalizer = dictationNormalizer(isRecord(draft.tolerance) ? draft.tolerance : void 0);
 	issues.push(...checkTranscript(draft.transcript, normalizer));
 	issues.push(...checkAcceptedTranscripts(draft, normalizer));
-	issues.push(...checkRecording$1(draft.media));
+	issues.push(...checkRecording$2(draft.media));
 	issues.push(...checkSlowRecording$1(draft));
 	issues.push(...checkRevealed(draft, normalizer));
 	issues.push(...checkHints(draft.hints));
@@ -2644,7 +2662,7 @@ function acceptedTranscriptEmpty(index) {
 	return issue("dc_accepted_transcript_empty", ["acceptedTranscripts", index], `Accepted transcript ${index + 1} has nothing to type. Fill it in or remove it.`);
 }
 /** The recording. Its address, description and playback are `checkSharedOptional`'s; the kind and the captions are this type's. */
-function checkRecording$1(media) {
+function checkRecording$2(media) {
 	if (!isRecord(media)) return [];
 	const issues = [];
 	const kind = media.type;
@@ -4172,8 +4190,8 @@ const readAloudAuthoring = {
 function checkReadAloudDraft(draft) {
 	const issues = checkIdentity(draft, "read-aloud");
 	issues.push(...checkReferenceText(draft.referenceText));
-	issues.push(...checkLocale(draft.locale));
-	issues.push(...checkRecording(draft.recording));
+	issues.push(...checkLocale$1(draft.locale));
+	issues.push(...checkRecording$1(draft.recording));
 	issues.push(...checkDimensions(draft.scoring));
 	issues.push(...checkModelRecording(draft.media));
 	issues.push(...checkSlowRecording(draft));
@@ -4190,7 +4208,7 @@ function checkReferenceText(referenceText) {
 	if (containsUnspacedScript(referenceText)) issues.push(issue("ra_reference_text_unspaced_script", ["referenceText"], "The text is written in a script that does not separate its words with spaces. Each word is marked on its own, and a run of Han, kana, Thai, Lao, Khmer or Myanmar letters would be marked as one word."));
 	return issues;
 }
-function checkLocale(locale) {
+function checkLocale$1(locale) {
 	if (isUnwritten(locale)) return [issue("ra_locale_required", ["locale"], "Choose the language the learner reads in, with its region — \"en-US\", not \"en\".")];
 	if (typeof locale !== "string" || CANONICAL_LOCALE_RE.test(locale)) return [];
 	return [issue("ra_locale_invalid", ["locale"], "The language must be a BCP 47 tag in canonical form, with a region: \"en-US\", \"es-419\", \"zh-Hant-TW\". Pronunciation is assessed against one locale's speech.")];
@@ -4200,7 +4218,7 @@ function checkLocale(locale) {
 * none of them decides a grade, but the longest take has to be set before a
 * recorder can be shown at all.
 */
-function checkRecording(recording) {
+function checkRecording$1(recording) {
 	if (isUnset(recording)) return [maxSecondsRequired()];
 	if (!isRecord(recording)) return [];
 	const issues = [];
@@ -4300,6 +4318,217 @@ function checkSlowRecording(draft) {
 	if (typeof slow.url === "string" && slow.url !== "" && slow.url === media.url) issues.push(issue("ra_slow_media_same_recording", ["slowMedia", "url"], "The slow model recording is the same file as the recording. Point it at the slower reading."));
 	return issues;
 }
+// src/schemas/speaking-response.ts
+/** The engine measures a speaking criterion can be scored from. */
+const SPEAKING_MEASURES = [
+	"pronunciation",
+	"fluency",
+	"prosody"
+];
+/** One criterion: a written-response criterion, and the measure that may score it. Loose: a sidecar survives. */
+const SpeakingRubricCriterionSchema = zod_v4.looseObject({
+	name: zod_v4.string().min(1),
+	description: zod_v4.string().optional(),
+	weight: zod_v4.number().min(0),
+	measure: zod_v4.enum(SPEAKING_MEASURES).optional()
+});
+const SpeakingRubricSchema = zod_v4.looseObject({
+	label: zod_v4.string().optional(),
+	criteria: zod_v4.array(SpeakingRubricCriterionSchema).min(1)
+});
+/** The limits on a take, as a read-aloud's. Loose, like every content object. */
+const SpeakingRecordingBoundsSchema = zod_v4.looseObject({
+	maxSeconds: zod_v4.number().gt(0).max(300),
+	minSeconds: zod_v4.number().min(0).optional(),
+	maxTakes: zod_v4.number().int().min(1).max(20).optional()
+});
+/**
+* Zod schema validating the full Speaking Response data contract.
+*
+* Four semantic guards, none expressible in JSON Schema, each an authoring
+* error that would otherwise reach a grade:
+*
+* 1. **No two criteria share a name** (case and spacing aside): a judgement
+*    names the criterion it scores, and two of one name leave it unsaid which.
+* 2. **Some criterion carries a weight above 0**, or there is no weighted total
+*    and every answer would be unscorable.
+* 3. **No measure scores two criteria**: the engine reports one fluency, and
+*    two criteria scored from it would weigh it twice under two names.
+* 4. **The shortest take is shorter than the longest.**
+*
+* The guards run even when an unrelated field was refused, but a guard that
+* reads a field zod refused waits until that field parses.
+*/
+const SpeakingResponseDataSchema = zod_v4.looseObject({
+	schemaVersion: zod_v4.literal("1.0"),
+	type: zod_v4.literal("speaking-response"),
+	id: zod_v4.string().min(1),
+	title: zod_v4.string().min(1),
+	instructions: zod_v4.string().optional(),
+	prompt: zod_v4.string(),
+	promptHtml: zod_v4.string().optional(),
+	locale: zod_v4.string().regex(CANONICAL_LOCALE_RE, { error: "The locale must be a BCP 47 tag in canonical form, with a region: \"en-US\", \"es-419\". Pronunciation is measured against one locale's speech, and \"en\" does not say whose." }),
+	media: MediaSchema.optional(),
+	recording: SpeakingRecordingBoundsSchema,
+	rubric: SpeakingRubricSchema,
+	languageTarget: zod_v4.string().optional(),
+	passThreshold: zod_v4.number().min(0).max(1).optional(),
+	feedback: FeedbackSchema.optional(),
+	learningObjectives: zod_v4.array(zod_v4.string()).optional(),
+	difficultyLevel: zod_v4.literal([
+		1,
+		2,
+		3,
+		4,
+		5
+	]).optional(),
+	ai: AiPermissionsSchema.optional()
+}).check(checkEvenAfterIssues((ctx) => {
+	if (ctx.issues.some((issue) => (issue.path?.length ?? 0) === 0)) return;
+	const { data, refused } = parsedFields(ctx);
+	const report = (path, input, message) => {
+		ctx.issues.push({
+			code: "custom",
+			input,
+			message,
+			path: [...path]
+		});
+	};
+	if (!refused.has("rubric")) {
+		const criteria = data.rubric.criteria;
+		const names = /* @__PURE__ */ new Set();
+		const measures = /* @__PURE__ */ new Set();
+		for (const [index, criterion] of criteria.entries()) {
+			const key = levelKey(criterion.name);
+			if (names.has(key)) report([
+				"rubric",
+				"criteria",
+				index,
+				"name"
+			], criterion.name, `Another criterion is already called "${criterion.name}": a judgement names the criterion it scores, and two of one name leave it unsaid which.`);
+			names.add(key);
+			if (criterion.measure !== void 0) {
+				if (measures.has(criterion.measure)) report([
+					"rubric",
+					"criteria",
+					index,
+					"measure"
+				], criterion.measure, `Another criterion is already scored from ${criterion.measure}: the engine reports it once, and two criteria scored from it weigh it twice.`);
+				measures.add(criterion.measure);
+			}
+		}
+		if (criteria.every((criterion) => criterion.weight === 0)) report(["rubric", "criteria"], criteria, "At least one criterion must carry a weight above 0: with every weight at 0 there is no weighted total, and every answer would be unscorable.");
+	}
+	if (!refused.has("recording")) {
+		const { minSeconds, maxSeconds } = data.recording;
+		if (minSeconds !== void 0 && minSeconds >= maxSeconds) report(["recording", "minSeconds"], minSeconds, "The shortest take must be shorter than the longest.");
+	}
+}));
+// src/authoring/speaking-response.ts
+/**
+* Draft support for `speaking-response`.
+*
+* A new draft has no prompt, no locale, no recording time and a rubric with no
+* criteria: the length of an answer, its language and what it is graded on are
+* teaching decisions, and the SDK picks none of them. Each is reported
+* `incomplete` until it is set.
+*
+* Stricter than the schema in the places written-response is — a blank plain
+* prompt beside a rich one, a criterion named only with spaces, weights that
+* are all 0 or add up past what a number holds — and in the ones read-aloud
+* is: a locale that is not canonical, bounds outside their range.
+*/
+const speakingResponseAuthoring = {
+	createDraft: ({ newId }) => ({
+		schemaVersion: "1.0",
+		type: "speaking-response",
+		id: newId(),
+		title: "",
+		prompt: "",
+		locale: "",
+		recording: { maxSeconds: 0 },
+		rubric: { criteria: [] }
+	}),
+	checkDraft: checkSpeakingResponseDraft
+};
+function checkSpeakingResponseDraft(draft) {
+	const issues = checkIdentity(draft, "speaking-response");
+	if (isUnwritten(draft.prompt)) issues.push(issue("sr_prompt_required", ["prompt"], isUnwritten(draft.promptHtml) ? "Write the prompt the learner answers." : "Write the prompt as plain text too. The rich-text prompt is shown only where a sanitiser is supplied; the plain text is shown everywhere else."));
+	issues.push(...checkLocale(draft.locale));
+	issues.push(...checkRecording(draft.recording));
+	issues.push(...checkRubric(draft.rubric));
+	issues.push(...checkSharedOptional(draft));
+	return issues;
+}
+function checkLocale(locale) {
+	if (isUnwritten(locale)) return [issue("sr_locale_required", ["locale"], "Choose the language the learner answers in, with its region — \"en-US\", not \"en\".")];
+	if (typeof locale !== "string" || CANONICAL_LOCALE_RE.test(locale)) return [];
+	return [issue("sr_locale_invalid", ["locale"], "The language must be a BCP 47 tag in canonical form, with a region: \"en-US\", \"es-419\". Pronunciation is measured against one locale's speech.")];
+}
+function checkRecording(recording) {
+	const required = issue("sr_max_seconds_required", ["recording", "maxSeconds"], "Set how long an answer may be, in seconds.");
+	if (isUnset(recording)) return [required];
+	if (!isRecord(recording)) return [];
+	const issues = [];
+	const max = recording.maxSeconds;
+	if (isUnset(max) || max === 0) issues.push(required);
+	else if (typeof max === "number" && !(Number.isFinite(max) && max > 0 && max <= 300)) issues.push(issue("sr_max_seconds_out_of_range", ["recording", "maxSeconds"], `An answer is at most 300 seconds long.`));
+	const min = recording.minSeconds;
+	const minOut = (message) => issue("sr_min_seconds_out_of_range", ["recording", "minSeconds"], message);
+	if (typeof min === "number" && !(Number.isFinite(min) && min >= 0)) issues.push(minOut("The shortest answer is a number of seconds, 0 or more."));
+	else if (typeof min === "number" && typeof max === "number" && max > 0 && min >= max) issues.push(minOut("The shortest answer must be shorter than the longest."));
+	const takes = recording.maxTakes;
+	if (typeof takes === "number" && !(isWholeNumber(takes) && takes >= 1 && takes <= 20)) issues.push(issue("sr_max_takes_out_of_range", ["recording", "maxTakes"], `How many takes a learner may record is a whole number from 1 to 20.`));
+	return issues;
+}
+const MEASURES = SPEAKING_MEASURES;
+function checkRubric(rubric) {
+	if (isUnset(rubric)) return [issue("sr_rubric_required", ["rubric"], "Add the rubric the answer is graded on.")];
+	if (!isRecord(rubric)) return [];
+	const criteria = isUnset(rubric.criteria) ? [] : rubric.criteria;
+	if (!Array.isArray(criteria)) return [];
+	if (criteria.length === 0) return [issue("sr_rubric_criteria_required", ["rubric", "criteria"], "Add at least one rubric criterion: what the answer is graded on.")];
+	const issues = [];
+	const names = /* @__PURE__ */ new Set();
+	const measures = /* @__PURE__ */ new Set();
+	let totalWeight = 0;
+	let everyWeightUsable = true;
+	for (const [index, criterion] of criteria.entries()) {
+		if (!isRecord(criterion)) {
+			everyWeightUsable = false;
+			continue;
+		}
+		const ordinal = index + 1;
+		const path = [
+			"rubric",
+			"criteria",
+			index
+		];
+		if (isUnwritten(criterion.name)) issues.push(issue("sr_criterion_name_required", [...path, "name"], `Name rubric criterion ${ordinal}.`));
+		else if (typeof criterion.name === "string") {
+			const key = levelKey(criterion.name);
+			if (names.has(key)) issues.push(issue("sr_criterion_name_duplicate", [...path, "name"], `Another criterion is already called "${criterion.name}". A judgement names the criterion it scores, so names must differ.`));
+			names.add(key);
+		}
+		const weight = criterion.weight;
+		if (isUnset(weight)) {
+			everyWeightUsable = false;
+			issues.push(issue("sr_criterion_weight_required", [...path, "weight"], `Give rubric criterion ${ordinal} a weight.`));
+		} else if (!(typeof weight === "number" && Number.isFinite(weight) && weight >= 0)) {
+			everyWeightUsable = false;
+			issues.push(issue("sr_criterion_weight_invalid", [...path, "weight"], "A rubric weight must be a number, 0 or more."));
+		} else totalWeight += weight;
+		const measure = criterion.measure;
+		if (measure !== void 0) {
+			if (!MEASURES.includes(measure)) issues.push(issue("sr_criterion_measure_invalid", [...path, "measure"], `A criterion is scored from ${SPEAKING_MEASURES.join(", ")}, or by the judge when it names no measure.`));
+			else if (measures.has(measure)) issues.push(issue("sr_criterion_measure_duplicate", [...path, "measure"], `Another criterion is already scored from ${String(measure)}: the engine reports it once, and two criteria scored from it would weigh it twice.`));
+			measures.add(measure);
+		}
+	}
+	if (everyWeightUsable && totalWeight === 0) issues.push(issue("sr_rubric_weights_zero", ["rubric", "criteria"], "Give at least one rubric criterion a weight above 0. With every weight at 0, no weighted total can be computed."));
+	else if (totalWeight === Number.POSITIVE_INFINITY) issues.push(issue("sr_rubric_weights_too_large", ["rubric", "criteria"], "The rubric weights add up to more than can be calculated with. Use smaller weights."));
+	return issues;
+}
 // src/authoring/written-response.ts
 /**
 * Draft support for `written-response`.
@@ -4829,6 +5058,34 @@ const RedactedReadAloudDataSchema = zod_v4.strictObject({
 		path: ["slowMedia", "url"]
 	});
 });
+/**
+* Redacted Speaking Response data: everything a learner needs to answer — the
+* prompt, the picture or recording, the limits of a take — and the rubric, which
+* tells them what the answer is graded on, as a written response's does (a
+* deployment may hide it per call). Only the authored pass/fail feedback is
+* removed: it is written about a grade that does not exist yet.
+*/
+const RedactedSpeakingResponseDataSchema = zod_v4.strictObject({
+	...redactedBase,
+	type: zod_v4.literal("speaking-response"),
+	locale: zod_v4.string().regex(CANONICAL_LOCALE_RE),
+	instructions: zod_v4.string().optional(),
+	prompt: zod_v4.string(),
+	promptHtml: zod_v4.string().optional(),
+	recording: zod_v4.strictObject({
+		maxSeconds: zod_v4.number().gt(0).max(300),
+		minSeconds: zod_v4.number().min(0).optional(),
+		maxTakes: zod_v4.number().int().min(1).max(20).optional()
+	}),
+	rubric: zod_v4.strictObject({
+		label: zod_v4.string().optional(),
+		criteria: zod_v4.array(zod_v4.strictObject({
+			...RedactedWrittenResponseRubricCriterionSchema.shape,
+			measure: zod_v4.enum(SPEAKING_MEASURES).optional()
+		})).min(1)
+	}).optional(),
+	languageTarget: zod_v4.string().optional()
+});
 // src/scoring/activity-scorers/dictation.ts
 /**
 * Scores a Dictation response: the character-level similarity of what the
@@ -5433,6 +5690,34 @@ const READ_ALOUD_FIELD_POLICY = {
 	feedback: FEEDBACK_FIELD_POLICY
 };
 /**
+* Speaking Response: public, as written-response is. The task, the picture and
+* the limits of a take are what the learner needs to answer; the rubric tells
+* them what the answer is graded on — classified key by key, a criterion's
+* `measure` included, so nothing parked on it reaches a learner. A deployment
+* that wants the rubric hidden tightens it per call: the redacted schema leaves
+* it optional. Only the authored pass/fail feedback is removed.
+*/
+const SPEAKING_RESPONSE_FIELD_POLICY = {
+	...SHARED_PUBLIC_FIELDS,
+	instructions: "public",
+	prompt: "public",
+	promptHtml: "public",
+	recording: {
+		maxSeconds: "public",
+		minSeconds: "public",
+		maxTakes: "public"
+	},
+	languageTarget: "public",
+	feedback: FEEDBACK_FIELD_POLICY,
+	rubric: {
+		...RUBRIC_FIELD_POLICY,
+		criteria: {
+			...RUBRIC_FIELD_POLICY.criteria,
+			measure: "public"
+		}
+	}
+};
+/**
 * Whether a response carries a stored recording: an object whose `key` is a
 * non-empty string. Read defensively, because both callers are handed whatever
 * an application stored — `evaluate()` passes `partial` a response that may be
@@ -5487,7 +5772,32 @@ const BUILT_IN_DESCRIPTORS = {
 	"written-response": writtenResponseType,
 	"gap-select": gapSelectType,
 	dictation: dictationType,
-	"read-aloud": readAloudType
+	"read-aloud": readAloudType,
+	"speaking-response": defineActivityType({
+		type: "speaking-response",
+		schema: SpeakingResponseDataSchema,
+		scoring: {
+			kind: "deferred",
+			reason: "requires_async_grading",
+			partial: (_data, response) => ({ hasRecording: hasRecording(response) })
+		},
+		isAnswered: (response) => hasRecording(response),
+		fieldPolicy: SPEAKING_RESPONSE_FIELD_POLICY,
+		redactedSchema: RedactedSpeakingResponseDataSchema,
+		interop: {
+			xapiActivityTypeIri: "http://adlnet.gov/expapi/activities/cmi.interaction",
+			xapiInteractionType: "other",
+			correctResponsesPattern: () => []
+		},
+		interactions: [
+			"recording-started",
+			"recording-stopped",
+			"recording-uploaded",
+			"submitted"
+		],
+		authoring: speakingResponseAuthoring,
+		mediaSlots: () => MAIN_MEDIA
+	})
 };
 // src/schemas/read-schema.ts
 /**
@@ -5819,6 +6129,12 @@ Object.defineProperty(exports, "SCRIPT_MAX_TURNS", {
 		return SCRIPT_MAX_TURNS;
 	}
 });
+Object.defineProperty(exports, "SPEAKING_MEASURES", {
+	enumerable: true,
+	get: function() {
+		return SPEAKING_MEASURES;
+	}
+});
 Object.defineProperty(exports, "SPEECH_ASSESSMENT_MAX_TEXT_LENGTH", {
 	enumerable: true,
 	get: function() {
@@ -5843,6 +6159,12 @@ Object.defineProperty(exports, "ScriptSchema", {
 		return ScriptSchema;
 	}
 });
+Object.defineProperty(exports, "SpeakingResponseDataSchema", {
+	enumerable: true,
+	get: function() {
+		return SpeakingResponseDataSchema;
+	}
+});
 Object.defineProperty(exports, "UnknownActivityTypeError", {
 	enumerable: true,
 	get: function() {
@@ -6162,4 +6484,4 @@ Object.defineProperty(exports, "writtenResponseType", {
 	}
 });
 
-//# sourceMappingURL=registry-Cymq7Ah0.cjs.map
+//# sourceMappingURL=registry-C9O9txy5.cjs.map