@intellectif/lk-core 1.8.0 → 1.9.0

package/dist/{registry-tkacvJUI.js → registry-Bw9grsCN.js}

@@ -441,7 +441,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) {
@@ -2349,7 +2350,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 {
@@ -2564,7 +2582,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));
@@ -2622,7 +2640,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;
@@ -4150,8 +4168,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));
@@ -4168,7 +4186,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.")];
@@ -4178,7 +4196,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 = [];
@@ -4278,6 +4296,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 = z.looseObject({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	weight: z.number().min(0),
+	measure: z.enum(SPEAKING_MEASURES).optional()
+});
+const SpeakingRubricSchema = z.looseObject({
+	label: z.string().optional(),
+	criteria: z.array(SpeakingRubricCriterionSchema).min(1)
+});
+/** The limits on a take, as a read-aloud's. Loose, like every content object. */
+const SpeakingRecordingBoundsSchema = z.looseObject({
+	maxSeconds: z.number().gt(0).max(300),
+	minSeconds: z.number().min(0).optional(),
+	maxTakes: z.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 = z.looseObject({
+	schemaVersion: z.literal("1.0"),
+	type: z.literal("speaking-response"),
+	id: z.string().min(1),
+	title: z.string().min(1),
+	instructions: z.string().optional(),
+	prompt: z.string(),
+	promptHtml: z.string().optional(),
+	locale: z.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: z.string().optional(),
+	passThreshold: z.number().min(0).max(1).optional(),
+	feedback: FeedbackSchema.optional(),
+	learningObjectives: z.array(z.string()).optional(),
+	difficultyLevel: z.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`.
@@ -4807,6 +5036,34 @@ const RedactedReadAloudDataSchema = z.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 = z.strictObject({
+	...redactedBase,
+	type: z.literal("speaking-response"),
+	locale: z.string().regex(CANONICAL_LOCALE_RE),
+	instructions: z.string().optional(),
+	prompt: z.string(),
+	promptHtml: z.string().optional(),
+	recording: z.strictObject({
+		maxSeconds: z.number().gt(0).max(300),
+		minSeconds: z.number().min(0).optional(),
+		maxTakes: z.number().int().min(1).max(20).optional()
+	}),
+	rubric: z.strictObject({
+		label: z.string().optional(),
+		criteria: z.array(z.strictObject({
+			...RedactedWrittenResponseRubricCriterionSchema.shape,
+			measure: z.enum(SPEAKING_MEASURES).optional()
+		})).min(1)
+	}).optional(),
+	languageTarget: z.string().optional()
+});
 // src/scoring/activity-scorers/dictation.ts
 /**
 * Scores a Dictation response: the character-level similarity of what the
@@ -5411,6 +5668,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
@@ -5465,7 +5750,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
 /**
@@ -5629,6 +5939,6 @@ function getActivityTypeDescriptor(type) {
 function registeredActivityTypes() {
 	return [...registry.keys()];
 }
-export { ActivitySchemaError as $, normaliseFinding as A, maxUnits as At, checkMedia as B, READ_ALOUD_MAX_TAKES as C, revealsAnswer as Ct, MultipleChoiceOptionMediaSchema as D, RedactedMediaSchema as Dt, MultipleChoiceDataSchema as E, MediaSchema as Et, levelDistribution as F, isUnset as G, covers as H, levelKey as I, pathKey as J, isUnwritten as K, readRubricLevels as L, levenshteinDistance as M, matchText as N, keyPositionFinding as O, SCRIPT_MAX_TURNS as Ot, LEVEL_PROBABILITY_TOLERANCE as P, groupCaptionsField as Q, countWords as R, READ_ALOUD_MAX_SECONDS as S, placeholderOrder as St, SPEECH_ASSESSMENT_MAX_WORDS as T, PLACEHOLDER_RE as Tt, isMissingId as U, coveredPathsOf as V, isRecord as W, DictationDataSchema as X, refusesEmpty as Y, GROUP_CAPTIONS_REVEAL_DICTATION as Z, GapSelectDataSchema as _, isBuiltInActivityType as _t, readSchema as a, alignSequences as at, READ_ALOUD_MAX_DIMENSION_WEIGHT as b, numberedPassage as bt, dictationType as c, DICTATION_MAX_EQUIVALENCES as ct, multipleChoiceType as d, DICTATION_MAX_TRANSCRIPT_LENGTH as dt, DeferredScoringError as et, readAloudType as f, codePointLength as ft, WrittenResponseDataSchema as g, everyBuiltInTypeHandled as gt, defineActivityType as h, BUILT_IN_ACTIVITY_TYPES as ht, isOwnSchema as i, alignDictation as it, policyFor as j, finding as k, ScriptSchema as kt, fillInTheBlanksType as l, DICTATION_MAX_EQUIVALENCE_LENGTH as lt, guardOf as m, withValidationScope as mt, registerActivityType as n, UnknownActivityTypeError as nt, standardJsonSchemaOf as o, dictationReferenceWords as ot, writtenResponseType as p, normalizeDictationText as pt, issue as q, registeredActivityTypes as r, STEP as rt, MEDIA_FIELD_POLICY as s, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as st, getActivityTypeDescriptor as t, RedactedScoringError as tt, gapSelectType as u, DICTATION_MAX_TEXT_LENGTH as ut, ReadAloudDataSchema as v, containsWords as vt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as w, FillInTheBlanksDataSchema as wt, READ_ALOUD_MAX_REFERENCE_LENGTH as x, passageWithoutPlaceholders as xt, CANONICAL_LOCALE_RE as y, fold as yt, DRAFT_ISSUE_SEVERITY as z };
+export { GROUP_CAPTIONS_REVEAL_DICTATION as $, keyPositionFinding as A, SCRIPT_MAX_TURNS as At, countWords as B, READ_ALOUD_MAX_REFERENCE_LENGTH as C, passageWithoutPlaceholders as Ct, SPEECH_ASSESSMENT_MAX_WORDS as D, PLACEHOLDER_RE as Dt, SPEECH_ASSESSMENT_MAX_TEXT_LENGTH as E, FillInTheBlanksDataSchema as Et, matchText as F, isMissingId as G, checkMedia as H, LEVEL_PROBABILITY_TOLERANCE as I, isUnwritten as J, isRecord as K, levelDistribution as L, normaliseFinding as M, maxUnits as Mt, policyFor as N, MultipleChoiceDataSchema as O, MediaSchema as Ot, levenshteinDistance as P, DictationDataSchema as Q, levelKey as R, READ_ALOUD_MAX_DIMENSION_WEIGHT as S, numberedPassage as St, READ_ALOUD_MAX_TAKES as T, revealsAnswer as Tt, coveredPathsOf as U, DRAFT_ISSUE_SEVERITY as V, covers as W, pathKey as X, issue as Y, refusesEmpty as Z, GapSelectDataSchema as _, BUILT_IN_ACTIVITY_TYPES as _t, readSchema as a, STEP as at, ReadAloudDataSchema as b, containsWords as bt, dictationType as c, dictationReferenceWords as ct, multipleChoiceType as d, DICTATION_MAX_EQUIVALENCE_LENGTH as dt, groupCaptionsField as et, readAloudType as f, DICTATION_MAX_TEXT_LENGTH as ft, WrittenResponseDataSchema as g, withValidationScope as gt, defineActivityType as h, normalizeDictationText as ht, isOwnSchema as i, UnknownActivityTypeError as it, finding as j, ScriptSchema as jt, MultipleChoiceOptionMediaSchema as k, RedactedMediaSchema as kt, fillInTheBlanksType as l, DICTATION_MAX_ACCEPTED_TRANSCRIPTS as lt, guardOf as m, codePointLength as mt, registerActivityType as n, DeferredScoringError as nt, standardJsonSchemaOf as o, alignDictation as ot, writtenResponseType as p, DICTATION_MAX_TRANSCRIPT_LENGTH as pt, isUnset as q, registeredActivityTypes as r, RedactedScoringError as rt, MEDIA_FIELD_POLICY as s, alignSequences as st, getActivityTypeDescriptor as t, ActivitySchemaError as tt, gapSelectType as u, DICTATION_MAX_EQUIVALENCES as ut, SPEAKING_MEASURES as v, everyBuiltInTypeHandled as vt, READ_ALOUD_MAX_SECONDS as w, placeholderOrder as wt, CANONICAL_LOCALE_RE as x, fold as xt, SpeakingResponseDataSchema as y, isBuiltInActivityType as yt, readRubricLevels as z };
 
-//# sourceMappingURL=registry-tkacvJUI.js.map
+//# sourceMappingURL=registry-Bw9grsCN.js.map