@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/chunk-G6PXJ2SA.js

@@ -1,823 +0,0 @@
-'use client';
-import { StimulusPanel } from './chunk-4ZZWZSWI.js';
-import { WrittenResponse } from './chunk-FKGMSOJF.js';
-import { MultipleChoice } from './chunk-C7QZE5BI.js';
-import { FillInTheBlanks } from './chunk-TCDJY3H6.js';
-import { GapSelect } from './chunk-ABJJ3LII.js';
-import { Dictation } from './chunk-RBS5A2DF.js';
-import { ReadAloud, stopCaptureGroup } from './chunk-DC4CQCK5.js';
-import { randomSessionId, takeOf, mintTake, SequenceSlotContext } from './chunk-MXNC5UNO.js';
-import { useLkStrings } from './chunk-HNLRVRQR.js';
-import { isItemGroup, flattenSequence, resolveDeliveryPolicy, resolveItemScoringPolicy, resolvePlaybackPolicy, slotMediaKey, stimulusMediaKey } from '@intellectif/lk-core';
-import { useRef, useState, useMemo, useEffect } from 'react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-
-function slotKeyOf(setKey, slot) {
-  return `${setKey}::slot-${slot.slotId}-${slot.activity.id}`;
-}
-function entryKeyOf(slot) {
-  return slot.slotId.split(".")[0] ?? slot.slotId;
-}
-var captureScopeCount = 0;
-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 }) });
-}
-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 ? (
-    // biome-ignore lint/suspicious/noAssignInExpressions: sanctioned lazy ref initialization
-    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);
-  };
-  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);
-  };
-  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,
-          // A take this pager hears of first through its answer — a consumer's
-          // renderer has no channel — has nothing on its way.
-          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();
-  };
-  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()
-      );
-    }
-  };
-  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,
-      // The take the grade is for: stamped by `<ReadAloud>`, and for a
-      // consumer's renderer, which cannot stamp one, the slot's latest.
-      takesAnswers ? takeOf(result) ?? takesRef.current.get(at.index)?.take : void 0
-    );
-  };
-  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;
-  };
-  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();
-  };
-  const emitFor = (generation, at, type, payload) => {
-    if (!aliveRef.current || generation !== setGenerationRef.current) {
-      return;
-    }
-    onInteraction?.({
-      type,
-      activityId: at.activityId,
-      timestamp: Date.now(),
-      payload: payload ?? {}
-    });
-  };
-  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();
-  };
-  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
-  };
-  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;
-  };
-  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 next2 = new Map(held);
-            next2.delete(key);
-            return next2;
-          }
-          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;
-  };
-  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}`,
-        // A getter, so the channel keeps the one identity a recorder joined
-        // while still answering for the mode in force now.
-        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 \u2014 to the learner and to an appeal \u2014 from one that works. Budgeted media: ${[...new Set(budgetedMedia.map((m) => m.key))].join(", ")}.`
-      );
-    }
-    const resuming = responses !== void 0 && Object.keys(responses).length > 0 || submittedSlotIds !== void 0 && submittedSlotIds.length > 0;
-    if (resuming && 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} \xD7 maxPlays. Put the questions that share a recording in an item group \u2014 a group's stimulus is one recording with one budget.`
-      );
-    }
-  }
-  const bindingFor = (key, slot) => {
-    if (mediaBudget === void 0) {
-      return void 0;
-    }
-    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 } : {}
-    };
-  };
-  const recordingBindingFor = (slot) => {
-    if (recordingBinding === void 0) {
-      return void 0;
-    }
-    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 } : {},
-    // Handed to no question in `exam`, where none gives AI help: a
-    // `renderers` override is not given ports it must then know to ignore.
-    ...ai !== void 0 && renderMode !== "exam" ? { ai } : {},
-    // As given: each question combines it with the paper's through its
-    // channel, so what it is handed and what holds cannot disagree.
-    ...delivery !== void 0 && delivery !== null ? { delivery } : {},
-    // As given, for a `renderers` override to score by. The SDK's own questions
-    // read the paper's from their channel, which wins over it.
-    ...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 = {
-      // `defaultValue`, not `value`: the learner must be able to keep editing
-      // a restored answer. A controlled `value` would freeze it unless the
-      // consumer also threaded state back, which is not what resume means.
-      ...restored !== void 0 ? { defaultValue: restored } : {},
-      ...seedsApply && submitted.has(slotId) ? { defaultSubmitted: true } : {},
-      ...slotOutcome !== void 0 ? { outcome: slotOutcome } : {},
-      // One identity per slot for the life of the set — see `callsFor`. Their
-      // bodies are `submitSlot` and `completeSlot`, the same ones a host's own
-      // renderer calls, so a question the host draws is recorded exactly as one
-      // the SDK draws.
-      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, { 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
-        }
-      )
-    ] })
-  ] });
-}
-
-export { ActivitySequence };
-//# sourceMappingURL=chunk-G6PXJ2SA.js.map
-//# sourceMappingURL=chunk-G6PXJ2SA.js.map