@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/ActivitySequence-CkX87pfB.js

@@ -0,0 +1,839 @@
+'use client';
+import { d as randomSessionId, f as SequenceSlotContext, h as takeOf, p as mintTake } from "./useAiHelp-B-ccDL5Q.js";
+import { i as useLkStrings } from "./LkIntlProvider-D_FdYXjQ.js";
+import { t as Dictation } from "./Dictation-BlxRp-3k.js";
+import { t as FillInTheBlanks } from "./FillInTheBlanks-B6xzqYXx.js";
+import { t as GapSelect } from "./GapSelect-DUSiaEQH.js";
+import { t as MultipleChoice } from "./MultipleChoice-Dra0_KYD.js";
+import { n as stopCaptureGroup, t as ReadAloud } from "./ReadAloud-C8RhaUqV.js";
+import { t as WrittenResponse } from "./WrittenResponse-Cl8G6nO_.js";
+import { t as StimulusPanel } from "./StimulusPanel-BgzByfkb.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { flattenSequence, isItemGroup, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, slotMediaKey, stimulusMediaKey } from "@intellectif/lk-core";
+//#region src/components/ActivitySequence/ActivitySequence.tsx
+/**
+* One slot's key for the life of a set: its pane's React key, and the name its
+* portal node is held under.
+*/
+function slotKeyOf(setKey, slot) {
+	return `${setKey}::slot-${slot.slotId}-${slot.activity.id}`;
+}
+/** The authored-entry prefix of a slot id: `"3"` for `"3"` and for `"3.1"`. */
+function entryKeyOf(slot) {
+	return slot.slotId.split(".")[0] ?? slot.slotId;
+}
+/**
+* Names the capture groups of one pager, so a slot's microphone belongs to that
+* pager alone. Per mount, for the reason the playback groups are: slot ids are
+* short and repeat ("0", "1.0"), so two pagers on one page — a review beside a
+* live attempt — would share a group, and hiding one's first question would
+* stop the other's recorder. The name never reaches the DOM, so a server and
+* the client that hydrates it may mint different ones.
+*/
+let captureScopeCount = 0;
+/**
+* A pane that is kept MOUNTED but shown only when it is the current one, and
+* that stops any media it contains on the way out.
+*
+* `hidden` alone is not enough. It resolves to `display: none`, and CSS does
+* not touch playback: an `<audio>` or `<video>` inside a hidden subtree keeps
+* playing to the end. (The HTML spec pauses a media element when it is
+* REMOVED from the document — a different thing, and the thing this pager
+* deliberately does not do, because unmounting is what used to destroy the
+* learner's answers.) So a recording started for one question would carry on
+* underneath the next, which for a listening paper means the passage plays
+* while the learner is somewhere else entirely.
+*
+* Pausing preserves `currentTime`: coming back to a group resumes where the
+* learner left off. Nothing auto-plays on the way in — starting audio the
+* learner did not ask for is its own defect.
+*
+* `embed` media (a provider iframe) cannot be paused this way: controlling a
+* third-party player needs its own JS API, which the SDK has no reliable
+* access to because the author supplies the embed URL. Use `audio`/`video`
+* media for anything that must stop when the learner navigates.
+*
+* A microphone is the other way round: it is not an element in this subtree, so
+* no query can find it. A slot pane hands its content a `channel` through
+* `SequenceSlotContext` — never a prop, so nothing on a public component's
+* signature can name it — whose `captureGroup` the pane's recorders join, and
+* hiding the pane stops them: a learner who navigates away mid-take must not
+* leave the microphone live under the next question.
+*/
+function SequencePane({ className, hidden, channel, children }) {
+	const ref = useRef(null);
+	const captureGroup = channel?.captureGroup;
+	useEffect(() => {
+		if (!hidden) return;
+		if (captureGroup !== void 0) stopCaptureGroup(captureGroup);
+		const node = ref.current;
+		if (node === null) return;
+		for (const media of node.querySelectorAll("audio, video")) {
+			const element = media;
+			if (!element.paused) element.pause();
+		}
+	}, [hidden, captureGroup]);
+	return /* @__PURE__ */ jsx("div", {
+		className,
+		hidden,
+		ref,
+		children: channel === void 0 ? children : /* @__PURE__ */ jsx(SequenceSlotContext.Provider, {
+			value: channel,
+			children
+		})
+	});
+}
+/**
+* Presents a set of activities as an in-place pager: one question visible at a
+* time, navigated with Prev/Next (no page scrolling). Linear free navigation —
+* the learner may move back and forth; activities keep their own submit and
+* scoring. On navigation, focus moves to the question region and the position
+* is announced via an aria-live region.
+*
+* Item groups are flattened into consecutive questions; the group's stimulus
+* is mounted ONCE, beside the question region rather than inside it, and shown
+* alongside every question in the group — so a passage stays put, and a
+* recording keeps its position, as the learner moves between its questions.
+*/
+/**
+* Whether an activity shuffles its own options, and therefore needs a seed of
+* its own. Read structurally: `shuffle` is a per-type content field, not part
+* of the sequence entry contract.
+*/
+function shufflesItsOwnOptions(entry) {
+	const item = entry;
+	return item?.shuffle === true || item?.shuffleChoices === true;
+}
+function ActivitySequence({ activities, renderers, onActivityComplete, onComplete, onFinished, onSubmit, onInteraction, renderMode = "practice", shuffle, shuffleSeed, defaultIndex, onIndexChange, responses, submittedSlotIds, outcomes, sanitizeHtml, theme, locale, disabled, mediaBudget, recordingBinding, assessments, workletUrl, strings, ai, delivery, scoring }) {
+	const sessionIdRef = useRef(null);
+	const s = useLkStrings(strings);
+	const mediaPlays = mediaBudget?.plays;
+	const [captureScope] = useState(() => {
+		captureScopeCount += 1;
+		return `lk-seq-capture-${captureScopeCount}`;
+	});
+	const shuffleEntries = shuffle === "entries";
+	const needsSeed = shuffleEntries || activities.some((entry) => isItemGroup(entry) ? entry.shuffle === "within-group" || entry.items.some(shufflesItsOwnOptions) : shufflesItsOwnOptions(entry));
+	if (needsSeed && shuffleSeed === void 0 && renderMode !== "practice") throw new Error(`ActivitySequence: renderMode "${renderMode}" requires a \`shuffleSeed\` when anything in the sequence shuffles: shuffle="entries", a group with shuffle: "within-group", or an activity's own \`data.shuffle\` (multiple choice) or \`data.shuffleChoices\` (gap select), including an activity inside a group. Pass the attempt id, so the server can rebuild every order the learner saw from that one seed.`);
+	const seed = needsSeed ? shuffleSeed ?? (sessionIdRef.current ??= randomSessionId()) : void 0;
+	const slots = useMemo(() => flattenSequence(activities, {
+		shuffleEntries,
+		...seed !== void 0 ? { seed } : {}
+	}), [
+		activities,
+		shuffleEntries,
+		seed
+	]);
+	const [index, setIndex] = useState(() => {
+		const requested = Math.trunc(defaultIndex ?? 0);
+		if (!Number.isFinite(requested)) return 0;
+		return Math.min(Math.max(0, requested), Math.max(0, slots.length - 1));
+	});
+	const outcomesRef = useRef(null);
+	const outcomeSlotsRef = useRef(null);
+	const takesRef = useRef(/* @__PURE__ */ new Map());
+	const setGenerationRef = useRef(0);
+	const indexRef = useRef(index);
+	const reportedRef = useRef(false);
+	const channelsRef = useRef(/* @__PURE__ */ new Map());
+	const callsRef = useRef(/* @__PURE__ */ new Map());
+	const hostPendingRef = useRef(/* @__PURE__ */ new Set());
+	const [portals, setPortals] = useState(() => /* @__PURE__ */ new Map());
+	const portalRefsRef = useRef(/* @__PURE__ */ new Map());
+	const modeRef = useRef(renderMode);
+	modeRef.current = renderMode;
+	const deliveryRef = useRef(resolveDeliveryPolicy(delivery));
+	deliveryRef.current = resolveDeliveryPolicy(delivery);
+	const scoringKey = JSON.stringify(scoring ?? null);
+	const scoringInForce = useMemo(() => scoring === void 0 || scoring === null ? void 0 : resolveItemScoringPolicy(scoring), [scoringKey]);
+	const scoringRef = useRef(scoringInForce);
+	scoringRef.current = scoringInForce;
+	const [, setReported] = useState(false);
+	const triesRef = useRef(/* @__PURE__ */ new Map());
+	const triedRef = useRef(/* @__PURE__ */ new Map());
+	const latestRef = useRef(null);
+	const aliveRef = useRef(true);
+	useEffect(() => {
+		aliveRef.current = true;
+		return () => {
+			aliveRef.current = false;
+		};
+	}, []);
+	if (outcomesRef.current === null) {
+		const submittedAtMount = new Set(submittedSlotIds ?? []);
+		outcomesRef.current = slots.map((slot) => submittedAtMount.has(slot.slotId) ? {
+			kind: "restored",
+			index: slot.index,
+			slotId: slot.slotId,
+			activityId: slot.activity.id,
+			...responses !== void 0 && Object.hasOwn(responses, slot.slotId) ? { response: responses[slot.slotId] } : {}
+		} : null);
+		outcomeSlotsRef.current = slots;
+	}
+	const regionRef = useRef(null);
+	const mountedRef = useRef(false);
+	const setKey = JSON.stringify(slots.map((slot) => [slot.slotId, slot.activity.id]));
+	const [prevSetKey, setPrevSetKey] = useState(setKey);
+	const seedKey = `${setKey}::${mediaBudget?.resumeKey ?? ""}`;
+	const mountSetKeyRef = useRef(setKey);
+	const mountSeedKeyRef = useRef(seedKey);
+	const seedsApply = mountSetKeyRef.current === setKey;
+	const mediaSeedsApply = mountSeedKeyRef.current === seedKey || seedsApply;
+	if (mountSeedKeyRef.current !== seedKey) mountSeedKeyRef.current = seedKey;
+	const submitted = useMemo(() => new Set(submittedSlotIds ?? []), [submittedSlotIds]);
+	if (prevSetKey !== setKey) {
+		setPrevSetKey(setKey);
+		setIndex(0);
+		indexRef.current = 0;
+		outcomesRef.current = slots.map(() => null);
+		outcomeSlotsRef.current = slots;
+		takesRef.current = /* @__PURE__ */ new Map();
+		setGenerationRef.current += 1;
+		channelsRef.current = /* @__PURE__ */ new Map();
+		callsRef.current = /* @__PURE__ */ new Map();
+		hostPendingRef.current = /* @__PURE__ */ new Set();
+		portalRefsRef.current = /* @__PURE__ */ new Map();
+		reportedRef.current = false;
+		triesRef.current = /* @__PURE__ */ new Map();
+		triedRef.current = /* @__PURE__ */ new Map();
+		setReported(false);
+	}
+	const setGeneration = setGenerationRef.current;
+	useEffect(() => {
+		if (mountedRef.current) regionRef.current?.focus();
+		else mountedRef.current = true;
+	}, [index]);
+	const reportedIndexRef = useRef(null);
+	useEffect(() => {
+		if (reportedIndexRef.current === index) return;
+		const first = reportedIndexRef.current === null;
+		reportedIndexRef.current = index;
+		if (first && index === Math.trunc(defaultIndex ?? 0)) return;
+		onIndexChange?.(index);
+	}, [
+		index,
+		defaultIndex,
+		onIndexChange
+	]);
+	useEffect(() => {
+		if (indexRef.current === index) return;
+		indexRef.current = index;
+		latestRef.current?.reportIfFinished();
+	}, [index]);
+	const stimulusMounts = useMemo(() => {
+		const mounts = /* @__PURE__ */ new Map();
+		for (const slot of slots) {
+			if (slot.group === void 0) continue;
+			const entryKey = entryKeyOf(slot);
+			const existing = mounts.get(entryKey);
+			if (existing === void 0) mounts.set(entryKey, {
+				entryKey,
+				group: slot.group,
+				first: slot.index,
+				last: slot.index
+			});
+			else existing.last = slot.index;
+		}
+		return [...mounts.values()];
+	}, [slots]);
+	const total = slots.length;
+	const current = slots[index];
+	const go = (next) => {
+		setIndex(next);
+	};
+	/**
+	* Fires the whole-set callbacks — once, together — when every slot is done
+	* and no take is still on its way.
+	*
+	* **A take on its way holds the report.** A practice read-aloud records its
+	* `responded` outcome the moment its take is stored, and its grade can land
+	* after the last slot was filled; reporting then handed `onFinished` the raw
+	* outcome, and the grade a moment later could never reach it. So a slot
+	* whose latest take is being stored or judged is not done. The take states
+	* come from the component itself, through the slot's channel, and every way a
+	* take can end reports an end — a grade, a take with no grade, a failure
+	* nobody can retry, an unmount — so a take that settles never holds a set.
+	*
+	* **So does a failure the learner can still retry, on the question in front
+	* of them.** Reporting there reported a set whose answer "Try again" was about
+	* to change: the retry stored and graded the take, and `onComplete` then
+	* described a different set from the `onFinished` before it. Once the learner
+	* moves to another question the failure no longer holds the report: the slot
+	* completes as whatever it last stored, or as `unsubmitted` when that is
+	* nothing — never as a `recording` of `null`, which is the blank a learner
+	* chooses and a grader marks 0. `unsubmitted` is a `practice` outcome only:
+	* an exam question with no stored take is unanswered, and the learner has a
+	* blank to hand in if that is their answer.
+	*/
+	const reportIfFinished = () => {
+		const held = outcomesRef.current;
+		const presented = outcomeSlotsRef.current;
+		if (held === null || presented === null || reportedRef.current) return;
+		if (hostPendingRef.current.size > 0) return;
+		for (const [at, state] of triesRef.current) if (state === "retrying" || at === indexRef.current) return;
+		const items = [];
+		for (const [at, outcome] of held.entries()) {
+			const take = takesRef.current.get(at);
+			if (take?.state === "in-flight" || take?.state === "retryable" && at === indexRef.current) return;
+			const slot = presented[at];
+			if (outcome !== null) items.push(outcome);
+			else if (take?.state === "retryable" && renderMode === "practice" && slot !== void 0) items.push({
+				kind: "unsubmitted",
+				index: at,
+				slotId: slot.slotId,
+				activityId: slot.activity.id
+			});
+			else return;
+		}
+		reportedRef.current = true;
+		setReported(true);
+		onFinished?.(items);
+		const scored = [];
+		for (const item of items) {
+			if (item.kind !== "scored") return;
+			scored.push(item.result);
+		}
+		onComplete?.(scored);
+	};
+	/**
+	* Records a finished slot and reports the set when it is done — the one place
+	* a slot's outcome is decided.
+	*
+	* **An outcome must come from the set on screen.** A grade can settle after
+	* the paper changed — an assessment held across a swap of `activities`, or a
+	* consumer's own renderer grading asynchronously — and it arrives through a
+	* callback from the render that started it. Accepted, it landed in whatever
+	* slot of the NEW paper had its index, and could report that paper fully
+	* scored though nobody had answered it. Ids cannot tell the papers apart: a
+	* new paper can reuse both the slot id and the activity id, and a loading
+	* blip reuses every id there is. `generation` can: it is the set the callback
+	* was handed out for, and it is refused unless that set is still current.
+	*
+	* **A slot that already holds an outcome is FINAL**: the first outcome wins,
+	* so a renderer that reports twice keeps what it reported first. There is one
+	* exception.
+	*
+	* **The exception is a `practice` read-aloud, and it is decided by `take`.**
+	* That slot records `responded` when a take is stored, because a take that
+	* comes back unscorable produces no grade at all and the slot would otherwise
+	* stay `null` for ever. Each take has a number (`mintTake`), unique on the page
+	* and larger for a later take, carried by everything the component reports
+	* about it. The invariant:
+	*
+	* **The score and the response a slot holds always describe the same take.**
+	*
+	* - A `responded` for a newer take replaces whatever the slot holds, a grade
+	*   included: `onSubmit` has already told the host about that take, so a
+	*   grade kept for the older one would sit beside a response it does not
+	*   grade.
+	* - A `scored` lands only for the slot's latest take, once, and replaces that
+	*   take's `responded`. A grade for any other take — one the learner has
+	*   since replaced, even one still in flight when they did — is dropped
+	*   rather than filed against a take it did not grade.
+	* - A `restored` slot is never replaced: it was submitted before this mount,
+	*   and a resumed attempt must not be re-reported as if it had just been sat.
+	*
+	* A grade therefore lands once per take, and `onActivityComplete` — the
+	* per-item hook, keyed by `slotId` — only ever grades the answer `onSubmit`
+	* last reported for that slot. The whole-set callbacks stay once per set
+	* whatever is replaced — see `reportedRef`.
+	*/
+	const record = (outcome, generation, take, tried) => {
+		const held = outcomesRef.current;
+		if (held === null || generation !== setGenerationRef.current) return;
+		const at = outcome.index;
+		const holding = held[at];
+		let accepted = outcome;
+		if (tried !== void 0) {
+			const latest = triedRef.current.get(at);
+			if (holding?.kind === "restored") return;
+			if (holding != null && (reportedRef.current || latest === void 0 || tried <= latest)) return;
+			triedRef.current.set(at, tried);
+		} else if (take === void 0) {
+			if (holding != null) return;
+		} else {
+			if (holding?.kind === "restored") return;
+			const latest = takesRef.current.get(at);
+			if (outcome.kind === "responded") {
+				if (latest !== void 0 && (take < latest.take || take === latest.take && latest.response !== void 0)) return;
+				takesRef.current.set(at, {
+					take,
+					state: latest?.take === take ? latest.state : "settled",
+					response: outcome.response
+				});
+			} else if (outcome.kind === "scored") {
+				if (latest?.take !== take || latest.response === void 0 || holding?.kind === "scored") return;
+				accepted = {
+					...outcome,
+					response: latest.response
+				};
+			} else return;
+		}
+		const next = held.slice();
+		next[at] = accepted;
+		outcomesRef.current = next;
+		if (accepted.kind === "scored") onActivityComplete?.(accepted.result, accepted.index, accepted.slotId);
+		reportIfFinished();
+	};
+	/**
+	* The learner committed an answer to a slot: the body of the `onSubmit` every
+	* question is handed, the SDK's own components and a host's renderer alike.
+	*/
+	const submitSlot = (generation, at, response) => {
+		if (generation !== setGenerationRef.current) return;
+		onSubmit?.(response, {
+			slotId: at.slotId,
+			index: at.index,
+			activityId: at.activityId
+		});
+		if (at.type === "written-response") return;
+		if (renderMode !== "practice") {
+			record({
+				kind: "responded",
+				index: at.index,
+				slotId: at.slotId,
+				activityId: at.activityId,
+				response
+			}, generation);
+			return;
+		}
+		if (at.type === "read-aloud") record({
+			kind: "responded",
+			index: at.index,
+			slotId: at.slotId,
+			activityId: at.activityId,
+			response
+		}, generation, takeOf(response) ?? mintTake());
+	};
+	/** A slot produced a grade: the body of the `onComplete` every question is handed. */
+	const completeSlot = (generation, at, result) => {
+		const takesAnswers = renderMode === "practice" && at.type === "read-aloud";
+		const outcome = {
+			kind: "scored",
+			index: at.index,
+			slotId: at.slotId,
+			activityId: at.activityId,
+			result
+		};
+		const tried = takesAnswers ? void 0 : takeOf(result);
+		if (tried !== void 0 && renderMode === "practice") {
+			record(outcome, generation, void 0, tried);
+			return;
+		}
+		record(outcome, generation, takesAnswers ? takeOf(result) ?? takesRef.current.get(at.index)?.take : void 0);
+	};
+	/**
+	* A host's question withdrew its answer. The slot holds nothing again — its
+	* outcome and, with it, the take any grade would be filed against — so the
+	* set is unfinished until it is answered again.
+	*
+	* A set already reported stays reported: the whole-set callbacks fire once,
+	* and a consumer who persists on them must not be handed one attempt twice.
+	*/
+	const clearSlot = (generation, at) => {
+		const held = outcomesRef.current;
+		if (!aliveRef.current || held === null || generation !== setGenerationRef.current) return;
+		takesRef.current.delete(at.index);
+		if (held[at.index] == null) return;
+		const next = held.slice();
+		next[at.index] = null;
+		outcomesRef.current = next;
+	};
+	/** A host's question is waiting on work of its own, or has stopped waiting. */
+	const hostPending = (generation, at, pending) => {
+		if (!aliveRef.current || generation !== setGenerationRef.current) return;
+		const waiting = hostPendingRef.current;
+		if (pending) {
+			waiting.add(at.index);
+			return;
+		}
+		if (!waiting.delete(at.index)) return;
+		reportIfFinished();
+	};
+	/** A host's question reported an interaction: its activity and the moment, filled in. */
+	const emitFor = (generation, at, type, payload) => {
+		if (!aliveRef.current || generation !== setGenerationRef.current) return;
+		onInteraction?.({
+			type,
+			activityId: at.activityId,
+			timestamp: Date.now(),
+			payload: payload ?? {}
+		});
+	};
+	/**
+	* What a slot's channel reports: the state of one of its takes. A take older
+	* than the slot's latest has been replaced, and a report from a set that is
+	* no longer current, or reaching a pager that is unmounting, describes
+	* nothing on screen.
+	*/
+	const updateTake = (generation, at, take, state) => {
+		if (!aliveRef.current || generation !== setGenerationRef.current) return;
+		const latest = takesRef.current.get(at);
+		if (latest !== void 0 && take < latest.take) return;
+		takesRef.current.set(at, latest?.take === take ? {
+			...latest,
+			state
+		} : {
+			take,
+			state
+		});
+		reportIfFinished();
+	};
+	/**
+	* What a slot's channel reports: where its question is with its tries. One
+	* that stops offering or making a try may leave the set with nothing to wait
+	* for.
+	*/
+	const updateTries = (generation, at, state) => {
+		if (!aliveRef.current || generation !== setGenerationRef.current) return;
+		const was = triesRef.current.get(at);
+		if (state === "none") triesRef.current.delete(at);
+		else triesRef.current.set(at, state);
+		if (was !== void 0 && was !== state) reportIfFinished();
+	};
+	latestRef.current = {
+		updateTake,
+		updateTries,
+		reportIfFinished,
+		submitSlot,
+		completeSlot,
+		clearSlot,
+		hostPending,
+		emit: emitFor
+	};
+	/**
+	* The calls one slot makes, made once per slot per set. They reach the latest
+	* render through `latestRef`, so they can keep one identity while the props
+	* they report to change — what a host renderer needs to hold them in an
+	* effect, and what the pager needs so a host that re-renders on every
+	* keystroke does not re-run one.
+	*/
+	const callsFor = (slot) => {
+		const key = `${slot.index}::${slot.slotId}`;
+		let calls = callsRef.current.get(key);
+		if (calls === void 0) {
+			const generation = setGeneration;
+			const at = {
+				slotId: slot.slotId,
+				index: slot.index,
+				activityId: slot.activity.id,
+				type: slot.activity.type
+			};
+			calls = {
+				slot: {
+					slotId: at.slotId,
+					index: at.index,
+					activityId: at.activityId
+				},
+				onSubmit: (response) => latestRef.current?.submitSlot(generation, at, response),
+				onComplete: (result) => latestRef.current?.completeSlot(generation, at, result),
+				clear: () => latestRef.current?.clearSlot(generation, at),
+				setPending: (pending) => latestRef.current?.hostPending(generation, at, pending === true),
+				emit: (type, payload) => latestRef.current?.emit(generation, at, type, payload)
+			};
+			callsRef.current.set(key, calls);
+		}
+		return calls;
+	};
+	/**
+	* Where a host-drawn question portals: a node inside its own pane, so it is
+	* hidden with the question it belongs to and painted with it in fullscreen.
+	* One ref callback per slot, kept, because a new one each render detaches and
+	* re-attaches the node on every commit.
+	*/
+	const portalRefFor = (key) => {
+		let callback = portalRefsRef.current.get(key);
+		if (callback === void 0) {
+			callback = (node) => {
+				setPortals((held) => {
+					if (node === null) {
+						if (!held.has(key)) return held;
+						const next = new Map(held);
+						next.delete(key);
+						return next;
+					}
+					if (held.get(key) === node) return held;
+					const next = new Map(held);
+					next.set(key, node);
+					return next;
+				});
+			};
+			portalRefsRef.current.set(key, callback);
+		}
+		return callback;
+	};
+	/** The channel a slot's pane hands its content: its capture group and its takes. */
+	const channelFor = (slot) => {
+		const key = `${slot.index}::${slot.slotId}`;
+		let channel = channelsRef.current.get(key);
+		if (channel === void 0) {
+			const generation = setGeneration;
+			const at = slot.index;
+			channel = {
+				captureGroup: `${captureScope}::${slot.slotId}`,
+				get renderMode() {
+					return modeRef.current;
+				},
+				get delivery() {
+					return deliveryRef.current;
+				},
+				get scoring() {
+					return scoringRef.current;
+				},
+				get triesClosed() {
+					return reportedRef.current;
+				},
+				triesState: (state) => {
+					latestRef.current?.updateTries(generation, at, state);
+				},
+				takeState: (take, state) => {
+					latestRef.current?.updateTake(generation, at, take, state);
+				}
+			};
+			channelsRef.current.set(key, channel);
+		}
+		return channel;
+	};
+	if (!current) return /* @__PURE__ */ jsx("div", { className: "lk-seq" });
+	const budgetedMedia = slots.flatMap((slot) => {
+		const found = [];
+		const own = slot.activity.media;
+		if (own !== void 0 && resolvePlaybackPolicy(own).maxPlays !== null) found.push({
+			key: slotMediaKey(slot.slotId),
+			url: own.url
+		});
+		const stimulus = slot.group?.stimulus.media;
+		if (stimulus !== void 0 && resolvePlaybackPolicy(stimulus).maxPlays !== null) found.push({
+			key: stimulusMediaKey(slot.slotId),
+			url: stimulus.url
+		});
+		return found;
+	});
+	const budgetEnforced = mediaBudget?.enforced ?? renderMode !== "review";
+	if (budgetedMedia.length > 0 && renderMode === "exam" && budgetEnforced) {
+		if (mediaBudget?.onPlayConsumed === void 0) throw new Error(`ActivitySequence: renderMode "exam" with media that declares \`maxPlays\` requires \`mediaBudget.onPlayConsumed\`. The SDK persists nothing, so without it the count lives only in this mount: a refresh silently restores the full budget, and a paper that grants unlimited plays while showing "2 plays remaining" is indistinguishable — to the learner and to an appeal — from one that works. Budgeted media: ${[...new Set(budgetedMedia.map((m) => m.key))].join(", ")}.`);
+		if ((responses !== void 0 && Object.keys(responses).length > 0 || submittedSlotIds !== void 0 && submittedSlotIds.length > 0) && mediaBudget.plays === void 0) throw new Error("ActivitySequence: this is a resumed attempt (`responses`/`submittedSlotIds` were supplied) but `mediaBudget.plays` is absent. A resume that omits the ledger hands the learner a fresh budget at exactly the moment it matters. Pass `restoreMediaPlayLedger(plan, stored).entries`, or `{}` to state explicitly that nothing was spent.");
+	}
+	const keysByUrl = /* @__PURE__ */ new Map();
+	for (const { key, url } of budgetedMedia) {
+		const keys = keysByUrl.get(url) ?? /* @__PURE__ */ new Set();
+		keys.add(key);
+		keysByUrl.set(url, keys);
+	}
+	for (const [url, keys] of keysByUrl) if (keys.size > 1) throw new Error(`ActivitySequence: media ${JSON.stringify(url)} is budgeted under ${keys.size} separate keys (${[...keys].join(", ")}), so one recording grants ${keys.size} × maxPlays. Put the questions that share a recording in an item group — a group's stimulus is one recording with one budget.`);
+	/** The per-media binding handed to a component or to the stimulus panel. */
+	const bindingFor = (key, slot) => {
+		if (mediaBudget === void 0) return;
+		const entry = mediaSeedsApply && mediaPlays !== void 0 && Object.hasOwn(mediaPlays, key) ? mediaPlays[key] : void 0;
+		return {
+			key,
+			slotId: slot.slotId,
+			index: slot.index,
+			activityId: slot.activity.id,
+			...entry !== void 0 ? { entry } : {},
+			...mediaBudget.enforced !== void 0 ? { enforced: mediaBudget.enforced } : {},
+			...mediaBudget.onPlayConsumed !== void 0 ? { onPlayConsumed: mediaBudget.onPlayConsumed } : {},
+			...mediaBudget.onPlayRefunded !== void 0 ? { onPlayRefunded: mediaBudget.onPlayRefunded } : {},
+			...mediaBudget.onPosition !== void 0 ? { onPosition: mediaBudget.onPosition } : {},
+			...mediaBudget.strings !== void 0 ? { strings: mediaBudget.strings } : {}
+		};
+	};
+	/**
+	* The per-slot recording binding handed to a read-aloud, modelled on
+	* `bindingFor`: the sequence-level methods are called with the slot they
+	* belong to, and `assess` / `playbackUrl` are copied only when the consumer
+	* supplied them — a binding carrying `assess: undefined` is a binding the
+	* component would try to call.
+	*
+	* It watches nothing. The pager used to watch the promises it handed out to
+	* decide when a set was finished, and a promise knows nothing of the take
+	* that asked for it: a late failure from a paper no longer on screen landed
+	* in a new paper that reused the slot's ids, as a blank. What a take came to
+	* is reported by the component, numbered by take, through the slot's channel
+	* — see `record` and `reportIfFinished`.
+	*
+	* A consumer's own renderer is handed no binding.
+	*/
+	const recordingBindingFor = (slot) => {
+		if (recordingBinding === void 0) return;
+		const at = {
+			slotId: slot.slotId,
+			index: slot.index,
+			activityId: slot.activity.id
+		};
+		const { assess, playbackUrl } = recordingBinding;
+		return {
+			upload: (take) => recordingBinding.upload(take, at),
+			...assess !== void 0 ? { assess: (ref) => assess.call(recordingBinding, ref, at) } : {},
+			...playbackUrl !== void 0 ? { playbackUrl: (ref) => playbackUrl.call(recordingBinding, ref, at) } : {}
+		};
+	};
+	const forwarded = {
+		...onInteraction ? { onInteraction } : {},
+		renderMode,
+		...sanitizeHtml ? { sanitizeHtml } : {},
+		...strings !== void 0 ? { strings } : {},
+		...ai !== void 0 && renderMode !== "exam" ? { ai } : {},
+		...delivery !== void 0 && delivery !== null ? { delivery } : {},
+		...scoring !== void 0 && scoring !== null ? { scoring } : {},
+		...theme ? { theme } : {},
+		...locale ? { locale } : {},
+		...disabled ? { disabled } : {}
+	};
+	const renderSlot = (slot) => {
+		const activity = slot.activity;
+		const { slotId, index: slotIndex } = slot;
+		const activityId = activity.id;
+		const restored = seedsApply && responses !== void 0 && Object.hasOwn(responses, slotId) ? responses[slotId] : void 0;
+		const slotOutcome = outcomes !== void 0 && Object.hasOwn(outcomes, slotId) ? outcomes[slotId] : void 0;
+		const slotBinding = bindingFor(slotMediaKey(slotId), slot);
+		const calls = callsFor(slot);
+		const childProps = {
+			...restored !== void 0 ? { defaultValue: restored } : {},
+			...seedsApply && submitted.has(slotId) ? { defaultSubmitted: true } : {},
+			...slotOutcome !== void 0 ? { outcome: slotOutcome } : {},
+			onComplete: calls.onComplete,
+			onSubmit: calls.onSubmit,
+			...forwarded,
+			...slotBinding !== void 0 ? { mediaBudget: slotBinding } : {}
+		};
+		const CustomRenderer = renderers?.[activity.type];
+		if (CustomRenderer) {
+			const portalKey = slotKeyOf(setKey, slot);
+			return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(CustomRenderer, {
+				data: activity,
+				...childProps,
+				question: {
+					slot: calls.slot,
+					active: slotIndex === index,
+					portalContainer: portals.get(portalKey) ?? null,
+					clear: calls.clear,
+					setPending: calls.setPending,
+					emit: calls.emit
+				}
+			}), /* @__PURE__ */ jsx("div", {
+				className: "lk-seq-portal",
+				ref: portalRefFor(portalKey)
+			})] });
+		}
+		if (activity.type === "multiple-choice") return /* @__PURE__ */ jsx(MultipleChoice, {
+			data: activity,
+			...shuffleSeed !== void 0 ? { shuffleSeed } : {},
+			...childProps
+		});
+		if (activity.type === "fill-in-the-blanks") return /* @__PURE__ */ jsx(FillInTheBlanks, {
+			data: activity,
+			...childProps
+		});
+		if (activity.type === "gap-select") return /* @__PURE__ */ jsx(GapSelect, {
+			data: activity,
+			...shuffleSeed !== void 0 ? { shuffleSeed } : {},
+			...childProps
+		});
+		if (activity.type === "dictation") return /* @__PURE__ */ jsx(Dictation, {
+			data: activity,
+			...childProps
+		});
+		if (activity.type === "read-aloud") {
+			const slotRecordingBinding = recordingBindingFor(slot);
+			const slotAssessment = assessments !== void 0 && Object.hasOwn(assessments, slotId) ? assessments[slotId] : void 0;
+			return /* @__PURE__ */ jsx(ReadAloud, {
+				data: activity,
+				...childProps,
+				...slotRecordingBinding !== void 0 ? { recordingBinding: slotRecordingBinding } : {},
+				...slotAssessment !== void 0 ? { assessment: slotAssessment } : {},
+				...workletUrl !== void 0 ? { workletUrl } : {}
+			});
+		}
+		if (activity.type === "written-response") {
+			const { onComplete: _neverGrades, ...writtenResponseProps } = childProps;
+			return /* @__PURE__ */ jsx(WrittenResponse, {
+				data: activity,
+				...writtenResponseProps,
+				onSubmitted: (submission) => record({
+					kind: "submitted",
+					index: slotIndex,
+					slotId,
+					activityId,
+					submission
+				}, setGeneration)
+			});
+		}
+		return /* @__PURE__ */ jsx("div", {
+			className: "lk-seq-unsupported",
+			role: "note",
+			children: s.unsupportedActivity
+		});
+	};
+	const currentEntryKey = entryKeyOf(current);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "lk-seq",
+		lang: locale,
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				className: "lk-seq-progress",
+				"aria-live": "polite",
+				role: "status",
+				children: s.questionProgress(index + 1, total)
+			}),
+			stimulusMounts.map(({ entryKey, group, first, last }) => {
+				const firstSlot = slots[first];
+				const stimulusBinding = firstSlot === void 0 ? void 0 : bindingFor(stimulusMediaKey(firstSlot.slotId), firstSlot);
+				return /* @__PURE__ */ jsx(SequencePane, {
+					className: "lk-seq-stimulus",
+					hidden: entryKey !== currentEntryKey,
+					children: /* @__PURE__ */ jsx(StimulusPanel, {
+						stimulus: group.stimulus,
+						range: {
+							first: first + 1,
+							last: last + 1
+						},
+						renderMode,
+						...sanitizeHtml ? { sanitizeHtml } : {},
+						...locale ? { locale } : {},
+						...onInteraction ? { onInteraction } : {},
+						...disabled ? { disabled } : {},
+						...strings !== void 0 ? { strings } : {},
+						...stimulusBinding !== void 0 ? { mediaBudget: stimulusBinding } : {}
+					})
+				}, `${setKey}::group-${entryKey}`);
+			}),
+			/* @__PURE__ */ jsx("section", {
+				className: "lk-seq-question",
+				ref: regionRef,
+				tabIndex: -1,
+				"aria-label": s.questionProgress(index + 1, total),
+				children: slots.map((slot) => {
+					const slotKey = slotKeyOf(setKey, slot);
+					return /* @__PURE__ */ jsx(SequencePane, {
+						className: "lk-seq-slot",
+						hidden: slot.index !== index,
+						channel: channelFor(slot),
+						children: renderSlot(slot)
+					}, slotKey);
+				})
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "lk-seq-nav",
+				children: [/* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "lk-seq-prev",
+					onClick: () => go(index - 1),
+					disabled: index === 0,
+					children: s.previous
+				}), /* @__PURE__ */ jsx("button", {
+					type: "button",
+					className: "lk-seq-next",
+					onClick: () => go(index + 1),
+					disabled: index === total - 1,
+					children: s.next
+				})]
+			})
+		]
+	});
+}
+//#endregion
+export { ActivitySequence as t };
+
+//# sourceMappingURL=ActivitySequence-CkX87pfB.js.map