@molecule/app-audio-recorder-react 1.0.0

package/LICENSE

@@ -0,0 +1,115 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship.
+
+      "Contribution" shall mean any work of authorship, including the
+      original version of the Work and any modifications or additions
+      to that Work, that is intentionally submitted to the Licensor for
+      inclusion in the Work by the copyright owner or by an individual or
+      Legal Entity authorized to submit on behalf of the copyright owner.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      patent license to make, have made, use, offer to sell, sell, import,
+      and otherwise transfer the Work.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+   8. Limitation of Liability. In no event and under no legal theory shall
+      any Contributor be liable to You for damages.
+
+   9. Accepting Warranty or Additional Liability.
+
+   Copyright 2026 Molecule Dev, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/AudioRecorder.d.ts

@@ -0,0 +1,27 @@
+import type { ReactElement } from 'react';
+import type { AudioRecorderProps } from './types.js';
+/**
+ * Mic-permission + MediaRecorder UI primitive — emits a `Blob` once the user
+ * finishes recording. Pure browser API; no upload, no transcription. Wire to
+ * any backend by listening to `onRecorded` and POST-ing the blob.
+ *
+ * Renders a status badge, an elapsed-time readout, and three buttons:
+ * Record (idle/processed) → Pause/Resume + Stop (recording/paused).
+ * All button labels and status text flow through `t()` with English
+ * `defaultValue` fallbacks; drop in a companion locale bond to translate.
+ *
+ * Styling is delegated to `getClassMap()` — no Tailwind / raw class names.
+ *
+ * @param props - Component props.
+ * @returns The rendered recorder element.
+ *
+ * @example
+ * ```tsx
+ * <AudioRecorder
+ *   maxDurationSeconds={120}
+ *   onRecorded={({ blob, mimeType }) => uploadVoiceNote(blob, mimeType)}
+ * />
+ * ```
+ */
+export declare function AudioRecorder({ onRecorded, onError, mimeType, maxDurationSeconds, dataMolId, className, }: AudioRecorderProps): ReactElement;
+//# sourceMappingURL=AudioRecorder.d.ts.map

package/dist/AudioRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioRecorder.d.ts","sourceRoot":"","sources":["../src/AudioRecorder.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,OAAO,CAAA;AAMxD,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,YAAY,CAAA;AA0BxE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAAC,EAC5B,UAAU,EACV,OAAO,EACP,QAAQ,EACR,kBAAsB,EACtB,SAAS,EACT,SAAS,GACV,EAAE,kBAAkB,GAAG,YAAY,CA4TnC"}

package/dist/AudioRecorder.js

@@ -0,0 +1,263 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTranslation } from '@molecule/app-react';
+import { getClassMap } from '@molecule/app-ui';
+/**
+ * Format a duration (seconds) as `m:ss`.
+ *
+ * @param seconds - Duration to format.
+ * @returns A short `m:ss` string.
+ */
+function formatDuration(seconds) {
+    const m = Math.floor(seconds / 60);
+    const s = Math.floor(seconds % 60);
+    return `${m}:${String(s).padStart(2, '0')}`;
+}
+/**
+ * Resolve the MediaRecorder constructor at call time so jsdom + tests can
+ * stub `globalThis.MediaRecorder` without leaking through static imports.
+ *
+ * @returns The runtime MediaRecorder constructor or `undefined` when the
+ *   browser environment lacks support.
+ */
+function getMediaRecorder() {
+    if (typeof globalThis === 'undefined')
+        return undefined;
+    return globalThis.MediaRecorder;
+}
+/**
+ * Mic-permission + MediaRecorder UI primitive — emits a `Blob` once the user
+ * finishes recording. Pure browser API; no upload, no transcription. Wire to
+ * any backend by listening to `onRecorded` and POST-ing the blob.
+ *
+ * Renders a status badge, an elapsed-time readout, and three buttons:
+ * Record (idle/processed) → Pause/Resume + Stop (recording/paused).
+ * All button labels and status text flow through `t()` with English
+ * `defaultValue` fallbacks; drop in a companion locale bond to translate.
+ *
+ * Styling is delegated to `getClassMap()` — no Tailwind / raw class names.
+ *
+ * @param props - Component props.
+ * @returns The rendered recorder element.
+ *
+ * @example
+ * ```tsx
+ * <AudioRecorder
+ *   maxDurationSeconds={120}
+ *   onRecorded={({ blob, mimeType }) => uploadVoiceNote(blob, mimeType)}
+ * />
+ * ```
+ */
+export function AudioRecorder({ onRecorded, onError, mimeType, maxDurationSeconds = 0, dataMolId, className, }) {
+    const cm = getClassMap();
+    const { t } = useTranslation();
+    const [state, setState] = useState('idle');
+    const [elapsed, setElapsed] = useState(0);
+    const [errorMessage, setErrorMessage] = useState(null);
+    const recorderRef = useRef(null);
+    const streamRef = useRef(null);
+    const chunksRef = useRef([]);
+    const tickRef = useRef(null);
+    const startedAtRef = useRef(0);
+    const pausedAccumRef = useRef(0);
+    const pausedAtRef = useRef(null);
+    // Cleanup on unmount.
+    useEffect(() => {
+        return () => {
+            if (tickRef.current)
+                clearInterval(tickRef.current);
+            streamRef.current?.getTracks().forEach((tr) => tr.stop());
+            if (recorderRef.current && recorderRef.current.state !== 'inactive') {
+                try {
+                    recorderRef.current.stop();
+                }
+                catch (_error) {
+                    // Best-effort cleanup on unmount; recorder may already be inactive or torn down.
+                }
+            }
+        };
+    }, []);
+    const stopTick = useCallback(() => {
+        if (tickRef.current) {
+            clearInterval(tickRef.current);
+            tickRef.current = null;
+        }
+    }, []);
+    const startTick = useCallback(() => {
+        stopTick();
+        tickRef.current = setInterval(() => {
+            const now = Date.now();
+            const totalPaused = pausedAccumRef.current + (pausedAtRef.current ? now - pausedAtRef.current : 0);
+            const sec = Math.floor((now - startedAtRef.current - totalPaused) / 1000);
+            setElapsed(sec);
+            if (maxDurationSeconds > 0 && sec >= maxDurationSeconds) {
+                // Auto-stop.
+                try {
+                    recorderRef.current?.stop();
+                }
+                catch (_error) {
+                    // Best-effort auto-stop at max duration; recorder may have already stopped or been torn down.
+                }
+            }
+        }, 250);
+    }, [maxDurationSeconds, stopTick]);
+    const handleStart = useCallback(async () => {
+        setErrorMessage(null);
+        chunksRef.current = [];
+        pausedAccumRef.current = 0;
+        pausedAtRef.current = null;
+        const Ctor = getMediaRecorder();
+        if (!Ctor) {
+            const err = new Error('MediaRecorder is not supported in this environment');
+            setErrorMessage(t('audioRecorder.unsupported', {}, { defaultValue: 'Audio recording is not supported in this browser' }));
+            setState('error');
+            onError?.(err);
+            return;
+        }
+        try {
+            const md = globalThis.navigator?.mediaDevices;
+            if (!md?.getUserMedia) {
+                throw new Error('Microphone access (getUserMedia) is not available');
+            }
+            const stream = await md.getUserMedia({ audio: true });
+            streamRef.current = stream;
+            const opts = mimeType ? { mimeType } : undefined;
+            const rec = new Ctor(stream, opts);
+            recorderRef.current = rec;
+            rec.addEventListener('dataavailable', (e) => {
+                if (e.data && e.data.size > 0)
+                    chunksRef.current.push(e.data);
+            });
+            rec.addEventListener('stop', () => {
+                stopTick();
+                const finalMime = rec.mimeType || mimeType || 'audio/webm';
+                const blob = new Blob(chunksRef.current, { type: finalMime });
+                const dur = elapsedFromRefs(startedAtRef, pausedAccumRef, pausedAtRef);
+                // Tear down stream tracks so the OS mic indicator turns off.
+                streamRef.current?.getTracks().forEach((tr) => tr.stop());
+                streamRef.current = null;
+                recorderRef.current = null;
+                setState('processed');
+                onRecorded({ blob, mimeType: finalMime, durationSeconds: dur });
+            });
+            rec.addEventListener('error', () => {
+                const err = new Error('Recording failed');
+                setErrorMessage(t('audioRecorder.error', {}, { defaultValue: 'Recording failed. Please try again.' }));
+                setState('error');
+                stopTick();
+                onError?.(err);
+            });
+            startedAtRef.current = Date.now();
+            setElapsed(0);
+            rec.start();
+            startTick();
+            setState('recording');
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error('Microphone permission denied');
+            setErrorMessage(t('audioRecorder.permissionDenied', {}, { defaultValue: 'Microphone permission denied. Allow access and try again.' }));
+            setState('error');
+            onError?.(e);
+        }
+    }, [mimeType, onError, onRecorded, startTick, stopTick, t]);
+    const handlePause = useCallback(() => {
+        const rec = recorderRef.current;
+        if (!rec || rec.state !== 'recording')
+            return;
+        try {
+            rec.pause();
+            pausedAtRef.current = Date.now();
+            setState('paused');
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error('Pause failed'));
+        }
+    }, [onError]);
+    const handleResume = useCallback(() => {
+        const rec = recorderRef.current;
+        if (!rec || rec.state !== 'paused')
+            return;
+        try {
+            rec.resume();
+            if (pausedAtRef.current) {
+                pausedAccumRef.current += Date.now() - pausedAtRef.current;
+                pausedAtRef.current = null;
+            }
+            setState('recording');
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error('Resume failed'));
+        }
+    }, [onError]);
+    const handleStop = useCallback(() => {
+        const rec = recorderRef.current;
+        if (!rec)
+            return;
+        if (rec.state === 'inactive')
+            return;
+        try {
+            rec.stop();
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error('Stop failed'));
+        }
+    }, [onError]);
+    const recordLabel = t('audioRecorder.record', {}, { defaultValue: 'Record' });
+    const pauseLabel = t('audioRecorder.pause', {}, { defaultValue: 'Pause' });
+    const resumeLabel = t('audioRecorder.resume', {}, { defaultValue: 'Resume' });
+    const stopLabel = t('audioRecorder.stop', {}, { defaultValue: 'Stop' });
+    const elapsedLabel = t('audioRecorder.elapsed', { time: formatDuration(elapsed) }, { defaultValue: 'Elapsed {{time}}' });
+    const stateLabel = state === 'recording'
+        ? t('audioRecorder.statusRecording', {}, { defaultValue: 'Recording' })
+        : state === 'paused'
+            ? t('audioRecorder.statusPaused', {}, { defaultValue: 'Paused' })
+            : state === 'processed'
+                ? t('audioRecorder.statusProcessed', {}, { defaultValue: 'Recorded' })
+                : state === 'error'
+                    ? t('audioRecorder.statusError', {}, { defaultValue: 'Error' })
+                    : t('audioRecorder.statusIdle', {}, { defaultValue: 'Ready to record' });
+    // Inline styles only for things ClassMap can't express: the live red
+    // dot, the bare button reset, and the disabled cursor.
+    const dotStyle = {
+        display: 'inline-block',
+        width: 10,
+        height: 10,
+        borderRadius: '50%',
+        background: state === 'recording'
+            ? 'var(--mol-color-error, #e11)'
+            : 'var(--mol-color-on-surface-variant, #888)',
+        marginRight: 8,
+        verticalAlign: 'middle',
+        animation: state === 'recording' ? 'mol-pulse 1.2s ease-in-out infinite' : undefined,
+    };
+    const buttonBase = {
+        background: 'none',
+        border: '1px solid currentColor',
+        padding: '0.4rem 0.9rem',
+        borderRadius: 6,
+        cursor: 'pointer',
+        color: 'inherit',
+        fontSize: 'inherit',
+        lineHeight: 1.2,
+    };
+    const showRecord = state === 'idle' || state === 'processed' || state === 'error';
+    const showPause = state === 'recording';
+    const showResume = state === 'paused';
+    const showStop = state === 'recording' || state === 'paused';
+    const wrapperClass = cm.cn(cm.flex({ direction: 'col', gap: 'xs' }), className);
+    return (_jsxs("div", { className: wrapperClass, "data-mol-id": dataMolId ?? 'audio-recorder', "data-state": state, role: "group", "aria-label": t('audioRecorder.group', {}, { defaultValue: 'Audio recorder' }), children: [_jsxs("div", { className: cm.flex({ align: 'center', gap: 'sm' }), children: [_jsx("span", { "aria-hidden": true, style: dotStyle }), _jsx("span", { className: cm.cn(cm.textSize('sm'), cm.fontWeight('semibold')), "data-mol-id": "audio-recorder-status", "aria-live": "polite", children: stateLabel }), _jsx("span", { className: cm.textSize('sm'), "data-mol-id": "audio-recorder-elapsed", "aria-label": elapsedLabel, children: formatDuration(elapsed) })] }), _jsxs("div", { className: cm.flex({ align: 'center', gap: 'sm' }), children: [showRecord && (_jsx("button", { type: "button", onClick: handleStart, "aria-label": recordLabel, "data-action": "record", style: buttonBase, children: recordLabel })), showPause && (_jsx("button", { type: "button", onClick: handlePause, "aria-label": pauseLabel, "data-action": "pause", style: buttonBase, children: pauseLabel })), showResume && (_jsx("button", { type: "button", onClick: handleResume, "aria-label": resumeLabel, "data-action": "resume", style: buttonBase, children: resumeLabel })), showStop && (_jsx("button", { type: "button", onClick: handleStop, "aria-label": stopLabel, "data-action": "stop", style: buttonBase, children: stopLabel }))] }), errorMessage && (_jsx("div", { className: cm.textSize('sm'), role: "alert", "data-mol-id": "audio-recorder-error", style: { color: 'var(--mol-color-error, #e11)' }, children: errorMessage }))] }));
+}
+/**
+ * Compute final recording duration from refs at stop time.
+ *
+ * @param startedAtRef - Ref holding the recording start timestamp.
+ * @param pausedAccumRef - Ref holding accumulated paused milliseconds.
+ * @param pausedAtRef - Ref holding the current pause start (or null).
+ * @returns Duration in whole seconds.
+ */
+function elapsedFromRefs(startedAtRef, pausedAccumRef, pausedAtRef) {
+    const now = Date.now();
+    const pausedNow = pausedAtRef.current ? now - pausedAtRef.current : 0;
+    const totalPaused = pausedAccumRef.current + pausedNow;
+    return Math.max(0, Math.floor((now - startedAtRef.current - totalPaused) / 1000));
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Mic-permission + MediaRecorder UI primitive — emits a `Blob` once the
+ * user finishes recording. Pure browser API; no upload, no transcription.
+ *
+ * Used by AI-voice-assistant, AI-meeting-notes (manual capture), and
+ * AI-customer-service-bot. Wire to any backend by handling `onRecorded`.
+ *
+ * @example
+ * ```tsx
+ * import { AudioRecorder } from '@molecule/app-audio-recorder-react'
+ *
+ * <AudioRecorder
+ *   maxDurationSeconds={300}
+ *   onRecorded={({ blob, mimeType, durationSeconds }) => {
+ *     console.log(`Captured ${durationSeconds}s of ${mimeType}`)
+ *     uploadVoiceNote(blob)
+ *   }}
+ * />
+ * ```
+ *
+ * @remarks
+ * `getUserMedia` only exists in a secure context — the recorder works on
+ * `https://` and `localhost`, and permanently shows the error state on
+ * plain HTTP. The requested `mimeType` is best-effort: unsupported types
+ * silently fall back to the browser default (the actual type is reported
+ * in `onRecorded`). Reaching `maxDurationSeconds` auto-stops and still
+ * fires `onRecorded`. The recording dot's pulse uses a `mol-pulse` CSS
+ * animation shipped in the molecule base stylesheet
+ * (`@molecule/app-ui-tailwind`'s `base.css`, loaded by every molecule app),
+ * so the dot animates out of the box; a host that does not load that
+ * stylesheet can define `@keyframes mol-pulse { 50% { opacity: .4 } }`
+ * itself (without it the dot is static but recording still works).
+ * Translations come from the companion
+ * `@molecule/app-locales-audio-recorder` locale bond.
+ *
+ * @module
+ */
+export * from './AudioRecorder.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,cAAc,oBAAoB,CAAA;AAClC,cAAc,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,39 @@
+/**
+ * Mic-permission + MediaRecorder UI primitive — emits a `Blob` once the
+ * user finishes recording. Pure browser API; no upload, no transcription.
+ *
+ * Used by AI-voice-assistant, AI-meeting-notes (manual capture), and
+ * AI-customer-service-bot. Wire to any backend by handling `onRecorded`.
+ *
+ * @example
+ * ```tsx
+ * import { AudioRecorder } from '@molecule/app-audio-recorder-react'
+ *
+ * <AudioRecorder
+ *   maxDurationSeconds={300}
+ *   onRecorded={({ blob, mimeType, durationSeconds }) => {
+ *     console.log(`Captured ${durationSeconds}s of ${mimeType}`)
+ *     uploadVoiceNote(blob)
+ *   }}
+ * />
+ * ```
+ *
+ * @remarks
+ * `getUserMedia` only exists in a secure context — the recorder works on
+ * `https://` and `localhost`, and permanently shows the error state on
+ * plain HTTP. The requested `mimeType` is best-effort: unsupported types
+ * silently fall back to the browser default (the actual type is reported
+ * in `onRecorded`). Reaching `maxDurationSeconds` auto-stops and still
+ * fires `onRecorded`. The recording dot's pulse uses a `mol-pulse` CSS
+ * animation shipped in the molecule base stylesheet
+ * (`@molecule/app-ui-tailwind`'s `base.css`, loaded by every molecule app),
+ * so the dot animates out of the box; a host that does not load that
+ * stylesheet can define `@keyframes mol-pulse { 50% { opacity: .4 } }`
+ * itself (without it the dot is static but recording still works).
+ * Translations come from the companion
+ * `@molecule/app-locales-audio-recorder` locale bond.
+ *
+ * @module
+ */
+export * from './AudioRecorder.js';
+export * from './types.js';

package/dist/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Public types for `<AudioRecorder>`.
+ *
+ * @module
+ */
+/** Recorder lifecycle states. */
+export type AudioRecorderState = 'idle' | 'recording' | 'paused' | 'processed' | 'error';
+/** Result emitted via `onRecorded` once a recording finishes. */
+export interface AudioRecording {
+    /** The captured audio as a `Blob`. */
+    blob: Blob;
+    /** Audio MIME type (e.g. `'audio/webm'`). */
+    mimeType: string;
+    /** Recording duration in seconds (whole-second precision). */
+    durationSeconds: number;
+}
+/** Props for {@link AudioRecorder}. */
+export interface AudioRecorderProps {
+    /**
+     * Called once the user stops recording and a Blob is ready. Parents are
+     * responsible for uploading or persisting the blob.
+     */
+    onRecorded: (rec: AudioRecording) => void;
+    /**
+     * Called whenever a recording error occurs (permission denied, no
+     * MediaRecorder support, hardware failure). Optional — the component
+     * surfaces a translated error message regardless.
+     */
+    onError?: (err: Error) => void;
+    /**
+     * Optional MIME type to request from MediaRecorder. Falls back to the
+     * browser's default if unsupported. Common values: `'audio/webm'`,
+     * `'audio/mp4'`, `'audio/ogg;codecs=opus'`.
+     */
+    mimeType?: string;
+    /**
+     * Maximum recording duration (seconds). When reached, recording stops
+     * automatically and `onRecorded` fires. `0` (default) means unlimited.
+     */
+    maxDurationSeconds?: number;
+    /** `data-mol-id` attribute for AI-agent selectors. */
+    dataMolId?: string;
+    /** Extra classes appended via the ClassMap `cn()` helper. */
+    className?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,iCAAiC;AACjC,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAA;AAExF,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,IAAI,EAAE,IAAI,CAAA;IACV,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,eAAe,EAAE,MAAM,CAAA;CACxB;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,UAAU,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;IACzC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB"}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Public types for `<AudioRecorder>`.
+ *
+ * @module
+ */
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@molecule/app-audio-recorder-react",
+  "version": "1.0.0",
+  "description": "Mic permission + MediaRecorder wrapper that emits a Blob — voice notes, meeting capture, AI voice agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "molecule",
+    "audio-recorder",
+    "mediarecorder",
+    "voice",
+    "react"
+  ],
+  "license": "Apache-2.0",
+  "peerDependencies": {
+    "@molecule/app-i18n": "^1.0.0",
+    "@molecule/app-react": "^1.0.0",
+    "@molecule/app-ui": "^1.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@molecule/app-i18n": "1.0.0",
+    "@molecule/app-react": "1.0.0",
+    "@molecule/app-ui": "1.0.0",
+    "@molecule/app-ui-tailwind": "1.0.0",
+    "@testing-library/dom": "10.4.1",
+    "@testing-library/react": "16.3.2",
+    "@types/node": "26.1.2",
+    "@types/react": "19.2.17",
+    "@types/react-dom": "19.2.3",
+    "jsdom": "30.0.1",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  }
+}