@intellectif/lk-core 1.5.0 → 1.7.0

package/dist/{index-qMbxed1B.d.cts → index-DP9rvyOz.d.cts}

@@ -1,5 +1,4 @@
-import { At as ActivityType, Et as ActivityDataMap, Ot as ActivityMedia, hn as ValidationResult, nn as MultipleChoiceOptionMedia, st as ItemGroup } from "./ai-BYryFkF9.cjs";
-//#region src/types/redacted.d.ts
+import { At as ActivityType, Et as ActivityDataMap, Ot as ActivityMedia, gn as ValidationResult, nn as MultipleChoiceOptionMedia, st as ItemGroup } from "./ai-B1wYrqcB.cjs";
 /**
  * The learner-safe SHAPE of each built-in type.
  *
@@ -78,6 +77,7 @@ interface RedactedMultipleChoiceOption {
 /** A Multiple Choice item with the answer key, feedback and strategy removed. */
 interface RedactedMultipleChoiceData extends RedactedItem {
   type: 'multiple-choice';
+  instructions?: string | undefined;
   question: string;
   questionHtml?: string | undefined;
   mode: 'single' | 'multi';
@@ -93,6 +93,7 @@ interface RedactedBlankConfig {
 /** A Fill-in-the-Blanks item with every accepted answer removed. */
 interface RedactedFillInTheBlanksData extends RedactedItem {
   type: 'fill-in-the-blanks';
+  instructions?: string | undefined;
   passage: string;
   passageHtml?: string | undefined;
   blanks: RedactedBlankConfig[];
@@ -139,6 +140,7 @@ interface RedactedGapSelectGap {
 /** A Gap Select item the learner can still answer: choices intact, answer key gone. */
 interface RedactedGapSelectData extends RedactedItem {
   type: 'gap-select';
+  instructions?: string | undefined;
   passage: string;
   passageHtml?: string | undefined;
   gaps: RedactedGapSelectGap[];
@@ -209,8 +211,6 @@ interface RedactedStimulus {
  * ```
  */
 type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData | RedactedWrittenResponseData | RedactedGapSelectData | RedactedDictationData | RedactedReadAloudData;
-//#endregion
-//#region src/schemas/item-group.d.ts
 /**
  * Validates an item group in full: the container and stimulus against
  * {@link ItemGroupSchema}, then every item against the schema registered for
@@ -222,8 +222,6 @@ type RedactedActivity = RedactedMultipleChoiceData | RedactedFillInTheBlanksData
  * not the first one that happened to throw.
  */
 declare function validateItemGroup(data: unknown): ValidationResult<ItemGroup>;
-//#endregion
-//#region src/schemas/json-schema.d.ts
 /**
  * JSON Schema (Draft 7) for a `Stimulus`. Structural contract only — the
  * kind/media/body consistency guards are Zod-only.
@@ -288,24 +286,49 @@ declare const fillInTheBlanksJsonSchema: Record<string, unknown>;
  * contract. Structural contract only.
  */
 declare const writtenResponseJsonSchema: Record<string, unknown>;
+/** The JSON Schema drafts the SDK writes. */
+type JsonSchemaTarget = 'draft-2020-12' | 'draft-7';
 /**
- * Derives the JSON Schema (Draft 7) for any REGISTERED activity type — the
- * live, registry-backed replacement for the static per-type exports above,
- * and the building block for AI generation pipelines (R6.1): pass the result
- * as a structured-output schema so a model can only emit valid items.
+ * Derives the JSON Schema for any REGISTERED activity type — the live,
+ * registry-backed replacement for the static per-type exports above, and the
+ * building block for AI generation pipelines (R6.1): pass the result as a
+ * structured-output schema so a model can only emit valid items.
  *
- * For a type you registered, it is the descriptor's `jsonSchema` when you gave
- * one, or else what the schema produces through the Standard JSON Schema
- * converter (`'~standard'.jsonSchema`) — a zod 4.6 schema has one. A fresh copy
- * every call.
+ * Draft 7 unless `target` says `'draft-2020-12'`. For a type you registered,
+ * it is the descriptor's `jsonSchema` when you gave one, in whatever draft you
+ * wrote it, or else what the schema produces through the Standard JSON Schema
+ * converter (`'~standard'.jsonSchema`) in the draft asked for — a zod 4.6
+ * schema has one. A fresh copy every call.
  *
  * @throws UnknownActivityTypeError when `type` has no registered descriptor.
  * @throws Error when a registered type has neither a `jsonSchema` nor a schema
  *   that can produce one.
  */
-declare function jsonSchemaFor(type: string): Record<string, unknown>;
-//#endregion
-//#region src/schemas/index.d.ts
+declare function jsonSchemaFor(type: string, options?: {
+  target?: JsonSchemaTarget;
+}): Record<string, unknown>;
+/**
+ * One JSON Schema document for content an outside tool writes: the root is a
+ * `SequenceEntry` — an activity of any registered type, or an item group whose
+ * items are typed too. Each type, the stimulus and the item group sit under
+ * `$defs` (`definitions` in draft 7), so a tool can also point at one of them.
+ * Draft 2020-12 unless `target` says `'draft-7'`.
+ *
+ * Structural, as every exported schema is: rules that span fields (one key in
+ * a single-answer question, a blank for each marker, a slow recording that is
+ * another file) cannot be written in JSON Schema. On import, `validateDraft`
+ * and `validateItemGroupDraft` decide. It includes the author-only fields
+ * (`transcript`, `script`), so a tool can write them.
+ *
+ * ```ts
+ * writeFileSync('schema.json', JSON.stringify(contentJsonSchema(), null, 2));
+ * ```
+ */
+declare function contentJsonSchema(options?: {
+  target?: JsonSchemaTarget;
+}): Record<string, unknown>;
+/** The most turns a recording's `script` may hold. */
+declare const SCRIPT_MAX_TURNS = 500;
 /**
  * Checks a piece of activity media — an item's `media`, a stimulus's, a
  * dictation's `slowMedia` — on its own, the way `validateActivity` checks it
@@ -338,6 +361,5 @@ declare function validateOptionMedia(value: unknown): ValidationResult<MultipleC
  * @throws UnknownActivityTypeError when `type` has no registered descriptor.
  */
 declare function validateActivity<T extends ActivityType>(type: T, data: unknown): ValidationResult<ActivityDataMap[T]>;
-//#endregion
-export { RedactedMultipleChoiceData as C, RedactedStimulus as D, RedactedReadAloudData as E, RedactedWrittenResponseData as O, RedactedGapSelectGap as S, RedactedMultipleChoiceOptionMedia as T, RedactedDictationSlowMedia as _, fillInTheBlanksJsonSchema as a, RedactedGapSelectChoice as b, jsonSchemaFor as c, stimulusJsonSchema as d, writtenResponseJsonSchema as f, RedactedDictationData as g, RedactedBlankConfig as h, dictationJsonSchema as i, multipleChoiceJsonSchema as l, RedactedActivity as m, validateMedia as n, gapSelectJsonSchema as o, validateItemGroup as p, validateOptionMedia as r, itemGroupJsonSchema as s, validateActivity as t, readAloudJsonSchema as u, RedactedFillInTheBlanksData as v, RedactedMultipleChoiceOption as w, RedactedGapSelectData as x, RedactedGapSelectBank as y };
-//# sourceMappingURL=index-qMbxed1B.d.cts.map
+export { RedactedStimulus as A, RedactedGapSelectChoice as C, RedactedMultipleChoiceOption as D, RedactedMultipleChoiceData as E, RedactedMultipleChoiceOptionMedia as O, RedactedGapSelectBank as S, RedactedGapSelectGap as T, RedactedActivity as _, JsonSchemaTarget as a, RedactedDictationSlowMedia as b, fillInTheBlanksJsonSchema as c, jsonSchemaFor as d, multipleChoiceJsonSchema as f, validateItemGroup as g, writtenResponseJsonSchema as h, SCRIPT_MAX_TURNS as i, RedactedWrittenResponseData as j, RedactedReadAloudData as k, gapSelectJsonSchema as l, stimulusJsonSchema as m, validateMedia as n, contentJsonSchema as o, readAloudJsonSchema as p, validateOptionMedia as r, dictationJsonSchema as s, validateActivity as t, itemGroupJsonSchema as u, RedactedBlankConfig as v, RedactedGapSelectData as w, RedactedFillInTheBlanksData as x, RedactedDictationData as y };
+//# sourceMappingURL=index-DP9rvyOz.d.cts.map

package/dist/index-DP9rvyOz.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DP9rvyOz.d.cts","names":[],"sources":["../src/types/redacted.ts","../src/schemas/item-group.ts","../src/schemas/json-schema.ts","../src/schemas/media.ts","../src/schemas/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAoBU;EACR;EACA;EACA;EACA;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA,SAAS;EACT;EACA,WAAW;;;UAIH;EACR;EACA;;;UAIQ;EACR;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;EACA;EACA,KAAK;;;UAIU;EACf;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA,QAAQ;;;UAIO,mCAAmC;EAClD;EACA;EACA;EACA;EACA;EACA,SAAS;EACT;EACA;;;UAIe;EACf;EACA;;;UAIe,oCAAoC;EACnD;EACA;EACA;EACA;EACA,QAAQ;EACR;;;UAIe,oCAAoC;EACnD;EACA;EACA;EACA;EACA;EACA;IAEM;MACE;MACA;MACA;MACA;QAAW;QAAe;;;IAE5B;;EAGN;EACA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA,SAAS;;;UAIM;EACf;EACA,UAAU;EACV;;;UAIe,8BAA8B;EAC7C;EACA;EACA;EACA;EACA,MAAM;EACN,QAAQ;EACR;EACA;EACA;;;UAIe;EACf;EACA;EACA;;;UAIe,8BAA8B;EAC7C;EACA,YAAY;EACZ;IAAU;;EACV;;;;;;;UAQe,8BAA8B;EAC7C;EACA;EACA;EACA;EACA,YAAY;EACZ;IACE;IACA;IACA;;EAEF;IACE;MACE;MACA;;;;;UAMW;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR;EACA;;;;;;;;;;;;;;KAeU,mBACR,6BACA,8BACA,8BACA,wBACA,wBACA;;;;;;;;;;;iBCyMY,kBAAkB,gBAAgB,iBAAiB;;;;;cCnatD,oBAAoB;;;;;;;;cAWpB,qBAAqB;;;;;;;;;;;;;;;;;;cAqBrB,qBAAqB;;;;;;;;;;;cAcrB,qBAAqB;;;;;;;;;;cAarB,qBAAqB;cAIrB,0BAA0B;;;;;;cAY1B,2BAA2B;;;;;cAW3B,2BAA2B;;KAQ5B;;;;;;;;;;;;;;;;;iBAqBI,cACd,cACA;EAAW,SAAS;IACnB;;;;;;;;;;;;;;;;;;iBA4Ca,kBACd;EAAW,SAAS;IACnB;;cCzEU;;;;;;;;;;;iBCnDG,cAAc,iBAAiB,iBAAiB;;;;;;;;iBAWhD,oBAAoB,iBAAiB,iBAAiB;;;;;;;;;;;;;iBA8BtD,iBAAiB,UAAU,cACzC,MAAM,GACN,gBACC,iBAAiB,gBAAgB"}

package/dist/{index-D7R3Ll8R.d.cts → index-XCCoPoTU.d.cts}

@@ -1,5 +1,4 @@
-import { Cn as XAPIContext, Dn as XAPIResult, kn as XAPIStatement, pn as ScoringResult, xn as XAPIActor } from "./ai-BYryFkF9.cjs";
-//#region src/xapi/verbs.d.ts
+import { An as XAPIStatement, On as XAPIResult, Sn as XAPIActor, pn as ScoringResult, wn as XAPIContext } from "./ai-B1wYrqcB.cjs";
 /**
  * The set of xAPI verbs emitted by SDK activities, keyed by a stable
  * identifier mapped to its canonical xAPI verb IRI (xAPI 1.0.3 / ADL registry).
@@ -36,8 +35,6 @@ type XAPIVerbKey = keyof typeof XAPIVerb;
  * `XAPIVerbObject.display` when the builder resolves a verb key.
  */
 declare const XAPI_VERB_DISPLAY: Record<XAPIVerbKey, Record<string, string>>;
-//#endregion
-//#region src/xapi/builder.d.ts
 /** Caller-supplied activity object descriptor (mapped to an xAPI Activity). */
 interface XAPIObjectParams {
   /** Activity IRI. */
@@ -132,8 +129,6 @@ declare const xAPIBuilder: {
 declare function xapiDefinitionFor(data: {
   type: string;
 }): Partial<XAPIObjectParams>;
-//#endregion
-//#region src/xapi/validators.d.ts
 /**
  * Validates a constructed {@link XAPIStatement} against the xAPI 1.0.3
  * structural contract.
@@ -148,6 +143,5 @@ declare function xapiDefinitionFor(data: {
  * `XAPIValidationError` would be semantically cleaner — flagged for review.
  */
 declare function validateXAPIStatement(statement: XAPIStatement): void;
-//#endregion
 export { XAPIObjectParams as a, xapiDefinitionFor as c, XAPI_VERB_DISPLAY as d, SubmittedStatementParams as i, XAPIVerb as l, AnsweredStatementParams as n, XAPIStatementParams as o, CompletedStatementParams as r, xAPIBuilder as s, validateXAPIStatement as t, XAPIVerbKey as u };
-//# sourceMappingURL=index-D7R3Ll8R.d.cts.map
+//# sourceMappingURL=index-XCCoPoTU.d.cts.map

package/dist/index-XCCoPoTU.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-XCCoPoTU.d.cts","names":[],"sources":["../src/xapi/verbs.ts","../src/xapi/builder.ts","../src/xapi/validators.ts"],"mappings":";;;;;cAIa;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BD,2BAA2B;;;;;cAM1B,mBAAmB,OAAO,aAAa;;UCxBnC;;EAEf;EACA,OAAO;EACP,cAAc;;EAEd;;EAEA;;EAEA;;EAEA,UAAU;IAAQ;IAAY,cAAc;;;;UAI7B;EACf,OAAO;EACP,MAAM;EACN,QAAQ;EACR,SAAS;EACT,UAAU;;;UAIK;EACf,OAAO;EACP,QAAQ;EACR,eAAe;EACf;;EAEA;EACA,UAAU;EACV,mBAAmB;;;;;;;UAQJ;EACf,OAAO;EACP,QAAQ;EACR;;EAEA;EACA,UAAU;EACV,mBAAmB;;;UAIJ;EACf,OAAO;EACP,QAAQ;EACR,gBAAgB;EAChB;EACA,UAAU;EACV,mBAAmB;;;;;;;cAiGR;EACY,eAAA,QAAA,sBAAsB;EAoBd,uBAAA,QAAA,0BAA0B;;;;;;;EAqBzB,wBAAA,QAAA,2BAA2B;EAc3B,wBAAA,QAAA,2BAA2B;;;;;;;;;;;;;;;;iBA8B7C,kBAAkB;EAAQ;IAAiB,QAAQ;;;;;;;;;;;;;;iBClHnD,sBAAsB,WAAW"}

package/dist/index.cjs

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_registry = require("./registry-Ce00A_OW.cjs");
-const require_ai_writing = require("./ai-writing-Cen7-3qs.cjs");
-const require_scoring = require("./scoring-lKQVYsxy.cjs");
-const require_item_group = require("./item-group-DEB7nLID.cjs");
-const require_schemas = require("./schemas-DksueYsu.cjs");
-const require_xapi = require("./xapi-NYrTlpID.cjs");
-//#region src/delivery.ts
+const require_registry = require("./registry-hzrkTeIT.cjs");
+const require_ai_writing = require("./ai-writing-DrPTV3R2.cjs");
+const require_scoring = require("./scoring-CtkCFyFT.cjs");
+const require_item_group = require("./item-group-8P3WFuUK.cjs");
+const require_schemas = require("./schemas-BWeskONy.cjs");
+const require_xapi = require("./xapi-7btSpx6v.cjs");
+// src/delivery.ts
 /**
 * The policy that restricts nothing: every setting `true`. It is what an absent
 * policy resolves to, and it is exactly the behaviour the SDK had before
@@ -159,8 +159,7 @@ function validateDeliveryPolicy(policy) {
 		data: given
 	};
 }
-//#endregion
-//#region src/item-group.ts
+// src/item-group.ts
 /** Narrows a sequence entry to an item group. */
 function isItemGroup(entry) {
 	return entry.type === "item-group";
@@ -284,8 +283,7 @@ function flattenSequence(entries, options = {}) {
 	}
 	return slots;
 }
-//#endregion
-//#region src/media-budget.ts
+// src/media-budget.ts
 /**
 * The authored-entry prefix of a slot id: `"3"` for both `"3"` and `"3.1"`.
 *
@@ -399,8 +397,7 @@ function restoreMediaPlayLedger(plan, stored) {
 	if (stored.planHash !== plan.planHash) throw new Error(`restoreMediaPlayLedger: this ledger belongs to a different paper (ledger ${stored.planHash}, plan ${plan.planHash}). Restoring it would hold the learner to a play budget from an exam they never sat.`);
 	return serializeMediaPlayLedger(plan, stored.entries, { ...stored.savedAt !== void 0 ? { savedAt: stored.savedAt } : {} });
 }
-//#endregion
-//#region src/attempt-plan.ts
+// src/attempt-plan.ts
 /**
 * The activity as CONTENT, with its slot key removed.
 *
@@ -651,8 +648,7 @@ function scoredItemsFromPlan(plan, outcomes, options = {}) {
 		outcome: Object.hasOwn(outcomes, slot.slotId) ? outcomes[slot.slotId] : missingOutcome(slot, policy)
 	}));
 }
-//#endregion
-//#region src/attempt-state.ts
+// src/attempt-state.ts
 /**
 * A DEEP copy of the responses.
 *
@@ -776,8 +772,7 @@ function diffResponses(before, after) {
 	}
 	return entries;
 }
-//#endregion
-//#region src/redact.ts
+// src/redact.ts
 /** Merges per-call overrides over a registered policy, one level deep. */
 function mergePolicy(base, overrides) {
 	if (overrides === void 0) return base;
@@ -907,7 +902,8 @@ const ITEM_GROUP_FIELD_POLICY = {
 		media: require_registry.MEDIA_FIELD_POLICY,
 		locale: "public",
 		attribution: "public",
-		transcript: "author-only"
+		transcript: "author-only",
+		script: "author-only"
 	},
 	timeline: {
 		cues: {
@@ -994,8 +990,56 @@ function assertRedactedItemGroup(data) {
 		}
 	});
 }
-//#endregion
-//#region src/timeline.ts
+/** A deep copy of plain data with every field its policy calls `author-only` left out. */
+function withoutAuthorOnlyValue(value, policy) {
+	if (Array.isArray(value)) return value.map((element) => withoutAuthorOnlyValue(element, policy));
+	if (value === null || typeof value !== "object") return value;
+	const output = {};
+	for (const [key, field] of Object.entries(value)) {
+		const classification = policy?.[key];
+		if (classification === "author-only") continue;
+		output[key] = withoutAuthorOnlyValue(field, classification === void 0 || isSensitivity(classification) ? void 0 : classification);
+	}
+	return output;
+}
+/** The policy an activity is stripped under; the same one `redact()` reads. */
+function policyOf(type) {
+	const descriptor = typeof type === "string" ? require_registry.getActivityTypeDescriptor(type) : void 0;
+	if (descriptor === void 0) throw new require_registry.UnknownActivityTypeError(String(type));
+	if (descriptor.fieldPolicy === void 0) throw new Error(`Activity type "${descriptor.type}" has no fieldPolicy; withoutAuthorOnly() cannot tell which of its fields are author-only.`);
+	return descriptor.fieldPolicy;
+}
+/**
+* A copy of an activity or an item group without its `author-only` fields:
+* a recording's `transcript` and `script`, on an item's media, a
+* multiple-choice option's recording, a stimulus or its media. Everything
+* else is kept as stored, the answer key and your own fields included, and
+* the copy is not marked redacted, so it scores exactly as the stored item.
+*
+* For practice an app scores in the browser, where the learner may hold the
+* key but not the author's material. It is NOT a learner-safe projection: an
+* exam, or anything a learner must not be able to answer from the payload,
+* goes through {@link redact} / {@link redactItemGroup}, whose output a scorer
+* refuses.
+*
+* ```ts
+* res.json(withoutAuthorOnly(practiceItem));
+* ```
+*
+* @throws UnknownActivityTypeError when an activity's type is not registered,
+*   and Error when it declares no `fieldPolicy`.
+*/
+function withoutAuthorOnly(entry) {
+	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new TypeError("withoutAuthorOnly: expects an activity or an item group.");
+	const record = entry;
+	if (record.type !== "item-group") return withoutAuthorOnlyValue(entry, policyOf(record.type));
+	const { items, ...container } = record;
+	return {
+		...withoutAuthorOnlyValue(container, ITEM_GROUP_FIELD_POLICY),
+		...Array.isArray(items) ? { items: items.map((item) => withoutAuthorOnlyValue(item, policyOf(item?.type))) } : items !== void 0 ? { items } : {}
+	};
+}
+// src/timeline.ts
 /**
 * Reads a stored {@link MediaProgress}. Never throws: anything that is not one
 * — a string, a stale shape, an object whose getters throw — answers `null`,
@@ -1049,7 +1093,6 @@ function composeTimelineScore(entryKey, items, policy) {
 		items: own
 	}], policy);
 }
-//#endregion
 exports.AI_COACHING_MAX_TIP_LENGTH = require_ai_writing.AI_COACHING_MAX_TIP_LENGTH;
 exports.AI_COACHING_MAX_WORDS = require_ai_writing.AI_COACHING_MAX_WORDS;
 exports.AI_CRITIQUE_MAX_FIELD_LENGTH = require_ai_writing.AI_CRITIQUE_MAX_FIELD_LENGTH;
@@ -1081,6 +1124,7 @@ exports.READ_ALOUD_MAX_REFERENCE_LENGTH = require_registry.READ_ALOUD_MAX_REFERE
 exports.READ_ALOUD_MAX_SECONDS = require_registry.READ_ALOUD_MAX_SECONDS;
 exports.READ_ALOUD_MAX_TAKES = require_registry.READ_ALOUD_MAX_TAKES;
 exports.RedactedScoringError = require_registry.RedactedScoringError;
+exports.SCRIPT_MAX_TURNS = require_registry.SCRIPT_MAX_TURNS;
 exports.SPEECH_ASSESSMENT_MAX_WORDS = require_registry.SPEECH_ASSESSMENT_MAX_WORDS;
 exports.TIMELINE_MAX_CHAPTERS = require_item_group.TIMELINE_MAX_CHAPTERS;
 exports.TIMELINE_MAX_ITEMS = require_item_group.TIMELINE_MAX_ITEMS;
@@ -1120,6 +1164,7 @@ exports.composeAssessmentScore = require_scoring.composeAssessmentScore;
 exports.composeTimelineScore = composeTimelineScore;
 exports.computePassThreshold = require_scoring.computePassThreshold;
 exports.contentHash = require_scoring.contentHash;
+exports.contentJsonSchema = require_schemas.contentJsonSchema;
 exports.countWords = require_registry.countWords;
 exports.createDraft = require_ai_writing.createDraft;
 exports.createInteractiveVideoDraft = require_ai_writing.createInteractiveVideoDraft;
@@ -1161,6 +1206,8 @@ exports.isItemGroup = isItemGroup;
 exports.itemGroupJsonSchema = require_schemas.itemGroupJsonSchema;
 exports.jsonSchemaFor = require_schemas.jsonSchemaFor;
 exports.levenshteinDistance = require_registry.levenshteinDistance;
+exports.listMediaRefs = require_ai_writing.listMediaRefs;
+exports.mapMediaRefs = require_ai_writing.mapMediaRefs;
 exports.matchText = require_registry.matchText;
 exports.multipleChoiceJsonSchema = require_schemas.multipleChoiceJsonSchema;
 exports.multipleChoiceType = require_registry.multipleChoiceType;
@@ -1193,6 +1240,7 @@ exports.serializeMediaPlayLedger = serializeMediaPlayLedger;
 exports.slotMediaKey = slotMediaKey;
 exports.stimulusJsonSchema = require_schemas.stimulusJsonSchema;
 exports.stimulusMediaKey = stimulusMediaKey;
+exports.transcriptOf = require_ai_writing.transcriptOf;
 exports.validateActivity = require_schemas.validateActivity;
 exports.validateDeliveryPolicy = validateDeliveryPolicy;
 exports.validateDraft = require_ai_writing.validateDraft;
@@ -1204,6 +1252,7 @@ exports.validateOptionMedia = require_schemas.validateOptionMedia;
 exports.validateSpeechAssessment = require_scoring.validateSpeechAssessment;
 exports.validateXAPIStatement = require_xapi.validateXAPIStatement;
 exports.verifyAttemptPlan = verifyAttemptPlan;
+exports.withoutAuthorOnly = withoutAuthorOnly;
 exports.writtenResponseJsonSchema = require_schemas.writtenResponseJsonSchema;
 exports.writtenResponseType = require_registry.writtenResponseType;
 exports.xAPIBuilder = require_xapi.xAPIBuilder;