@intellectif/lk-react 13.0.0 → 14.1.0

package/dist/chunk-UDCQTOVU.cjs

@@ -0,0 +1,523 @@
+'use client';
+'use strict';
+
+var react = require('react');
+
+// src/hooks/useSpeechRecorder.ts
+
+// src/hooks/speech-recorder/machine.ts
+var IDLE_RECORDER = {
+  status: "idle",
+  error: null,
+  level: 0,
+  elapsedMs: 0,
+  take: null,
+  takesUsed: 0
+};
+function reduceRecorder(state, event) {
+  switch (event.kind) {
+    case "requested":
+      return {
+        ...state,
+        status: "requesting-permission",
+        error: null,
+        level: 0,
+        elapsedMs: 0,
+        take: null
+      };
+    case "started":
+      return state.status === "requesting-permission" ? { ...state, status: "recording" } : state;
+    case "progress":
+      return state.status === "recording" ? { ...state, level: event.level, elapsedMs: event.elapsedMs } : state;
+    case "captured":
+      return {
+        ...state,
+        status: "recorded",
+        error: null,
+        level: 0,
+        elapsedMs: event.take.durationMs,
+        take: event.take,
+        takesUsed: state.takesUsed + 1
+      };
+    case "failed":
+      return { ...state, status: "error", error: event.error, level: 0, take: null };
+    case "discarded":
+      return { ...state, status: "idle", error: null, level: 0, elapsedMs: 0, take: null };
+    case "reset":
+      return state === IDLE_RECORDER ? state : IDLE_RECORDER;
+  }
+}
+
+// src/hooks/speech-recorder/resample.ts
+var TARGET_SAMPLE_RATE = 16e3;
+var CUTOFF_FRACTION = 0.45;
+var KERNEL_HALF_PERIODS = 8;
+function downmix(channels) {
+  if (channels.length === 0) {
+    return new Float32Array(0);
+  }
+  let frames = channels[0].length;
+  for (const channel of channels) {
+    if (channel.length < frames) {
+      frames = channel.length;
+    }
+  }
+  const mono = new Float32Array(frames);
+  for (const channel of channels) {
+    for (let frame = 0; frame < frames; frame += 1) {
+      mono[frame] += channel[frame];
+    }
+  }
+  for (let frame = 0; frame < frames; frame += 1) {
+    mono[frame] /= channels.length;
+  }
+  return mono;
+}
+function joinBlocks(blocks, frames) {
+  const joined = new Float32Array(frames);
+  let at = 0;
+  for (const block of blocks) {
+    joined.set(block, at);
+    at += block.length;
+  }
+  return joined;
+}
+function lowPass(samples, inputRate) {
+  const cutoff = TARGET_SAMPLE_RATE * CUTOFF_FRACTION / inputRate;
+  const half = Math.max(1, Math.round(KERNEL_HALF_PERIODS * inputRate / TARGET_SAMPLE_RATE));
+  const taps = new Float32Array(half * 2 + 1);
+  let gain = 0;
+  for (let tap = 0; tap < taps.length; tap += 1) {
+    const at = tap - half;
+    const angle = 2 * Math.PI * cutoff * at;
+    const sinc = at === 0 ? 2 * cutoff : Math.sin(angle) / (Math.PI * at);
+    const window = 0.5 - 0.5 * Math.cos(2 * Math.PI * tap / (taps.length - 1));
+    taps[tap] = sinc * window;
+    gain += taps[tap];
+  }
+  for (let tap = 0; tap < taps.length; tap += 1) {
+    taps[tap] /= gain;
+  }
+  const last = samples.length - 1;
+  const filtered = new Float32Array(samples.length);
+  for (let index = 0; index < samples.length; index += 1) {
+    let total = 0;
+    for (let tap = 0; tap < taps.length; tap += 1) {
+      const at = index + tap - half;
+      total += taps[tap] * samples[at < 0 ? 0 : at > last ? last : at];
+    }
+    filtered[index] = total;
+  }
+  return filtered;
+}
+function resampleToTarget(samples, inputRate) {
+  if (samples.length === 0) {
+    return new Float32Array(0);
+  }
+  if (inputRate === TARGET_SAMPLE_RATE) {
+    return samples.slice();
+  }
+  const source = inputRate > TARGET_SAMPLE_RATE ? lowPass(samples, inputRate) : samples;
+  const length = Math.round(samples.length * TARGET_SAMPLE_RATE / inputRate);
+  const resampled = new Float32Array(length);
+  const step = inputRate / TARGET_SAMPLE_RATE;
+  const last = source.length - 1;
+  for (let index = 0; index < length; index += 1) {
+    const at = index * step;
+    const left = Math.min(Math.floor(at), last);
+    const right = Math.min(left + 1, last);
+    const fraction = at - left;
+    resampled[index] = source[left] * (1 - fraction) + source[right] * fraction;
+  }
+  return resampled;
+}
+
+// src/hooks/speech-recorder/wav.ts
+var WAV_MIME_TYPE = "audio/wav";
+var HEADER_BYTES = 44;
+function writeTag(view, offset, tag) {
+  for (let index = 0; index < tag.length; index += 1) {
+    view.setUint8(offset + index, tag.charCodeAt(index));
+  }
+}
+function encodeWav16(samples, sampleRate) {
+  const dataBytes = samples.length * 2;
+  const bytes = new Uint8Array(HEADER_BYTES + dataBytes);
+  const view = new DataView(bytes.buffer);
+  writeTag(view, 0, "RIFF");
+  view.setUint32(4, HEADER_BYTES - 8 + dataBytes, true);
+  writeTag(view, 8, "WAVE");
+  writeTag(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  writeTag(view, 36, "data");
+  view.setUint32(40, dataBytes, true);
+  for (let index = 0; index < samples.length; index += 1) {
+    const sample = samples[index];
+    const clamped = sample < -1 ? -1 : sample > 1 ? 1 : sample;
+    view.setInt16(
+      HEADER_BYTES + index * 2,
+      Math.round(clamped * (clamped < 0 ? 32768 : 32767)),
+      true
+    );
+  }
+  return bytes;
+}
+function peakOf(samples) {
+  let peak = 0;
+  for (let index = 0; index < samples.length; index += 1) {
+    const magnitude = Math.abs(samples[index]);
+    if (magnitude > peak) {
+      peak = magnitude;
+    }
+  }
+  return peak > 1 ? 1 : peak;
+}
+function rmsOf(samples) {
+  if (samples.length === 0) {
+    return 0;
+  }
+  let total = 0;
+  for (let index = 0; index < samples.length; index += 1) {
+    total += samples[index] * samples[index];
+  }
+  const rms = Math.sqrt(total / samples.length);
+  return rms > 1 ? 1 : rms;
+}
+
+// src/hooks/speech-recorder/worklet.ts
+var CAPTURE_PROCESSOR = "lk-speech-capture";
+var CAPTURE_PROCESSOR_SOURCE = `class LkSpeechCapture extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input === undefined || input.length === 0) {
+      return true;
+    }
+    const block = [];
+    for (let channel = 0; channel < input.length; channel += 1) {
+      block.push(input[channel].slice());
+    }
+    this.port.postMessage(block);
+    return true;
+  }
+}
+registerProcessor(${JSON.stringify(CAPTURE_PROCESSOR)}, LkSpeechCapture);
+`;
+function createProcessorUrl() {
+  const urls = globalThis.URL;
+  if (urls === void 0) {
+    return null;
+  }
+  const create = urls.createObjectURL;
+  const revoke = urls.revokeObjectURL;
+  if (create === void 0 || revoke === void 0) {
+    return null;
+  }
+  const url = create.call(urls, new Blob([CAPTURE_PROCESSOR_SOURCE], { type: "text/javascript" }));
+  return {
+    url,
+    release: () => {
+      revoke.call(urls, url);
+    }
+  };
+}
+
+// src/hooks/useSpeechRecorder.ts
+var PROCESSOR_BUFFER_FRAMES = 4096;
+var LEVEL_UPDATES_PER_SECOND = 10;
+function stopTracks(stream) {
+  for (const track of stream.getTracks()) {
+    track.stop();
+  }
+}
+function closeQuietly(context) {
+  void context.close().catch(() => {
+  });
+}
+function microphoneError(error) {
+  switch (error?.name) {
+    case "NotAllowedError":
+    case "SecurityError":
+      return "permission-denied";
+    case "NotFoundError":
+      return "no-device";
+    case "NotSupportedError":
+      return "unsupported";
+    default:
+      return "failed";
+  }
+}
+async function createWorkletNode(context, workletUrl, onBlock) {
+  const AudioWorkletNodeConstructor = globalThis.AudioWorkletNode;
+  const worklet = context.audioWorklet;
+  if (AudioWorkletNodeConstructor === void 0 || worklet === void 0) {
+    return null;
+  }
+  const minted = workletUrl === void 0 ? createProcessorUrl() : null;
+  const url = workletUrl ?? minted?.url;
+  if (url === void 0) {
+    return null;
+  }
+  try {
+    await worklet.addModule(url);
+    const node = new AudioWorkletNodeConstructor(context, CAPTURE_PROCESSOR);
+    node.port.onmessage = (event) => {
+      onBlock(event.data);
+    };
+    return {
+      node,
+      detach: () => {
+        node.port.onmessage = null;
+      }
+    };
+  } catch {
+    return null;
+  } finally {
+    minted?.release();
+  }
+}
+function createProcessorNode(context, onBlock) {
+  const create = context.createScriptProcessor;
+  if (create === void 0) {
+    return null;
+  }
+  const node = create.call(context, PROCESSOR_BUFFER_FRAMES, 1, 1);
+  node.onaudioprocess = (event) => {
+    const buffer = event.inputBuffer;
+    const channels = [];
+    for (let channel = 0; channel < buffer.numberOfChannels; channel += 1) {
+      channels.push(buffer.getChannelData(channel));
+    }
+    onBlock(channels);
+  };
+  return {
+    node,
+    detach: () => {
+      node.onaudioprocess = null;
+    }
+  };
+}
+function useSpeechRecorder(options) {
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = react.useState(IDLE_RECORDER);
+  const stateRef = react.useRef(IDLE_RECORDER);
+  const sessionRef = react.useRef(null);
+  const startingRef = react.useRef(false);
+  const attemptRef = react.useRef(0);
+  const dispatch = react.useCallback((event) => {
+    const next = reduceRecorder(stateRef.current, event);
+    if (next === stateRef.current) {
+      return;
+    }
+    stateRef.current = next;
+    setState(next);
+  }, []);
+  const endSession = react.useCallback(() => {
+    const session = sessionRef.current;
+    sessionRef.current = null;
+    session?.release();
+  }, []);
+  const finish = react.useCallback(() => {
+    const session = sessionRef.current;
+    if (session === null) {
+      return;
+    }
+    sessionRef.current = null;
+    session.release();
+    const { minDurationMs } = optionsRef.current;
+    const samples = resampleToTarget(joinBlocks(session.blocks, session.frames), session.rate);
+    const durationMs = samples.length / TARGET_SAMPLE_RATE * 1e3;
+    if (minDurationMs !== void 0 && durationMs < minDurationMs) {
+      dispatch({ kind: "failed", error: "too-short" });
+      return;
+    }
+    dispatch({
+      kind: "captured",
+      take: {
+        blob: new Blob([encodeWav16(samples, TARGET_SAMPLE_RATE)], { type: WAV_MIME_TYPE }),
+        mimeType: WAV_MIME_TYPE,
+        durationMs,
+        peakLevel: peakOf(samples)
+      }
+    });
+  }, [dispatch]);
+  const handleBlock = react.useCallback(
+    (channels) => {
+      const session = sessionRef.current;
+      if (session === null) {
+        return;
+      }
+      let block = downmix(channels);
+      const room = session.maxFrames - session.frames;
+      if (block.length > room) {
+        block = block.subarray(0, room);
+      }
+      session.blocks.push(block);
+      session.frames += block.length;
+      const level = rmsOf(block);
+      if (level > session.peak) {
+        session.peak = level;
+      }
+      if (session.frames >= session.maxFrames) {
+        finish();
+        return;
+      }
+      if (session.frames - session.reportedAt < session.rate / LEVEL_UPDATES_PER_SECOND) {
+        return;
+      }
+      session.reportedAt = session.frames;
+      const peak = session.peak;
+      session.peak = 0;
+      dispatch({
+        kind: "progress",
+        level: peak,
+        elapsedMs: session.frames / session.rate * 1e3
+      });
+    },
+    [dispatch, finish]
+  );
+  const start = react.useCallback(async () => {
+    const { maxDurationMs, maxTakes: maxTakes2, workletUrl } = optionsRef.current;
+    if (startingRef.current || sessionRef.current !== null) {
+      return;
+    }
+    if (maxTakes2 !== void 0 && stateRef.current.takesUsed >= maxTakes2) {
+      return;
+    }
+    const attempt = attemptRef.current;
+    startingRef.current = true;
+    dispatch({ kind: "requested" });
+    let release = () => {
+    };
+    try {
+      const view = globalThis;
+      const devices = view.navigator?.mediaDevices;
+      const getUserMedia = devices?.getUserMedia;
+      const AudioContextConstructor = view.AudioContext;
+      if (devices === void 0 || getUserMedia === void 0 || AudioContextConstructor === void 0) {
+        dispatch({ kind: "failed", error: "unsupported" });
+        return;
+      }
+      let stream;
+      try {
+        stream = await getUserMedia.call(devices, { audio: true });
+      } catch (error) {
+        dispatch({ kind: "failed", error: microphoneError(error) });
+        return;
+      }
+      release = () => {
+        stopTracks(stream);
+      };
+      if (attempt !== attemptRef.current) {
+        release();
+        dispatch({ kind: "discarded" });
+        return;
+      }
+      let context;
+      try {
+        context = new AudioContextConstructor();
+      } catch {
+        release();
+        dispatch({ kind: "failed", error: "unsupported" });
+        return;
+      }
+      const open = context;
+      release = () => {
+        stopTracks(stream);
+        closeQuietly(open);
+      };
+      const attached = await createWorkletNode(open, workletUrl, handleBlock) ?? createProcessorNode(open, handleBlock);
+      if (attached === null) {
+        release();
+        dispatch({ kind: "failed", error: "unsupported" });
+        return;
+      }
+      const source = open.createMediaStreamSource(stream);
+      const sink = open.createGain();
+      sink.gain.value = 0;
+      source.connect(attached.node);
+      attached.node.connect(sink);
+      sink.connect(open.destination);
+      release = () => {
+        attached.detach();
+        attached.node.disconnect();
+        source.disconnect();
+        sink.disconnect();
+        stopTracks(stream);
+        closeQuietly(open);
+      };
+      if (attempt !== attemptRef.current) {
+        release();
+        dispatch({ kind: "discarded" });
+        return;
+      }
+      sessionRef.current = {
+        blocks: [],
+        frames: 0,
+        rate: open.sampleRate,
+        maxFrames: Math.max(1, Math.floor(maxDurationMs / 1e3 * open.sampleRate)),
+        peak: 0,
+        reportedAt: 0,
+        release
+      };
+      dispatch({ kind: "started" });
+    } catch {
+      release();
+      sessionRef.current = null;
+      dispatch({ kind: "failed", error: "failed" });
+    } finally {
+      startingRef.current = false;
+    }
+  }, [dispatch, handleBlock]);
+  const stop = react.useCallback(() => {
+    if (sessionRef.current === null) {
+      attemptRef.current += 1;
+      return;
+    }
+    finish();
+  }, [finish]);
+  const discard = react.useCallback(() => {
+    attemptRef.current += 1;
+    endSession();
+    dispatch({ kind: "discarded" });
+  }, [dispatch, endSession]);
+  const reset = react.useCallback(() => {
+    attemptRef.current += 1;
+    endSession();
+    dispatch({ kind: "reset" });
+  }, [dispatch, endSession]);
+  react.useEffect(() => {
+    return () => {
+      attemptRef.current += 1;
+      endSession();
+    };
+  }, [endSession]);
+  const { maxTakes } = options;
+  return react.useMemo(
+    () => ({
+      status: state.status,
+      error: state.error,
+      level: state.level,
+      elapsedMs: state.elapsedMs,
+      take: state.take,
+      takesUsed: state.takesUsed,
+      canRecord: maxTakes === void 0 || state.takesUsed < maxTakes,
+      start,
+      stop,
+      discard,
+      reset
+    }),
+    [state, maxTakes, start, stop, discard, reset]
+  );
+}
+
+exports.CAPTURE_PROCESSOR_SOURCE = CAPTURE_PROCESSOR_SOURCE;
+exports.useSpeechRecorder = useSpeechRecorder;
+//# sourceMappingURL=chunk-UDCQTOVU.cjs.map
+//# sourceMappingURL=chunk-UDCQTOVU.cjs.map

package/dist/chunk-UDCQTOVU.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/speech-recorder/machine.ts","../src/hooks/speech-recorder/resample.ts","../src/hooks/speech-recorder/wav.ts","../src/hooks/speech-recorder/worklet.ts","../src/hooks/useSpeechRecorder.ts"],"names":["useRef","useState","useCallback","maxTakes","useEffect","useMemo"],"mappings":"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","file":"chunk-UDCQTOVU.cjs","sourcesContent":["'use client';\n\n/**\n * The recorder's state, as one pure reduction.\n *\n * Kept out of the hook because the hook's own work — opening a microphone,\n * building a graph, tearing both down — is asynchronous, and a state machine\n * spread across five callbacks is exactly where an auto-stop that races a\n * learner's `stop()` hides. Every transition is here, synchronous and\n * testable without a microphone; the hook only says which event happened.\n *\n * No transition reads a browser global, which is what lets `status`, `error`\n * and `canRecord` be rendered on a server.\n */\n\n/** A recording the learner has made and not yet discarded. */\nexport interface RecordedTake {\n  /** Mono 16-bit PCM WAV at 16 kHz — the format `inspectWav` measures. */\n  blob: Blob;\n  mimeType: string;\n  /** The encoded recording's own length, not a wall-clock timing of the attempt. */\n  durationMs: number;\n  /** The loudest sample of the take, 0..1. */\n  peakLevel: number;\n}\n\nexport type SpeechRecorderStatus =\n  | 'idle'\n  | 'requesting-permission'\n  | 'recording'\n  | 'recorded'\n  | 'error';\n\nexport type SpeechRecorderError =\n  | 'permission-denied'\n  | 'no-device'\n  | 'unsupported'\n  | 'too-short'\n  | 'failed';\n\nexport interface RecorderState {\n  status: SpeechRecorderStatus;\n  error: SpeechRecorderError | null;\n  level: number;\n  elapsedMs: number;\n  take: RecordedTake | null;\n  takesUsed: number;\n}\n\nexport type RecorderEvent =\n  | { kind: 'requested' }\n  | { kind: 'started' }\n  | { kind: 'progress'; level: number; elapsedMs: number }\n  | { kind: 'captured'; take: RecordedTake }\n  | { kind: 'failed'; error: SpeechRecorderError }\n  | { kind: 'discarded' }\n  | { kind: 'reset' };\n\n/** The state a recorder mounts in, on a server as on a client. */\nexport const IDLE_RECORDER: RecorderState = {\n  status: 'idle',\n  error: null,\n  level: 0,\n  elapsedMs: 0,\n  take: null,\n  takesUsed: 0,\n};\n\n/**\n * Applies one event. Returns the state it was given, unchanged and identical,\n * when the event moves nothing — so a block arriving after teardown costs no\n * render.\n */\nexport function reduceRecorder(state: RecorderState, event: RecorderEvent): RecorderState {\n  switch (event.kind) {\n    case 'requested':\n      // A new attempt clears the previous take. The learner has replaced it,\n      // and a take left on screen through the next recording would offer a\n      // submit button for audio that is no longer the one just made.\n      return {\n        ...state,\n        status: 'requesting-permission',\n        error: null,\n        level: 0,\n        elapsedMs: 0,\n        take: null,\n      };\n    case 'started':\n      // Only from a request this machine made. A microphone that opens after\n      // the learner discarded the attempt must not put the meter back up.\n      return state.status === 'requesting-permission' ? { ...state, status: 'recording' } : state;\n    case 'progress':\n      return state.status === 'recording'\n        ? { ...state, level: event.level, elapsedMs: event.elapsedMs }\n        : state;\n    case 'captured':\n      // The take count rises here and nowhere else, and `discard` never gives\n      // one back: a budget a re-record refunded would bound nothing.\n      return {\n        ...state,\n        status: 'recorded',\n        error: null,\n        level: 0,\n        elapsedMs: event.take.durationMs,\n        take: event.take,\n        takesUsed: state.takesUsed + 1,\n      };\n    case 'failed':\n      // No take was produced, so none was spent — a cough must not cost a\n      // learner their only attempt. The elapsed time survives, because a\n      // \"too short\" message reads better beside the length that was too short.\n      return { ...state, status: 'error', error: event.error, level: 0, take: null };\n    case 'discarded':\n      return { ...state, status: 'idle', error: null, level: 0, elapsedMs: 0, take: null };\n    case 'reset':\n      // The budget goes back, which is the whole difference from `discarded`.\n      // A discard is the same learner replacing their own take and must pay\n      // for it; a reset is a different reading altogether — a new activity in\n      // the same mounted component — and the takes it may have are its own.\n      return state === IDLE_RECORDER ? state : IDLE_RECORDER;\n  }\n}\n","'use client';\n\n/**\n * Turning the blocks a capture node delivers into one mono 16 kHz signal.\n *\n * 16 kHz mono is the rate every mainstream assessor accepts and the rate\n * `inspectWav` measures exactly, while a microphone is opened at whatever rate\n * the device runs at — 44.1 or 48 kHz on most, already 16 kHz on some. The\n * three steps are separated and pure so the arithmetic that decides what a\n * server will measure can be tested without a browser.\n */\n\n/** The capture rate every mainstream assessor accepts. */\nexport const TARGET_SAMPLE_RATE = 16_000;\n\n/**\n * Where the anti-alias filter stops passing, as a fraction of the target rate.\n *\n * Below 0.5 on purpose: a filter cutting at exactly the target's Nyquist is\n * only 6 dB down there and its transition band folds straight back into the\n * signal. Cutting at 7.2 kHz leaves the transition band room to finish before\n * 8 kHz, and speech carries next to nothing in the 800 Hz that costs.\n */\nconst CUTOFF_FRACTION = 0.45;\n\n/**\n * Half the kernel width, counted in target-rate sample periods. Sixteen\n * periods of taps is enough Hann-windowed sinc to put a tone an octave above\n * the cutoff far below anything a meter or an assessor would notice, and short\n * enough that filtering a whole take costs a fraction of a second.\n */\nconst KERNEL_HALF_PERIODS = 8;\n\n/**\n * Averages the channels of one capture block into mono.\n *\n * Always allocates, never returns what it was given: a `ScriptProcessorNode`\n * hands out the same buffer on every callback and overwrites it in place, so a\n * mono capture that passed the input straight through would find every block\n * it had kept replaced by the last one.\n *\n * Channels of unequal length are read to the shortest. Nothing should produce\n * them, and the alternative to a bound is reading past the end of one and\n * poisoning the whole take with NaN.\n */\nexport function downmix(channels: readonly Float32Array[]): Float32Array {\n  if (channels.length === 0) {\n    return new Float32Array(0);\n  }\n  let frames = channels[0].length;\n  for (const channel of channels) {\n    if (channel.length < frames) {\n      frames = channel.length;\n    }\n  }\n  const mono = new Float32Array(frames);\n  for (const channel of channels) {\n    for (let frame = 0; frame < frames; frame += 1) {\n      mono[frame] += channel[frame];\n    }\n  }\n  for (let frame = 0; frame < frames; frame += 1) {\n    mono[frame] /= channels.length;\n  }\n  return mono;\n}\n\n/** Concatenates captured blocks into the single signal a take is encoded from. */\nexport function joinBlocks(blocks: readonly Float32Array[], frames: number): Float32Array {\n  const joined = new Float32Array(frames);\n  let at = 0;\n  for (const block of blocks) {\n    joined.set(block, at);\n    at += block.length;\n  }\n  return joined;\n}\n\n/**\n * A windowed-sinc low-pass, applied at the input rate before any samples are\n * dropped.\n *\n * Without it, resampling is aliasing: every component above the target's\n * Nyquist folds back down into the speech band as a tone that was never\n * spoken, and an assessor scores what it hears. The window is Hann and the\n * kernel is normalised to unit gain, so a signal already inside the band comes\n * through at its own amplitude.\n *\n * Edges are extended by repeating the first and last sample rather than by\n * zero-padding, which would put a step — and so a click — at each end of every\n * take.\n */\nfunction lowPass(samples: Float32Array, inputRate: number): Float32Array {\n  const cutoff = (TARGET_SAMPLE_RATE * CUTOFF_FRACTION) / inputRate;\n  const half = Math.max(1, Math.round((KERNEL_HALF_PERIODS * inputRate) / TARGET_SAMPLE_RATE));\n  const taps = new Float32Array(half * 2 + 1);\n  let gain = 0;\n  for (let tap = 0; tap < taps.length; tap += 1) {\n    const at = tap - half;\n    const angle = 2 * Math.PI * cutoff * at;\n    const sinc = at === 0 ? 2 * cutoff : Math.sin(angle) / (Math.PI * at);\n    const window = 0.5 - 0.5 * Math.cos((2 * Math.PI * tap) / (taps.length - 1));\n    taps[tap] = sinc * window;\n    gain += taps[tap];\n  }\n  for (let tap = 0; tap < taps.length; tap += 1) {\n    taps[tap] /= gain;\n  }\n\n  const last = samples.length - 1;\n  const filtered = new Float32Array(samples.length);\n  for (let index = 0; index < samples.length; index += 1) {\n    let total = 0;\n    for (let tap = 0; tap < taps.length; tap += 1) {\n      const at = index + tap - half;\n      total += taps[tap] * samples[at < 0 ? 0 : at > last ? last : at];\n    }\n    filtered[index] = total;\n  }\n  return filtered;\n}\n\n/**\n * Resamples mono samples from `inputRate` to {@link TARGET_SAMPLE_RATE}.\n *\n * Every path returns an array the caller owns, the equal-rate one included, so\n * no caller has to know whether it was handed its own buffer back.\n *\n * The filter runs only when the rate is coming down. Interpolating upwards\n * invents no frequencies above the input's own Nyquist, so there is nothing\n * for an anti-alias filter to remove and applying one would only dull a\n * recording a 16 kHz device already captured cleanly.\n */\nexport function resampleToTarget(samples: Float32Array, inputRate: number): Float32Array {\n  if (samples.length === 0) {\n    return new Float32Array(0);\n  }\n  if (inputRate === TARGET_SAMPLE_RATE) {\n    return samples.slice();\n  }\n  const source = inputRate > TARGET_SAMPLE_RATE ? lowPass(samples, inputRate) : samples;\n  const length = Math.round((samples.length * TARGET_SAMPLE_RATE) / inputRate);\n  const resampled = new Float32Array(length);\n  const step = inputRate / TARGET_SAMPLE_RATE;\n  const last = source.length - 1;\n  for (let index = 0; index < length; index += 1) {\n    const at = index * step;\n    const left = Math.min(Math.floor(at), last);\n    const right = Math.min(left + 1, last);\n    const fraction = at - left;\n    resampled[index] = source[left] * (1 - fraction) + source[right] * fraction;\n  }\n  return resampled;\n}\n","'use client';\n\n/**\n * 16-bit PCM WAV, and the two level measurements taken over the same samples.\n *\n * This is the one format the SDK's `inspectWav` reads, so these bytes are the\n * bytes a server measures a take with — anything else would need a decoder on\n * the application's side before a grade could exist. Nothing here touches Web\n * Audio, which is why the encoder can be unit tested against `inspectWav`\n * itself rather than against a browser.\n */\n\n/** The media type of what {@link encodeWav16} returns. */\nexport const WAV_MIME_TYPE = 'audio/wav';\n\n/** RIFF + a 16-byte `fmt ` + `data`, every field fixed-size. */\nconst HEADER_BYTES = 44;\n\n/** Writes four ASCII characters, which is all a RIFF tag ever is. */\nfunction writeTag(view: DataView, offset: number, tag: string): void {\n  for (let index = 0; index < tag.length; index += 1) {\n    view.setUint8(offset + index, tag.charCodeAt(index));\n  }\n}\n\n/**\n * Encodes mono samples as a 16-bit PCM WAV.\n *\n * The two scale factors are not a typo. Signed 16-bit runs from -32768 to\n * 32767, so a single factor cannot reach full scale in both directions: 0x7fff\n * throughout leaves a full-scale negative peak reading -0.99997, and 0x8000\n * throughout overflows into the positive at +1. Each sign gets the factor that\n * lands exactly on its own limit.\n *\n * The buffer is named in the return type because a `Blob` refuses a view that\n * might be backed by a `SharedArrayBuffer`, and these bytes go straight into\n * one.\n */\nexport function encodeWav16(samples: Float32Array, sampleRate: number): Uint8Array<ArrayBuffer> {\n  const dataBytes = samples.length * 2;\n  const bytes = new Uint8Array(HEADER_BYTES + dataBytes);\n  const view = new DataView(bytes.buffer);\n\n  writeTag(view, 0, 'RIFF');\n  view.setUint32(4, HEADER_BYTES - 8 + dataBytes, true);\n  writeTag(view, 8, 'WAVE');\n  writeTag(view, 12, 'fmt ');\n  view.setUint32(16, 16, true);\n  view.setUint16(20, 1, true); // PCM, uncompressed\n  view.setUint16(22, 1, true); // mono\n  view.setUint32(24, sampleRate, true);\n  view.setUint32(28, sampleRate * 2, true); // byte rate: one channel of two bytes\n  view.setUint16(32, 2, true); // block align\n  view.setUint16(34, 16, true); // bits per sample\n  writeTag(view, 36, 'data');\n  view.setUint32(40, dataBytes, true);\n\n  for (let index = 0; index < samples.length; index += 1) {\n    const sample = samples[index];\n    const clamped = sample < -1 ? -1 : sample > 1 ? 1 : sample;\n    view.setInt16(\n      HEADER_BYTES + index * 2,\n      Math.round(clamped * (clamped < 0 ? 0x8000 : 0x7fff)),\n      true,\n    );\n  }\n  return bytes;\n}\n\n/** The loudest sample, 0..1 — what a take reports as its `peakLevel`. */\nexport function peakOf(samples: Float32Array): number {\n  let peak = 0;\n  for (let index = 0; index < samples.length; index += 1) {\n    const magnitude = Math.abs(samples[index]);\n    if (magnitude > peak) {\n      peak = magnitude;\n    }\n  }\n  return peak > 1 ? 1 : peak;\n}\n\n/**\n * Root mean square, 0..1 — what the recorder reports as its `level`.\n *\n * RMS rather than the peak, because a meter driven by peaks sits near full\n * scale on any speech at all and tells a learner nothing about whether they\n * are being heard. It is also the measure `inspectWav` decides voiced time\n * with, so what the meter shows and what the server later counts as speech are\n * the same quantity.\n */\nexport function rmsOf(samples: Float32Array): number {\n  if (samples.length === 0) {\n    return 0;\n  }\n  let total = 0;\n  for (let index = 0; index < samples.length; index += 1) {\n    total += samples[index] * samples[index];\n  }\n  const rms = Math.sqrt(total / samples.length);\n  return rms > 1 ? 1 : rms;\n}\n","'use client';\n\n/**\n * The audio worklet processor, and the module URL it is loaded through.\n *\n * The processor must run inside `AudioWorkletGlobalScope`, which can only be\n * reached by URL. Source text turned into a Blob URL is the only form of that\n * which needs nothing of the consuming application: `import.meta` is not\n * available in every target this package is bundled for — the CommonJS build\n * among them — and a separate asset file would have to be copied into the\n * public directory of every application that installs the SDK.\n *\n * An application whose Content-Security-Policy refuses that URL self-hosts the\n * same source and passes its URL as `workletUrl` instead. The source is public\n * for exactly that reason — see {@link CAPTURE_PROCESSOR_SOURCE}.\n */\n\n/** The name the processor registers itself under, and is constructed by. */\nexport const CAPTURE_PROCESSOR = 'lk-speech-capture';\n\n/**\n * The audio worklet module `useSpeechRecorder` captures through, as source\n * text — exported so an application with a strict Content-Security-Policy can\n * serve it itself.\n *\n * By default the hook loads this text from a `blob:` URL. A worklet module is\n * loaded as a script, so it is `script-src` that must allow `blob:` —\n * `worker-src` does not govern it. Where that is refused, write this string to\n * a file your policy's `script-src` does allow, at build time and from the\n * installed package so it moves with the version you run, and pass that file's\n * URL as `workletUrl`:\n *\n * ```ts\n * import { writeFileSync } from 'node:fs';\n * import { CAPTURE_PROCESSOR_SOURCE } from '@intellectif/lk-react/hooks/useSpeechRecorder';\n *\n * writeFileSync('public/lk-speech-capture.js', CAPTURE_PROCESSOR_SOURCE);\n * ```\n *\n * **The contract** a module at `workletUrl` must meet, which this source does:\n * register an `AudioWorkletProcessor` under the name `lk-speech-capture`, and\n * from its `process(inputs)` post the first input's channels to its `port` as\n * an array with one `Float32Array` per channel, **copied** — the render\n * quantum's buffers belong to the audio thread and are overwritten on the next\n * quantum, so a block posted without copying arrives as whatever the\n * microphone heard some milliseconds later. Return `true`, which keeps the\n * processor alive while its source is silent. Anything else changes what is\n * recorded, so serve this text unchanged rather than a copy of your own.\n */\nexport const CAPTURE_PROCESSOR_SOURCE = `class LkSpeechCapture extends AudioWorkletProcessor {\n  process(inputs) {\n    const input = inputs[0];\n    if (input === undefined || input.length === 0) {\n      return true;\n    }\n    const block = [];\n    for (let channel = 0; channel < input.length; channel += 1) {\n      block.push(input[channel].slice());\n    }\n    this.port.postMessage(block);\n    return true;\n  }\n}\nregisterProcessor(${JSON.stringify(CAPTURE_PROCESSOR)}, LkSpeechCapture);\n`;\n\n/** A module URL and the release that frees it. */\nexport interface ProcessorModule {\n  url: string;\n  release(): void;\n}\n\n/** The object-URL pair, as much of it as an environment happens to have. */\ninterface ObjectUrls {\n  createObjectURL?(blob: Blob): string;\n  revokeObjectURL?(url: string): void;\n}\n\n/**\n * Wraps {@link CAPTURE_PROCESSOR_SOURCE} in an object URL.\n *\n * Returns `null` where object URLs are unavailable — a server render, a test\n * environment, a hardened embedder — rather than throwing, because the caller\n * has a working fallback for exactly that case and a missing URL factory is\n * not a failed recording.\n *\n * Called from `start()` and never at module scope: `URL.createObjectURL` is a\n * browser global, and reading one while a module is evaluated is what breaks a\n * server render.\n */\nexport function createProcessorUrl(): ProcessorModule | null {\n  const urls = (globalThis as { URL?: ObjectUrls }).URL;\n  if (urls === undefined) {\n    return null;\n  }\n  const create = urls.createObjectURL;\n  const revoke = urls.revokeObjectURL;\n  if (create === undefined || revoke === undefined) {\n    return null;\n  }\n  const url = create.call(urls, new Blob([CAPTURE_PROCESSOR_SOURCE], { type: 'text/javascript' }));\n  return {\n    url,\n    release: () => {\n      revoke.call(urls, url);\n    },\n  };\n}\n","'use client';\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport {\n  IDLE_RECORDER,\n  type RecordedTake,\n  type RecorderEvent,\n  type RecorderState,\n  reduceRecorder,\n  type SpeechRecorderError,\n  type SpeechRecorderStatus,\n} from './speech-recorder/machine.js';\nimport {\n  downmix,\n  joinBlocks,\n  resampleToTarget,\n  TARGET_SAMPLE_RATE,\n} from './speech-recorder/resample.js';\nimport { encodeWav16, peakOf, rmsOf, WAV_MIME_TYPE } from './speech-recorder/wav.js';\nimport { CAPTURE_PROCESSOR, createProcessorUrl } from './speech-recorder/worklet.js';\n\n// Public because `workletUrl` is: an option that names a module is only usable\n// if the module's text can be reached without reading a minified chunk.\nexport { CAPTURE_PROCESSOR_SOURCE } from './speech-recorder/worklet.js';\nexport type { RecordedTake, SpeechRecorderError, SpeechRecorderStatus };\n\nexport interface SpeechRecorderOptions {\n  /** The longest a take may be. Reached, the recording stops itself. */\n  maxDurationMs: number;\n  /** Shorter than this and the take is refused as `too-short`. */\n  minDurationMs?: number;\n  /** How many takes the learner may make. Unbounded when absent. */\n  maxTakes?: number;\n  /**\n   * The URL of a self-hosted copy of {@link CAPTURE_PROCESSOR_SOURCE}, for an\n   * application whose Content-Security-Policy does not allow `blob:` in\n   * `script-src`. Serve that string unchanged; the contract a module here must\n   * meet is written on it.\n   *\n   * **A URL that does not work is not reported.** If the module fails to load,\n   * or loads without registering `lk-speech-capture`, the hook records through\n   * the deprecated `ScriptProcessorNode` on the main thread instead — the\n   * fallback it keeps for engines without audio worklets — and a recorder with\n   * a broken `workletUrl` looks like a working one. Only an engine with neither\n   * path reports `error: 'unsupported'`. Check that the module is actually\n   * fetched.\n   */\n  workletUrl?: string;\n}\n\nexport interface SpeechRecorder {\n  status: SpeechRecorderStatus;\n  error: SpeechRecorderError | null;\n  /** The loudest block since the last update, 0..1. */\n  level: number;\n  /** How much audio has been captured, from the sample count. */\n  elapsedMs: number;\n  take: RecordedTake | null;\n  takesUsed: number;\n  /** Whether a take remains. Not whether a `start()` would be accepted now. */\n  canRecord: boolean;\n  /** Opens the microphone and begins capturing. **Never rejects.** */\n  start(): Promise<void>;\n  /** Ends the capture and encodes the take. */\n  stop(): void;\n  /** Throws the take away and releases the microphone. */\n  discard(): void;\n  /**\n   * Starts over: releases the microphone, throws the take away **and gives the\n   * budget back**.\n   *\n   * That last part is the whole difference from {@link SpeechRecorder.discard},\n   * which deliberately refunds nothing — a budget a re-record gave back would\n   * bound nothing. A reset is for a recorder that has been handed a different\n   * reading while it stayed mounted: the takes belong to the activity, so the\n   * next activity's are its own. Calling it for the same reading hands a\n   * learner takes they have already spent.\n   */\n  reset(): void;\n}\n\n/**\n * The capture graph, typed by the surface this hook uses rather than by the\n * DOM lib.\n *\n * Two reasons, both load-bearing. The lib declares `audioWorklet` and\n * `createScriptProcessor` non-optional, and the engines this hook falls back\n * for are exactly the ones missing one or the other — comparing a type that\n * cannot be `undefined` against `undefined` is a compile error, so the lib's\n * types would force the fallback to be written blind. And a test harness can\n * implement these six members; it cannot implement `BaseAudioContext`.\n */\ninterface CaptureNode {\n  connect(destination: CaptureNode): unknown;\n  disconnect(): void;\n}\n\ninterface CaptureGain extends CaptureNode {\n  readonly gain: { value: number };\n}\n\ninterface WorkletCaptureNode extends CaptureNode {\n  readonly port: { onmessage: ((event: { data: unknown }) => void) | null };\n}\n\ninterface ScriptProcessorCaptureNode extends CaptureNode {\n  onaudioprocess:\n    | ((event: {\n        inputBuffer: { numberOfChannels: number; getChannelData(channel: number): Float32Array };\n      }) => void)\n    | null;\n}\n\ninterface CaptureStream {\n  getTracks(): readonly { stop(): void }[];\n}\n\ninterface CaptureContext {\n  readonly sampleRate: number;\n  readonly destination: CaptureNode;\n  readonly audioWorklet?: { addModule(url: string): Promise<void> };\n  createMediaStreamSource(stream: CaptureStream): CaptureNode;\n  createGain(): CaptureGain;\n  createScriptProcessor?(\n    bufferFrames: number,\n    inputChannels: number,\n    outputChannels: number,\n  ): ScriptProcessorCaptureNode;\n  close(): Promise<void>;\n}\n\ninterface CaptureGlobals {\n  navigator?: {\n    mediaDevices?: { getUserMedia?(constraints: { audio: boolean }): Promise<CaptureStream> };\n  };\n  AudioContext?: new () => CaptureContext;\n  AudioWorkletNode?: new (context: CaptureContext, name: string) => WorkletCaptureNode;\n}\n\n/** A capture node and the removal of the handler it was given. */\ninterface AttachedNode {\n  node: CaptureNode;\n  /** Detaches the handler, so a block delivered after teardown reaches nothing. */\n  detach(): void;\n}\n\ntype BlockHandler = (channels: readonly Float32Array[]) => void;\n\n/** One recording in progress. Everything it holds must be released exactly once. */\ninterface CaptureSession {\n  blocks: Float32Array[];\n  frames: number;\n  rate: number;\n  /** The auto-stop deadline, as a sample count, beside the samples it bounds. */\n  maxFrames: number;\n  /** The loudest block since the meter last reported. */\n  peak: number;\n  /** The frame count at the last meter update. */\n  reportedAt: number;\n  release(): void;\n}\n\n/**\n * A `ScriptProcessorNode`'s buffer, in frames.\n *\n * This fallback runs its callback on the main thread, so the buffer has to\n * hold whatever a render blocks it for; 4096 frames is about 85 ms at 48 kHz,\n * and a smaller one drops samples out of the middle of a take whenever the\n * page is busy. The worklet path, which runs on the audio thread, needs none\n * of this.\n */\nconst PROCESSOR_BUFFER_FRAMES = 4096;\n\n/** How often the meter and the elapsed time may move. */\nconst LEVEL_UPDATES_PER_SECOND = 10;\n\nfunction stopTracks(stream: CaptureStream): void {\n  for (const track of stream.getTracks()) {\n    track.stop();\n  }\n}\n\nfunction closeQuietly(context: CaptureContext): void {\n  void context.close().catch(() => {\n    /* a context the page has already closed; nothing depends on the result */\n  });\n}\n\n/**\n * Which refusal `getUserMedia` made.\n *\n * Read from `name`, not from the message: messages are localised and are\n * rewritten between browser versions, while the names are specified. Anything\n * unrecognised is `failed` rather than a guess — telling a learner their\n * permission was denied when their device was busy sends them to the wrong\n * setting.\n */\nfunction microphoneError(error: unknown): SpeechRecorderError {\n  switch ((error as { name?: string } | null)?.name) {\n    case 'NotAllowedError':\n    case 'SecurityError':\n      return 'permission-denied';\n    case 'NotFoundError':\n      return 'no-device';\n    case 'NotSupportedError':\n      return 'unsupported';\n    default:\n      return 'failed';\n  }\n}\n\n/**\n * The worklet capture node, or `null` when this engine cannot build one.\n *\n * `null` rather than a throw for every one of its reasons — no\n * `AudioWorkletNode`, no worklet thread, an object URL the page's\n * Content-Security-Policy refuses, a module that fails to load — because none\n * of them is a failed recording: the caller has a working fallback for all of\n * them, and only the absence of both is an unsupported browser.\n */\nasync function createWorkletNode(\n  context: CaptureContext,\n  workletUrl: string | undefined,\n  onBlock: BlockHandler,\n): Promise<AttachedNode | null> {\n  const AudioWorkletNodeConstructor = (globalThis as unknown as CaptureGlobals).AudioWorkletNode;\n  const worklet = context.audioWorklet;\n  if (AudioWorkletNodeConstructor === undefined || worklet === undefined) {\n    return null;\n  }\n  const minted = workletUrl === undefined ? createProcessorUrl() : null;\n  const url = workletUrl ?? minted?.url;\n  if (url === undefined) {\n    return null;\n  }\n  try {\n    await worklet.addModule(url);\n    const node = new AudioWorkletNodeConstructor(context, CAPTURE_PROCESSOR);\n    node.port.onmessage = (event) => {\n      onBlock(event.data as readonly Float32Array[]);\n    };\n    return {\n      node,\n      detach: () => {\n        node.port.onmessage = null;\n      },\n    };\n  } catch {\n    return null;\n  } finally {\n    // Revoked as soon as the module has been fetched, whether it loaded or\n    // not: an object URL lives until the document is discarded otherwise, and\n    // this one is minted once per take.\n    minted?.release();\n  }\n}\n\n/** The `ScriptProcessorNode` fallback, or `null` on an engine without one. */\nfunction createProcessorNode(context: CaptureContext, onBlock: BlockHandler): AttachedNode | null {\n  const create = context.createScriptProcessor;\n  if (create === undefined) {\n    return null;\n  }\n  const node = create.call(context, PROCESSOR_BUFFER_FRAMES, 1, 1);\n  node.onaudioprocess = (event) => {\n    const buffer = event.inputBuffer;\n    const channels: Float32Array[] = [];\n    for (let channel = 0; channel < buffer.numberOfChannels; channel += 1) {\n      channels.push(buffer.getChannelData(channel));\n    }\n    onBlock(channels);\n  };\n  return {\n    node,\n    detach: () => {\n      node.onaudioprocess = null;\n    },\n  };\n}\n\n/**\n * Records a take of speech as mono 16-bit PCM WAV at 16 kHz.\n *\n * That is the one format the SDK measures directly: `inspectWav` reads it\n * without a decoding library, and it is what every mainstream pronunciation\n * assessor accepts. A take is captured at whatever rate the device runs at,\n * downmixed to mono, low-pass filtered and resampled, then encoded — so what a\n * server measures is what this hook produced, not a claim about it.\n *\n * **Server rendering.** `status`, `error` and `canRecord` are derived from the\n * take count alone and never from a browser global, so the markup a server\n * produces is the markup the browser's first render produces. Support is\n * discovered inside {@link SpeechRecorder.start} and reported as\n * `error: 'unsupported'`; the obvious `!!navigator.mediaDevices` guard at\n * render time would make a server render and its hydration disagree.\n *\n * **Identity.** `start`, `stop`, `discard` and `reset` keep one identity for the\n * life of the hook, so they are safe in a dependency array. The returned object keeps\n * one identity for as long as none of its values changes, so a render caused\n * by something else does not invalidate an effect that depends on it.\n *\n * `start()` does nothing when no take remains, so `canRecord` is presentation:\n * mark the control `aria-disabled` rather than `disabled`, which would take it\n * out of the tab order and leave a learner nothing to read.\n *\n * ```tsx\n * const recorder = useSpeechRecorder({ maxDurationMs: 20_000, maxTakes: 3 });\n * <button\n *   type=\"button\"\n *   aria-disabled={!recorder.canRecord}\n *   onClick={() => {\n *     void recorder.start();\n *   }}\n * >\n *   Record\n * </button>\n * ```\n */\nexport function useSpeechRecorder(options: SpeechRecorderOptions): SpeechRecorder {\n  // The latest options without changing `start`/`stop`/`discard`'s identity\n  // when the caller passes an inline object, exactly as `useXAPI` keeps its\n  // config.\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n\n  const [state, setState] = useState<RecorderState>(IDLE_RECORDER);\n  // The state as of this instant, written synchronously. Two events in one\n  // tick — an auto-stop reached inside a capture callback and the learner's\n  // own `stop()` — would otherwise both read the value React has not committed\n  // yet, which is the bug `AudioTransport` and `ActivitySequence` each carry a\n  // report of.\n  const stateRef = useRef<RecorderState>(IDLE_RECORDER);\n  const sessionRef = useRef<CaptureSession | null>(null);\n  const startingRef = useRef(false);\n  // Bumped by anything that abandons an attempt. `start()` re-reads it after\n  // every await: a learner who discards, or a component that unmounts, while\n  // the permission prompt is still open must not have a microphone opened\n  // behind them and left open for ever.\n  const attemptRef = useRef(0);\n\n  const dispatch = useCallback((event: RecorderEvent) => {\n    const next = reduceRecorder(stateRef.current, event);\n    if (next === stateRef.current) {\n      return;\n    }\n    stateRef.current = next;\n    setState(next);\n  }, []);\n\n  const endSession = useCallback(() => {\n    const session = sessionRef.current;\n    sessionRef.current = null;\n    session?.release();\n  }, []);\n\n  const finish = useCallback(() => {\n    const session = sessionRef.current;\n    if (session === null) {\n      return;\n    }\n    sessionRef.current = null;\n    session.release();\n\n    const { minDurationMs } = optionsRef.current;\n    const samples = resampleToTarget(joinBlocks(session.blocks, session.frames), session.rate);\n    // Taken from the encoded samples, so a take reports the duration a server\n    // will measure in its bytes rather than a wall-clock timing of the attempt.\n    //\n    // No second bound is applied here. The capture was bounded at the device's\n    // own rate, and resampling cannot push a whole-millisecond bound over:\n    // checked across every rate from 8 to 192 kHz and every bound up to five\n    // minutes, the encoded length never exceeds what the bound allows. (A\n    // fractional `maxDurationMs` can overshoot by up to a fortieth of a\n    // millisecond, which is less than one sample at this rate.)\n    const durationMs = (samples.length / TARGET_SAMPLE_RATE) * 1000;\n    if (minDurationMs !== undefined && durationMs < minDurationMs) {\n      dispatch({ kind: 'failed', error: 'too-short' });\n      return;\n    }\n    dispatch({\n      kind: 'captured',\n      take: {\n        blob: new Blob([encodeWav16(samples, TARGET_SAMPLE_RATE)], { type: WAV_MIME_TYPE }),\n        mimeType: WAV_MIME_TYPE,\n        durationMs,\n        peakLevel: peakOf(samples),\n      },\n    });\n  }, [dispatch]);\n\n  const handleBlock = useCallback(\n    (channels: readonly Float32Array[]) => {\n      const session = sessionRef.current;\n      if (session === null) {\n        return;\n      }\n      let block = downmix(channels);\n      const room = session.maxFrames - session.frames;\n      if (block.length > room) {\n        block = block.subarray(0, room);\n      }\n      session.blocks.push(block);\n      session.frames += block.length;\n      const level = rmsOf(block);\n      if (level > session.peak) {\n        session.peak = level;\n      }\n\n      // Auto-stop is measured from the samples themselves, never from a timer:\n      // the samples ARE the recording, so a take cannot run past its bound\n      // however the page's timers were scheduled, and there is no deadline\n      // left for a learner's own `stop()` to race.\n      if (session.frames >= session.maxFrames) {\n        finish();\n        return;\n      }\n      if (session.frames - session.reportedAt < session.rate / LEVEL_UPDATES_PER_SECOND) {\n        return;\n      }\n      session.reportedAt = session.frames;\n      // The meter reports the loudest block since it last did, not the latest\n      // one: at ten updates a second the latest block is one in forty, and a\n      // meter that samples speech that thinly flickers instead of reading.\n      const peak = session.peak;\n      session.peak = 0;\n      dispatch({\n        kind: 'progress',\n        level: peak,\n        elapsedMs: (session.frames / session.rate) * 1000,\n      });\n    },\n    [dispatch, finish],\n  );\n\n  const start = useCallback(async (): Promise<void> => {\n    const { maxDurationMs, maxTakes, workletUrl } = optionsRef.current;\n    // A second start while one is in flight, or while a capture is running, is\n    // a learner pressing twice; a start with no takes left is a control the\n    // caller should not have offered. Neither is an error worth a message.\n    if (startingRef.current || sessionRef.current !== null) {\n      return;\n    }\n    if (maxTakes !== undefined && stateRef.current.takesUsed >= maxTakes) {\n      return;\n    }\n    const attempt = attemptRef.current;\n    startingRef.current = true;\n    dispatch({ kind: 'requested' });\n    // Everything acquired so far, in the order it must be given back. Each\n    // step replaces it, so every early return and the catch release exactly\n    // what exists at that point.\n    let release = (): void => {};\n\n    try {\n      // Support is discovered HERE and nowhere else — see the hook's note on\n      // server rendering.\n      const view = globalThis as unknown as CaptureGlobals;\n      const devices = view.navigator?.mediaDevices;\n      const getUserMedia = devices?.getUserMedia;\n      const AudioContextConstructor = view.AudioContext;\n      if (\n        devices === undefined ||\n        getUserMedia === undefined ||\n        AudioContextConstructor === undefined\n      ) {\n        dispatch({ kind: 'failed', error: 'unsupported' });\n        return;\n      }\n\n      let stream: CaptureStream;\n      try {\n        stream = await getUserMedia.call(devices, { audio: true });\n      } catch (error) {\n        dispatch({ kind: 'failed', error: microphoneError(error) });\n        return;\n      }\n      release = () => {\n        stopTracks(stream);\n      };\n      if (attempt !== attemptRef.current) {\n        release();\n        dispatch({ kind: 'discarded' });\n        return;\n      }\n\n      let context: CaptureContext;\n      try {\n        context = new AudioContextConstructor();\n      } catch {\n        release();\n        dispatch({ kind: 'failed', error: 'unsupported' });\n        return;\n      }\n      const open = context;\n      release = () => {\n        stopTracks(stream);\n        closeQuietly(open);\n      };\n\n      const attached =\n        (await createWorkletNode(open, workletUrl, handleBlock)) ??\n        createProcessorNode(open, handleBlock);\n      if (attached === null) {\n        release();\n        dispatch({ kind: 'failed', error: 'unsupported' });\n        return;\n      }\n\n      const source = open.createMediaStreamSource(stream);\n      // A capture node is only pulled while it is reachable from the\n      // destination, so the graph ends in a gain of zero: without the\n      // connection some engines never call the processor at all, and with a\n      // plain one the learner hears themselves through their own speakers.\n      const sink = open.createGain();\n      sink.gain.value = 0;\n      source.connect(attached.node);\n      attached.node.connect(sink);\n      sink.connect(open.destination);\n      release = () => {\n        attached.detach();\n        attached.node.disconnect();\n        source.disconnect();\n        sink.disconnect();\n        stopTracks(stream);\n        closeQuietly(open);\n      };\n      if (attempt !== attemptRef.current) {\n        release();\n        dispatch({ kind: 'discarded' });\n        return;\n      }\n\n      sessionRef.current = {\n        blocks: [],\n        frames: 0,\n        rate: open.sampleRate,\n        maxFrames: Math.max(1, Math.floor((maxDurationMs / 1000) * open.sampleRate)),\n        peak: 0,\n        reportedAt: 0,\n        release,\n      };\n      dispatch({ kind: 'started' });\n    } catch {\n      // `start()` never rejects. A recorder that throws into a click handler\n      // leaves the learner with a dead control and no message, so anything\n      // unforeseen becomes `failed` — which the caller already has a message\n      // for — and gives back whatever had been acquired.\n      release();\n      sessionRef.current = null;\n      dispatch({ kind: 'failed', error: 'failed' });\n    } finally {\n      startingRef.current = false;\n    }\n  }, [dispatch, handleBlock]);\n\n  const stop = useCallback(() => {\n    if (sessionRef.current === null) {\n      // Before the microphone opens there is nothing to encode, so a stop is a\n      // cancelled attempt: the bump is what makes `start()` give back the\n      // stream it is about to be handed.\n      attemptRef.current += 1;\n      return;\n    }\n    finish();\n  }, [finish]);\n\n  const discard = useCallback(() => {\n    attemptRef.current += 1;\n    endSession();\n    dispatch({ kind: 'discarded' });\n  }, [dispatch, endSession]);\n\n  const reset = useCallback(() => {\n    attemptRef.current += 1;\n    endSession();\n    dispatch({ kind: 'reset' });\n  }, [dispatch, endSession]);\n\n  useEffect(() => {\n    // Cleanup only. Every acquisition happens inside `start()` and is released\n    // by the session it created, so the mount run has nothing to do and\n    // StrictMode's extra mount/cleanup pair leaks nothing.\n    return () => {\n      attemptRef.current += 1;\n      endSession();\n    };\n  }, [endSession]);\n\n  const { maxTakes } = options;\n  return useMemo(\n    () => ({\n      status: state.status,\n      error: state.error,\n      level: state.level,\n      elapsedMs: state.elapsedMs,\n      take: state.take,\n      takesUsed: state.takesUsed,\n      canRecord: maxTakes === undefined || state.takesUsed < maxTakes,\n      start,\n      stop,\n      discard,\n      reset,\n    }),\n    [state, maxTakes, start, stop, discard, reset],\n  );\n}\n"]}

package/dist/{chunk-5N7OLFHB.js → chunk-UDQS5INQ.js}

@@ -1,8 +1,9 @@
 'use client';
-import { ActivityErrorBoundary, isDevelopment, randomSessionId, FeedbackRegion, ANONYMOUS_ACTOR, objectIdFor } from './chunk-DQERNAWI.js';
-import { ActivityMedia } from './chunk-R7DI5UMU.js';
+import { FeedbackRegion } from './chunk-RCMYEWBE.js';
+import { ActivityErrorBoundary, isDevelopment, randomSessionId, ANONYMOUS_ACTOR, objectIdFor } from './chunk-B4BCEQNO.js';
+import { ActivityMedia } from './chunk-DB4DLHN6.js';
 import { useActivityState } from './chunk-6N43WDVG.js';
-import { useLkStrings } from './chunk-3Q4I4KT6.js';
+import { useLkStrings } from './chunk-AWQ53DON.js';
 import { validateActivity, ActivitySchemaError, seededShuffle, score, xAPIBuilder, xapiDefinitionFor } from '@intellectif/lk-core';
 import { useMemo, useRef, useState, useEffect, Fragment } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
@@ -290,5 +291,5 @@ function MultipleChoice2(props) {
 }
 
 export { MultipleChoice2 as MultipleChoice };
-//# sourceMappingURL=chunk-5N7OLFHB.js.map
-//# sourceMappingURL=chunk-5N7OLFHB.js.map
+//# sourceMappingURL=chunk-UDQS5INQ.js.map
+//# sourceMappingURL=chunk-UDQS5INQ.js.map