tempest-react-sdk 0.38.2 → 0.39.0

package/README.md

@@ -279,7 +279,7 @@ Every module is re-exported from the package root — `import { Button, useDebou
 | `push`                                                                                            | `WebPushClient`, `WebPushUnsupportedError`, `WebPushPermissionDeniedError`, `usePushSubscription`, `urlBase64ToUint8Array`, `isPushSupported`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `sw` _(also subpath `tempest-react-sdk/sw`)_                                                      | `registerServiceWorker` (opt-in `autoUpdate` poll + reload, no `vite-plugin-pwa`), `skipWaiting`, `unregisterAllServiceWorkers`, `installPushHandler`, `installNotificationClickHandler`, `installSkipWaitingListener`, `installPrecache` (app-shell offline + Navigation Preload), `installRuntimeCache` (per-route caching, incl. `rangeRequests`), `createPartialResponse` (206 range slicing), `installBackgroundSync` (offline mutation queue + `periodicsync`), `registerPeriodicSync` (main-thread periodic sync), `inspectCaches`/`clearCaches` (cache observability) — the React-free `tempest-react-sdk/sw` subpath is ideal for bundling into your own `sw.ts`                                                                                                                                                                                                                      |
 | `editor` _(subpath `tempest-react-sdk/editor`, opt. peers `@tiptap/react`+`@tiptap/starter-kit`)_ | `RichTextEditor` — themed tiptap v3 rich-text editor with toolbar (tiptap externalized; install it only if you use the editor)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `vision` _(subpath `tempest-react-sdk/vision`, opt. peer `onnxruntime-web`)_                      | `Classifier`, `Detector`, `Segmenter` + results/labels/preprocess — on-device ONNX vision inference, vendored from `@mauriciobenjamin700/ort-vision-sdk-web` (onnxruntime-web externalized; install it only if you use vision). Plus browser capture primitives: `useCameraStream` (rear-camera `getUserMedia` + classified errors + `retry()`), `computeImageLuminance`/`isLuminanceAcceptable`/`LowLuminanceError`/`LUMINANCE_SAMPLE_MAX_EDGE` (BT.709 brightness), `useLiveLuminance` (live rAF sampling)                                                                                                                                                                                                                                                                                                                                                                                   |
+| `vision` _(subpath `tempest-react-sdk/vision`, opt. peer `onnxruntime-web`)_                      | `Classifier`, `Detector`, `Segmenter`, `DetectClassify` (fused detect→classify pipeline) + `warmup()`, `raiseOnEmpty`/`NoDetectionsError`, `LetterboxPipeline`, `readFusionSpec` and results/labels/preprocess — on-device ONNX vision inference, vendored from `@mauriciobenjamin700/ort-vision-sdk-web` (onnxruntime-web externalized; install it only if you use vision). Plus browser capture primitives: `useCameraStream` (rear-camera `getUserMedia` + classified errors + `retry()`), `computeImageLuminance`/`isLuminanceAcceptable`/`LowLuminanceError`/`LUMINANCE_SAMPLE_MAX_EDGE` (BT.709 brightness), `useLiveLuminance` (live rAF sampling)                                                                                                                                                                                                                                      |
 | `tabular` _(subpath `tempest-react-sdk/tabular`, opt. peer `onnxruntime-web`)_                    | `TabularPredictor`, `useTabularPredictor` — scikit-learn models exported by `tempest-fastapi-sdk`'s `export_sklearn_to_onnx`, running in the browser with no inference server. Offline by design: `fetchModelBytes`/`isModelCached`/`cacheModelBytes`/`clearModelCache` (Cache Storage, cache-first) plus `configureOrtAssets`/`ortAssetUrls`/`ORT_WASM_ASSETS` for the runtime's WebAssembly binaries, which ONNX Runtime Web fetches at session creation. Import the default `onnxruntime-web` entry — the WebGPU build has no `ai.onnx.ml` kernels                                                                                                                                                                                                                                                                                                                                          |
 | `imaging` _(subpath `tempest-react-sdk/imaging`, no deps)_                                        | `resizeImage`, `cropImage`, `rotateImage`, `flipImage`, `compressToTarget` (binary-searches quality into a byte budget), `createThumbnails` (several sizes from one decode), `decodeImage`/`readImageInfo`, `encodeImage`, `supportsImageType`/`bestSupportedType`, plus `useImagePreview`/`useImageProcessing`. Canvas only — decodes with EXIF orientation applied (phone photos arrive upright), reports the format actually produced (asking for AVIF where there is no encoder silently returns PNG), and re-encoding drops EXIF, which is the privacy step as much as the bandwidth one                                                                                                                                                                                                                                                                                                  |
 | `audio`                                                                                           | `createAudioPlayer`, `playAudio`, `stopAudio`, `useAudio`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |

package/bin/lib/design/collect.mjs

@@ -37,6 +37,25 @@ export function isExcluded(path) {
     );
 }
 
+/** How far into a file the generated banner is looked for. */
+const BANNER_BYTES = 800;
+
+/**
+ * True when the file says, in its own head, that it is not hand-written.
+ *
+ * A generated or vendored file is upstream's shape, not this project's: the fix
+ * for a 300-line function in it is a change in the generator or in the package it
+ * was copied from, and any edit made here is undone by the next regeneration.
+ * Reporting it teaches the reader to skim the report, which is how a linter dies.
+ *
+ * @param {string} source - File contents.
+ * @returns {boolean}
+ */
+export function declaresGenerated(source) {
+    const head = source.slice(0, BANNER_BYTES);
+    return /@generated\b/.test(head) || /\bDo not hand-edit\b/i.test(head);
+}
+
 /**
  * Collect the project's own source files.
  *

package/bin/lib/design/functions.mjs

@@ -174,6 +174,11 @@ export function findPropsTypes(masked) {
     const re = /\b(?:interface|type)\s+([A-Za-z_$][\w$]*Props)\b([^{;]*)/g;
     let match;
     while ((match = re.exec(masked))) {
+        // The body has to be this declaration's own. `type OverriddenDomProps =
+        // "children" | "onSubmit";` ends at the semicolon, and searching forward for a
+        // brace found the *next* interface — so a two-member string union was reported
+        // with the member count of whatever came after it.
+        if (!/^\s*\{/.test(masked.slice(match.index + match[0].length))) continue;
         const open = masked.indexOf("{", match.index + match[0].length - 1);
         if (open === -1) continue;
         const close = matchPair(masked, open, "{", "}");

package/bin/lib/design/index.mjs

@@ -5,7 +5,7 @@
 import { readFileSync } from "node:fs";
 import { relative } from "node:path";
 
-import { collectSources } from "./collect.mjs";
+import { collectSources, declaresGenerated } from "./collect.mjs";
 import { countBySeverity, LIMITS, sortFindings } from "./findings.mjs";
 import { scanFile } from "./scan.mjs";
 
@@ -42,6 +42,7 @@ export function analyzeDesign({ root, targets, limits = {}, maxFiles } = {}) {
     const findings = [];
     const waivers = [];
     const lineCounts = [];
+    const skipped = [...collected.skipped];
     let largest = null;
     let codeLines = 0;
 
@@ -53,6 +54,10 @@ export function analyzeDesign({ root, targets, limits = {}, maxFiles } = {}) {
         } catch {
             continue;
         }
+        if (declaresGenerated(source)) {
+            skipped.push({ path, reason: "declares itself generated or vendored" });
+            continue;
+        }
         const result = scanFile({ file, source, limits });
         findings.push(...result.findings);
         waivers.push(...result.waivers.map((w) => ({ file, ...w })));
@@ -69,12 +74,12 @@ export function analyzeDesign({ root, targets, limits = {}, maxFiles } = {}) {
         waivers,
         counts: countBySeverity(sorted),
         stats: {
-            files: collected.files.length,
+            files: collected.files.length - (skipped.length - collected.skipped.length),
             codeLines,
             medianLines: median(lineCounts),
             largest,
         },
-        skipped: collected.skipped.map((s) => ({ file: relative(root, s.path), reason: s.reason })),
+        skipped: skipped.map((s) => ({ file: relative(root, s.path), reason: s.reason })),
         truncated: collected.truncated,
     };
 }

package/bin/lib/design/index.test.mjs

@@ -21,6 +21,37 @@ afterEach(() => {
     rmSync(root, { recursive: true, force: true });
 });
 
+describe("analyzeDesign — generated and vendored code", () => {
+    it("skips a file that declares itself generated", () => {
+        write(
+            "src/vendored/detector.ts",
+            [
+                "/** @generated Vendored from upstream. Do not hand-edit. */",
+                "export function detect() {",
+                ...Array.from({ length: 300 }, (_, i) => `  const v${i} = ${i};`),
+                "  return 1;",
+                "}",
+            ].join("\n"),
+        );
+        const result = analyzeDesign({ root });
+        expect(result.findings).toHaveLength(0);
+        expect(result.skipped.map((s) => s.file)).toContain("src/vendored/detector.ts");
+    });
+
+    it("still judges the same file once the banner is gone", () => {
+        write(
+            "src/owned/detector.ts",
+            [
+                "export function detect() {",
+                ...Array.from({ length: 300 }, (_, i) => `  const v${i} = ${i};`),
+                "  return 1;",
+                "}",
+            ].join("\n"),
+        );
+        expect(analyzeDesign({ root }).findings.length).toBeGreaterThan(0);
+    });
+});
+
 describe("analyzeDesign", () => {
     it("reports nothing for a well-shaped project", () => {
         write(

package/bin/lib/design/scan.mjs

@@ -36,6 +36,30 @@ function isTypePosition(masked, index) {
     return /[:<|&(,[]\s*$|\bas\s+$/.test(before);
 }
 
+/**
+ * True when the file only re-exports: a barrel.
+ *
+ * The file-lines limit measures how much a reader has to hold in their head before
+ * changing a line, and a barrel asks for none of that — a 350-line index of
+ * `export { X } from "./x"` is a directory listing, and the advice to "extract a
+ * sub-component" is meaningless there. Judging it also punishes exactly the layout
+ * this SDK asks projects to use: one re-export per public symbol.
+ *
+ * @param {string} masked - Source with comments and string bodies blanked.
+ * @returns {boolean}
+ */
+function isBarrel(masked) {
+    const lines = masked
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0) return false;
+    const reexport = lines.filter((line) =>
+        /^(export|import)\b|^[\w$,{}*\s]+$|^} from |^};?$|^from /.test(line),
+    ).length;
+    return reexport / lines.length >= 0.95;
+}
+
 /**
  * Analyze one already-read source file.
  *
@@ -70,7 +94,7 @@ export function scanFile({ file, source, limits = {} }) {
     }
 
     const codeLines = countCodeLines(masked);
-    if (!isTest) {
+    if (!isTest && !isBarrel(masked)) {
         const fileMax = isTsx ? max.componentFileLines : max.moduleFileLines;
         if (codeLines > fileMax) {
             push(
@@ -114,7 +138,15 @@ export function scanFile({ file, source, limits = {} }) {
                     `${fn.name} takes ${fn.params.length} parameters (limit ${max.params}) — pass one named object`,
                 );
             }
-            if (fn.kind === "component" && fn.destructuredProps > max.props) {
+            // The destructuring is only news when it disagrees with the type: a
+            // component that spreads its own `<Name>Props` reports the same excess
+            // twice, and two lines for one fact reads as two problems.
+            const declared = propsTypes.get(`${fn.name}Props`)?.count;
+            if (
+                fn.kind === "component" &&
+                fn.destructuredProps > max.props &&
+                fn.destructuredProps !== declared
+            ) {
                 push(
                     "props-count",
                     fn.line,

package/bin/lib/design/scan.test.mjs

@@ -12,6 +12,84 @@ const bigComponent = (lines) =>
         "}",
     ].join("\n");
 
+describe("scanFile — what is not a props type", () => {
+    it("does not read a string union named *Props as a props type", () => {
+        const source = [
+            'type OverriddenDomProps = "children" | "onSubmit";',
+            "",
+            "export interface CardProps {",
+            ...Array.from({ length: 12 }, (_, i) => `  prop${i}?: string;`),
+            "}",
+            "",
+            "export function Card(props: CardProps) {",
+            "  return props;",
+            "}",
+        ].join("\n");
+        const result = scanFile({ file: "src/Card.tsx", source });
+        const propsFindings = result.findings.filter((f) => f.code === "props-count");
+        expect(propsFindings).toHaveLength(1);
+        expect(propsFindings[0].message).toContain("CardProps");
+        expect(propsFindings[0].message).not.toContain("OverriddenDomProps");
+    });
+
+    it("reports the type once, not again for the destructuring that mirrors it", () => {
+        const props = Array.from({ length: 9 }, (_, i) => `prop${i}`);
+        const source = [
+            "export interface PanelProps {",
+            ...props.map((p) => `  ${p}?: string;`),
+            "}",
+            "",
+            `export function Panel({ ${props.join(", ")} }: PanelProps) {`,
+            `  return ${props[0]};`,
+            "}",
+        ].join("\n");
+        const propsFindings = scanFile({ file: "src/Panel.tsx", source }).findings.filter(
+            (f) => f.code === "props-count",
+        );
+        expect(propsFindings).toHaveLength(1);
+        expect(propsFindings[0].message).toContain("PanelProps has 9 props");
+    });
+
+    it("still reports a destructuring that goes past its own type", () => {
+        const source = [
+            "export interface WideProps {",
+            "  a?: string;",
+            "}",
+            "",
+            "export function Wide({ a, b, c, d, e, f, g, h, i }: WideProps & Extra) {",
+            "  return a;",
+            "}",
+        ].join("\n");
+        const messages = scanFile({ file: "src/Wide.tsx", source })
+            .findings.filter((f) => f.code === "props-count")
+            .map((f) => f.message);
+        expect(messages.some((m) => m.includes("destructures 9 props"))).toBe(true);
+    });
+});
+
+describe("scanFile — barrels", () => {
+    it("does not size-check a file that only re-exports", () => {
+        const source = Array.from(
+            { length: 260 },
+            (_, i) => `export { Thing${i}, type Thing${i}Props } from "./thing-${i}";`,
+        ).join("\n");
+        expect(codes(scanFile({ file: "src/components/index.ts", source }))).not.toContain(
+            "file-lines",
+        );
+    });
+
+    it("still size-checks a file that re-exports and also holds logic", () => {
+        const source = [
+            ...Array.from({ length: 200 }, (_, i) => `export { T${i} } from "./t-${i}";`),
+            "export function helper() {",
+            ...Array.from({ length: 40 }, (_, i) => `  const v${i} = ${i};`),
+            "  return 1;",
+            "}",
+        ].join("\n");
+        expect(codes(scanFile({ file: "src/mixed.ts", source }))).toContain("file-lines");
+    });
+});
+
 describe("scanFile — size", () => {
     it("reports a .tsx over the component limit", () => {
         const result = scanFile({ file: "src/Big.tsx", source: bigComponent(200) });

package/bin/lib/doctor/doctor.e2e.test.mjs

@@ -277,6 +277,65 @@ describe("tempest doctor — a project that does use the SDK", () => {
         expect(doctor().out).not.toContain("Adopting the SDK (optional)");
     });
 
+    it("does not count a styles.css mentioned in a docstring as a second import", () => {
+        write("src/main.tsx", 'import "tempest-react-sdk/styles.css";\nexport const main = 1;');
+        write(
+            "src/theme.ts",
+            '/**\n * Theming notes.\n *\n * The app imports "tempest-react-sdk/styles.css" once, in the entry.\n */\nexport const theme = 1;',
+        );
+        const { out } = doctor();
+        expect(out).not.toContain("styles.css imported");
+    });
+
+    it("still catches a styles.css imported twice for real", () => {
+        write("src/main.tsx", 'import "tempest-react-sdk/styles.css";\nexport const main = 1;');
+        write("src/late.ts", 'import "tempest-react-sdk/styles.css";\nexport const late = 1;');
+        expect(doctor().out).toContain("styles.css imported 2×");
+    });
+
+    it("keeps quiet about an optional peer the project never uses", () => {
+        write("package.json", {
+            name: "sdk-lib",
+            type: "module",
+            dependencies: { "tempest-react-sdk": "^0.26.1" },
+            peerDependencies: { react: "^19.0.0", leaflet: ">=1.9.0" },
+            peerDependenciesMeta: { leaflet: { optional: true } },
+        });
+        const { out } = doctor();
+        expect(out).not.toContain("peerDependency(ies) unmet");
+    });
+
+    it("still reports a required peer that is not installed", () => {
+        write("package.json", {
+            name: "sdk-lib",
+            type: "module",
+            dependencies: { "tempest-react-sdk": "^0.26.1" },
+            peerDependencies: { react: "^19.0.0", leaflet: ">=1.9.0" },
+        });
+        const { out } = doctor();
+        expect(out).toContain("peerDependency(ies) unmet");
+        expect(out).toContain("leaflet");
+    });
+
+    it("does not demand an optional peer a test only renders to prove it degrades", () => {
+        write(
+            "src/TileMap.test.tsx",
+            'import { TrajectoryMap } from "tempest-react-sdk";\n' +
+                'export const t = <TrajectoryMap points={[]} tileUrl="https://t/{z}/{x}/{y}.png" />;',
+        );
+        const { out } = doctor();
+        expect(out).not.toContain("leaflet missing");
+    });
+
+    it("still demands the optional peer when production code uses it", () => {
+        write(
+            "src/TileMap.tsx",
+            'import { TrajectoryMap } from "tempest-react-sdk";\n' +
+                'export const T = () => <TrajectoryMap points={[]} tileUrl="https://t/{z}/{x}/{y}.png" />;',
+        );
+        expect(doctor().out).toContain("leaflet missing");
+    });
+
     it("warns when the SDK is installed but undeclared", () => {
         write("package.json", {
             name: "sdk-app",
@@ -289,6 +348,32 @@ describe("tempest doctor — a project that does use the SDK", () => {
     });
 });
 
+describe("tempest doctor — the summary count", () => {
+    beforeEach(thirdPartyApp);
+
+    it("counts design findings the list had to cap", () => {
+        for (let i = 0; i < 12; i += 1) {
+            write(
+                `src/Comp${i}.tsx`,
+                [
+                    `export function Comp${i}() {`,
+                    ...Array.from({ length: 210 }, (_, j) => `  const v${j} = ${j};`),
+                    "  return null;",
+                    "}",
+                ].join("\n"),
+            );
+        }
+        const { out } = doctor();
+        const hidden = /(\d+) more design finding\(s\) not shown/.exec(out);
+        const summary = /! (\d+) warning\(s\)/.exec(out);
+        expect(hidden).not.toBeNull();
+        expect(summary).not.toBeNull();
+        // The summary has to be at least the findings that were hidden plus the ones
+        // printed; before this it counted only the printed rows.
+        expect(Number(summary[1])).toBeGreaterThan(Number(hidden[1]));
+    });
+});
+
 describe("tempest doctor — design analysis", () => {
     beforeEach(thirdPartyApp);
 

package/bin/tempest.mjs

@@ -111,9 +111,65 @@ function nestedDupe(name) {
     return existsSync(join(ROOT, "node_modules", "tempest-react-sdk", "node_modules", name));
 }
 
+/**
+ * Drop comment bodies, keeping string contents and line count intact.
+ *
+ * Every usage check below asks "does this project do X?" of raw source text, and
+ * a JSDoc `@example` showing X is not the project doing X — a docstring telling
+ * you to `import "tempest-react-sdk/styles.css"`, or one rendering a
+ * `<TrajectoryMap tileUrl=…>`, used to be read as a second import and as a
+ * leaflet dependency. Strings survive because the checks match import paths,
+ * which live inside them; the design rules use `maskSource` instead, which blanks
+ * both.
+ *
+ * @param {string} source - Raw file contents.
+ * @returns {string} The same text with `//` and block comments blanked.
+ */
+function stripComments(source) {
+    let out = "";
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        const next = source[i + 1];
+        if (ch === "/" && next === "/") {
+            const end = source.indexOf("\n", i);
+            i = end === -1 ? source.length : end;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            const end = source.indexOf("*/", i + 2);
+            const stop = end === -1 ? source.length : end + 2;
+            out += source.slice(i, stop).replace(/[^\n]/g, " ");
+            i = stop;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            const quote = ch;
+            let j = i + 1;
+            while (j < source.length && source[j] !== quote) {
+                if (source[j] === "\\") j += 1;
+                if (source[j] === "\n" && quote !== "`") break;
+                j += 1;
+            }
+            out += source.slice(i, Math.min(j + 1, source.length));
+            i = j + 1;
+            continue;
+        }
+        out += ch;
+        i += 1;
+    }
+    return out;
+}
+
 /**
  * Recursively collect source text (bounded) to scan for import usage, and note
  * whether any test file exists. Returns `{ text, hasTests }`.
+ *
+ * The text comes back with comments stripped (see {@link stripComments}), since
+ * every caller is asking what the code does, not what its docs say. Test files
+ * are counted (`hasTests`) but kept out of it for the same reason: a test that
+ * renders a component precisely to assert how it degrades **without** an optional
+ * peer would otherwise be read as a project needing that peer installed.
  */
 function scanSources() {
     const roots = ["src", "app"].map((d) => join(ROOT, d)).filter(existsSync);
@@ -136,9 +192,12 @@ function scanSources() {
             if (e.isDirectory()) walk(full);
             else if (exts.has(e.name.slice(e.name.lastIndexOf(".")))) {
                 budget -= 1;
-                if (/\.(test|spec)\./.test(e.name)) hasTests = true;
+                if (/\.(test|spec)\./.test(e.name)) {
+                    hasTests = true;
+                    continue;
+                }
                 try {
-                    text += readFileSync(full, "utf8");
+                    text += stripComments(readFileSync(full, "utf8"));
                 } catch {
                     /* ignore */
                 }
@@ -372,6 +431,13 @@ function designChecks(limit = 6) {
             "the limits and the escape hatch are documented at /design/limits/",
         ]);
     }
+    // Carried to the summary so a capped list still reports its real size. Never
+    // printed: the reporter skips any row whose severity it does not know.
+    const hiddenWarns = Math.max(
+        0,
+        analysis.findings.filter((f) => f.severity === "warn").length - limit,
+    );
+    if (hiddenWarns > 0) rows.push(["hidden-warns", hiddenWarns]);
     if (analysis.findings.length === 0) {
         rows.push(["ok", "no design problems found"]);
     }
@@ -552,8 +618,14 @@ function doctor(args = []) {
         checks.push(["ok", "all declared dependencies installed"]);
     }
 
-    // App's own peerDependencies unmet.
-    const peerDeps = Object.keys(pkg.peerDependencies ?? {});
+    // App's own peerDependencies unmet. A peer flagged `optional` in
+    // peerDependenciesMeta is not missing when absent — that is the whole point of
+    // declaring it optional, and reporting it turns every published package into a
+    // permanent warning about peers its consumers were never meant to install.
+    const peerMeta = pkg.peerDependenciesMeta ?? {};
+    const peerDeps = Object.keys(pkg.peerDependencies ?? {}).filter(
+        (name) => peerMeta[name]?.optional !== true,
+    );
     const unmetPeers = peerDeps.filter((name) => !installedVersion(name));
     if (unmetPeers.length > 0) {
         checks.push([
@@ -728,7 +800,12 @@ function doctor(args = []) {
         }
     }
     // styles.css should be imported once — duplicates re-inject the whole sheet.
-    const stylesImports = (src.match(/tempest-react-sdk\/styles\.css/g) ?? []).length;
+    // Only an actual import statement counts: the path also shows up in prose (a
+    // JSDoc telling you to import it, a comment explaining what the sheet covers),
+    // and counting those reports a duplicate that does not exist.
+    const stylesImports = (
+        src.match(/(?:^|[\s;])import\s+["']tempest-react-sdk\/styles\.css["']/g) ?? []
+    ).length;
     if (stylesImports > 1) {
         checks.push([
             "warn",
@@ -846,6 +923,7 @@ function report(checks) {
             console.log(`\n${c.bold}${entry[1]}${c.reset}`);
             continue;
         }
+        if (entry[0] === "hidden-warns") continue;
         if (entry[0] === "info") {
             console.log(
                 `  [${c.cyan}i${c.reset}] ${entry[1]}${entry[2] ? ` ${c.dim}— ${entry[2]}${c.reset}` : ""}`,
@@ -855,7 +933,13 @@ function report(checks) {
         console.log(fmt(entry[0], entry[1], entry[2]));
     }
     const fails = checks.filter((x) => x[0] === "fail").length;
-    const warns = checks.filter((x) => x[0] === "warn").length;
+    // The design section prints at most `limit` findings per severity, so counting the
+    // printed rows under-reports it — a project with 245 design warnings used to close
+    // with "6 warning(s)", and a number that small is a number nobody acts on.
+    const hiddenWarns = checks
+        .filter((x) => x[0] === "hidden-warns")
+        .reduce((sum, x) => sum + x[1], 0);
+    const warns = checks.filter((x) => x[0] === "warn").length + hiddenWarns;
     console.log("");
     if (fails)
         console.log(

package/dist/audio/level-meter.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"level-meter.cjs","names":[],"sources":["../../src/audio/level-meter.ts"],"sourcesContent":["/** Options for {@link createLevelMeter}. */\nexport interface LevelMeterOptions {\n    /**\n     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable\n     * and short enough to react to a syllable.\n     */\n    fftSize?: number;\n    /**\n     * Extra smoothing on the way down, 0–1. Default `0.7`.\n     *\n     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left\n     * instant — a meter that lags the voice going *up* reads as \"not recording\" —\n     * while the decay is eased, which is how every hardware meter behaves.\n     */\n    decay?: number;\n}\n\n/** A running level meter. */\nexport interface LevelMeter {\n    /** Latest level, 0–1. Read it on your own frame loop. */\n    level: () => number;\n    /** Stop sampling and release the Web Audio graph. */\n    stop: () => void;\n}\n\n/**\n * Sample the loudness of a live stream, 0–1.\n *\n * This exists because a recorder with no visible level is indistinguishable from a\n * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong\n * device selected — all three produce a perfectly successful recording of silence,\n * and the user only finds out after they finish talking.\n *\n * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks\n * perceived loudness. It is deliberately **not** React state — updating state per\n * frame would re-render the tree 60 times a second. Poll `level()` from a\n * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing\n * animation.\n *\n * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number\n * of live contexts (Chrome allows around six), so a meter left running on unmount\n * eventually breaks every later one on the page.\n *\n * @param stream - A live audio stream.\n * @param options - See {@link LevelMeterOptions}.\n * @returns A `level()` reader and a `stop()`.\n *\n * @example\n * const meter = createLevelMeter(stream);\n * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };\n */\nexport function createLevelMeter(\n    stream: MediaStream,\n    { fftSize = 1024, decay = 0.7 }: LevelMeterOptions = {},\n): LevelMeter {\n    const Ctor: typeof AudioContext | undefined =\n        typeof AudioContext !== \"undefined\"\n            ? AudioContext\n            : (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n\n    if (!Ctor) {\n        return { level: () => 0, stop: () => undefined };\n    }\n\n    const context = new Ctor();\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = fftSize;\n    source.connect(analyser);\n\n    const samples = new Float32Array(analyser.fftSize);\n    let smoothed = 0;\n    let closed = false;\n\n    const read = (): number => {\n        if (closed) return 0;\n        analyser.getFloatTimeDomainData(samples);\n        let sum = 0;\n        for (let index = 0; index < samples.length; index += 1) {\n            sum += samples[index] * samples[index];\n        }\n        const rms = Math.sqrt(sum / samples.length);\n        // Instant attack, eased release.\n        smoothed = rms > smoothed ? rms : smoothed * decay + rms * (1 - decay);\n        return Math.min(1, smoothed);\n    };\n\n    return {\n        level: read,\n        stop: (): void => {\n            if (closed) return;\n            closed = true;\n            try {\n                source.disconnect();\n                analyser.disconnect();\n            } catch {\n                // Already torn down with the context — nothing to release.\n            }\n            void context.close().catch(() => undefined);\n        },\n    };\n}\n"],"mappings":"AAmDA,SAAgB,EACZ,EACA,CAAE,UAAU,KAAM,QAAQ,IAA2B,CAAC,EAC5C,CACV,IAAM,EACF,OAAO,aAAiB,IAClB,aACC,WAA4D,mBAEvE,GAAI,CAAC,EACD,MAAO,CAAE,UAAa,EAAG,SAAY,IAAA,EAAU,EAGnD,IAAM,EAAU,IAAI,EACd,EAAS,EAAQ,wBAAwB,CAAM,EAC/C,EAAW,EAAQ,eAAe,EACxC,EAAS,QAAU,EACnB,EAAO,QAAQ,CAAQ,EAEvB,IAAM,EAAU,IAAI,aAAa,EAAS,OAAO,EAC7C,EAAW,EACX,EAAS,GAeb,MAAO,CACH,UAduB,CACvB,GAAI,EAAQ,MAAO,GACnB,EAAS,uBAAuB,CAAO,EACvC,IAAI,EAAM,EACV,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,OAAQ,GAAS,EACjD,GAAO,EAAQ,GAAS,EAAQ,GAEpC,IAAM,EAAM,KAAK,KAAK,EAAM,EAAQ,MAAM,EAG1C,MADA,GAAW,EAAM,EAAW,EAAM,EAAW,EAAQ,GAAO,EAAI,GACzD,KAAK,IAAI,EAAG,CAAQ,CAC/B,EAII,SAAkB,CACV,MACJ,GAAS,GACT,GAAI,CACA,EAAO,WAAW,EAClB,EAAS,WAAW,CACxB,MAAQ,CAER,CACA,EAAa,MAAM,CAAC,CAAC,UAAY,IAAA,EAAS,CAPjC,CAQb,CACJ,CACJ"}
+{"version":3,"file":"level-meter.cjs","names":[],"sources":["../../src/audio/level-meter.ts"],"sourcesContent":["/** Options for {@link createLevelMeter}. */\nexport interface LevelMeterOptions {\n    /**\n     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable\n     * and short enough to react to a syllable.\n     */\n    fftSize?: number;\n    /**\n     * Extra smoothing on the way down, 0–1. Default `0.7`.\n     *\n     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left\n     * instant — a meter that lags the voice going *up* reads as \"not recording\" —\n     * while the decay is eased, which is how every hardware meter behaves.\n     */\n    decay?: number;\n}\n\n/** A running level meter. */\nexport interface LevelMeter {\n    /** Latest level, 0–1. Read it on your own frame loop. */\n    level: () => number;\n    /** Stop sampling and release the Web Audio graph. */\n    stop: () => void;\n}\n\n/**\n * Sample the loudness of a live stream, 0–1.\n *\n * This exists because a recorder with no visible level is indistinguishable from a\n * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong\n * device selected — all three produce a perfectly successful recording of silence,\n * and the user only finds out after they finish talking.\n *\n * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks\n * perceived loudness. It is deliberately **not** React state — updating state per\n * frame would re-render the tree 60 times a second. Poll `level()` from a\n * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing\n * animation.\n *\n * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number\n * of live contexts (Chrome allows around six), so a meter left running on unmount\n * eventually breaks every later one on the page.\n *\n * `level()` applies instant attack and eased release: a value above the current one\n * is taken as is, a lower one decays by `decay`. A meter that fell as fast as it rose\n * reads as noise instead of as loudness.\n *\n * @tempest-limits empty-catch — `stop()` disconnects nodes whose context may already\n * be closed (the tab was backgrounded, the stream's track ended, `stop()` raced an\n * unmount), and a disconnect on a dead graph throws. There is nothing to report and\n * nothing to retry: the resource this call would have released is already gone, and\n * the `context.close()` right after it is what actually matters.\n *\n * @param stream - A live audio stream.\n * @param options - See {@link LevelMeterOptions}.\n * @returns A `level()` reader and a `stop()`.\n *\n * @example\n * const meter = createLevelMeter(stream);\n * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };\n */\nexport function createLevelMeter(\n    stream: MediaStream,\n    { fftSize = 1024, decay = 0.7 }: LevelMeterOptions = {},\n): LevelMeter {\n    const Ctor: typeof AudioContext | undefined =\n        typeof AudioContext !== \"undefined\"\n            ? AudioContext\n            : (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n\n    if (!Ctor) {\n        return { level: () => 0, stop: () => undefined };\n    }\n\n    const context = new Ctor();\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = fftSize;\n    source.connect(analyser);\n\n    const samples = new Float32Array(analyser.fftSize);\n    let smoothed = 0;\n    let closed = false;\n\n    const read = (): number => {\n        if (closed) return 0;\n        analyser.getFloatTimeDomainData(samples);\n        let sum = 0;\n        for (let index = 0; index < samples.length; index += 1) {\n            sum += samples[index] * samples[index];\n        }\n        const rms = Math.sqrt(sum / samples.length);\n        smoothed = rms > smoothed ? rms : smoothed * decay + rms * (1 - decay);\n        return Math.min(1, smoothed);\n    };\n\n    return {\n        level: read,\n        stop: (): void => {\n            if (closed) return;\n            closed = true;\n            try {\n                source.disconnect();\n                analyser.disconnect();\n            } catch {\n                /* empty */\n            }\n            void context.close().catch(() => undefined);\n        },\n    };\n}\n"],"mappings":"AA6DA,SAAgB,EACZ,EACA,CAAE,UAAU,KAAM,QAAQ,IAA2B,CAAC,EAC5C,CACV,IAAM,EACF,OAAO,aAAiB,IAClB,aACC,WAA4D,mBAEvE,GAAI,CAAC,EACD,MAAO,CAAE,UAAa,EAAG,SAAY,IAAA,EAAU,EAGnD,IAAM,EAAU,IAAI,EACd,EAAS,EAAQ,wBAAwB,CAAM,EAC/C,EAAW,EAAQ,eAAe,EACxC,EAAS,QAAU,EACnB,EAAO,QAAQ,CAAQ,EAEvB,IAAM,EAAU,IAAI,aAAa,EAAS,OAAO,EAC7C,EAAW,EACX,EAAS,GAcb,MAAO,CACH,UAbuB,CACvB,GAAI,EAAQ,MAAO,GACnB,EAAS,uBAAuB,CAAO,EACvC,IAAI,EAAM,EACV,IAAK,IAAI,EAAQ,EAAG,EAAQ,EAAQ,OAAQ,GAAS,EACjD,GAAO,EAAQ,GAAS,EAAQ,GAEpC,IAAM,EAAM,KAAK,KAAK,EAAM,EAAQ,MAAM,EAE1C,MADA,GAAW,EAAM,EAAW,EAAM,EAAW,EAAQ,GAAO,EAAI,GACzD,KAAK,IAAI,EAAG,CAAQ,CAC/B,EAII,SAAkB,CACV,MACJ,GAAS,GACT,GAAI,CACA,EAAO,WAAW,EAClB,EAAS,WAAW,CACxB,MAAQ,CAER,CACA,EAAa,MAAM,CAAC,CAAC,UAAY,IAAA,EAAS,CAPjC,CAQb,CACJ,CACJ"}

package/dist/audio/level-meter.js.map

@@ -1 +1 @@
-{"version":3,"file":"level-meter.js","names":[],"sources":["../../src/audio/level-meter.ts"],"sourcesContent":["/** Options for {@link createLevelMeter}. */\nexport interface LevelMeterOptions {\n    /**\n     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable\n     * and short enough to react to a syllable.\n     */\n    fftSize?: number;\n    /**\n     * Extra smoothing on the way down, 0–1. Default `0.7`.\n     *\n     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left\n     * instant — a meter that lags the voice going *up* reads as \"not recording\" —\n     * while the decay is eased, which is how every hardware meter behaves.\n     */\n    decay?: number;\n}\n\n/** A running level meter. */\nexport interface LevelMeter {\n    /** Latest level, 0–1. Read it on your own frame loop. */\n    level: () => number;\n    /** Stop sampling and release the Web Audio graph. */\n    stop: () => void;\n}\n\n/**\n * Sample the loudness of a live stream, 0–1.\n *\n * This exists because a recorder with no visible level is indistinguishable from a\n * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong\n * device selected — all three produce a perfectly successful recording of silence,\n * and the user only finds out after they finish talking.\n *\n * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks\n * perceived loudness. It is deliberately **not** React state — updating state per\n * frame would re-render the tree 60 times a second. Poll `level()` from a\n * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing\n * animation.\n *\n * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number\n * of live contexts (Chrome allows around six), so a meter left running on unmount\n * eventually breaks every later one on the page.\n *\n * @param stream - A live audio stream.\n * @param options - See {@link LevelMeterOptions}.\n * @returns A `level()` reader and a `stop()`.\n *\n * @example\n * const meter = createLevelMeter(stream);\n * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };\n */\nexport function createLevelMeter(\n    stream: MediaStream,\n    { fftSize = 1024, decay = 0.7 }: LevelMeterOptions = {},\n): LevelMeter {\n    const Ctor: typeof AudioContext | undefined =\n        typeof AudioContext !== \"undefined\"\n            ? AudioContext\n            : (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n\n    if (!Ctor) {\n        return { level: () => 0, stop: () => undefined };\n    }\n\n    const context = new Ctor();\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = fftSize;\n    source.connect(analyser);\n\n    const samples = new Float32Array(analyser.fftSize);\n    let smoothed = 0;\n    let closed = false;\n\n    const read = (): number => {\n        if (closed) return 0;\n        analyser.getFloatTimeDomainData(samples);\n        let sum = 0;\n        for (let index = 0; index < samples.length; index += 1) {\n            sum += samples[index] * samples[index];\n        }\n        const rms = Math.sqrt(sum / samples.length);\n        // Instant attack, eased release.\n        smoothed = rms > smoothed ? rms : smoothed * decay + rms * (1 - decay);\n        return Math.min(1, smoothed);\n    };\n\n    return {\n        level: read,\n        stop: (): void => {\n            if (closed) return;\n            closed = true;\n            try {\n                source.disconnect();\n                analyser.disconnect();\n            } catch {\n                // Already torn down with the context — nothing to release.\n            }\n            void context.close().catch(() => undefined);\n        },\n    };\n}\n"],"mappings":";AAmDA,SAAgB,EACZ,GACA,EAAE,aAAU,MAAM,WAAQ,OAA2B,CAAC,GAC5C;CACV,IAAM,IACF,OAAO,eAAiB,MAClB,eACC,WAA4D;CAEvE,IAAI,CAAC,GACD,OAAO;EAAE,aAAa;EAAG,YAAY,KAAA;CAAU;CAGnD,IAAM,IAAU,IAAI,EAAK,GACnB,IAAS,EAAQ,wBAAwB,CAAM,GAC/C,IAAW,EAAQ,eAAe;CAExC,AADA,EAAS,UAAU,GACnB,EAAO,QAAQ,CAAQ;CAEvB,IAAM,IAAU,IAAI,aAAa,EAAS,OAAO,GAC7C,IAAW,GACX,IAAS;CAeb,OAAO;EACH,aAduB;GACvB,IAAI,GAAQ,OAAO;GACnB,EAAS,uBAAuB,CAAO;GACvC,IAAI,IAAM;GACV,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAQ,QAAQ,KAAS,GACjD,KAAO,EAAQ,KAAS,EAAQ;GAEpC,IAAM,IAAM,KAAK,KAAK,IAAM,EAAQ,MAAM;GAG1C,OADA,IAAW,IAAM,IAAW,IAAM,IAAW,IAAQ,KAAO,IAAI,IACzD,KAAK,IAAI,GAAG,CAAQ;EAC/B;EAII,YAAkB;GACV,QACJ;QAAS;IACT,IAAI;KAEA,AADA,EAAO,WAAW,GAClB,EAAS,WAAW;IACxB,QAAQ,CAER;IACA,EAAa,MAAM,CAAC,CAAC,YAAY,KAAA,CAAS;GAPjC;EAQb;CACJ;AACJ"}
+{"version":3,"file":"level-meter.js","names":[],"sources":["../../src/audio/level-meter.ts"],"sourcesContent":["/** Options for {@link createLevelMeter}. */\nexport interface LevelMeterOptions {\n    /**\n     * FFT window. 1024 is a good default: ~21 ms at 48 kHz, long enough to be stable\n     * and short enough to react to a syllable.\n     */\n    fftSize?: number;\n    /**\n     * Extra smoothing on the way down, 0–1. Default `0.7`.\n     *\n     * A raw RMS reading is jittery enough to make a meter look broken. Attack is left\n     * instant — a meter that lags the voice going *up* reads as \"not recording\" —\n     * while the decay is eased, which is how every hardware meter behaves.\n     */\n    decay?: number;\n}\n\n/** A running level meter. */\nexport interface LevelMeter {\n    /** Latest level, 0–1. Read it on your own frame loop. */\n    level: () => number;\n    /** Stop sampling and release the Web Audio graph. */\n    stop: () => void;\n}\n\n/**\n * Sample the loudness of a live stream, 0–1.\n *\n * This exists because a recorder with no visible level is indistinguishable from a\n * broken one. A muted OS input, a headset whose mic arm is switched off, the wrong\n * device selected — all three produce a perfectly successful recording of silence,\n * and the user only finds out after they finish talking.\n *\n * The value is RMS, not peak: peak reacts to a single sample and flickers, RMS tracks\n * perceived loudness. It is deliberately **not** React state — updating state per\n * frame would re-render the tree 60 times a second. Poll `level()` from a\n * `requestAnimationFrame` loop and write to the DOM, or read it inside an existing\n * animation.\n *\n * The `AudioContext` is created here and closed by `stop()`. Browsers cap the number\n * of live contexts (Chrome allows around six), so a meter left running on unmount\n * eventually breaks every later one on the page.\n *\n * `level()` applies instant attack and eased release: a value above the current one\n * is taken as is, a lower one decays by `decay`. A meter that fell as fast as it rose\n * reads as noise instead of as loudness.\n *\n * @tempest-limits empty-catch — `stop()` disconnects nodes whose context may already\n * be closed (the tab was backgrounded, the stream's track ended, `stop()` raced an\n * unmount), and a disconnect on a dead graph throws. There is nothing to report and\n * nothing to retry: the resource this call would have released is already gone, and\n * the `context.close()` right after it is what actually matters.\n *\n * @param stream - A live audio stream.\n * @param options - See {@link LevelMeterOptions}.\n * @returns A `level()` reader and a `stop()`.\n *\n * @example\n * const meter = createLevelMeter(stream);\n * const tick = () => { bar.style.transform = `scaleX(${meter.level()})`; raf = requestAnimationFrame(tick); };\n */\nexport function createLevelMeter(\n    stream: MediaStream,\n    { fftSize = 1024, decay = 0.7 }: LevelMeterOptions = {},\n): LevelMeter {\n    const Ctor: typeof AudioContext | undefined =\n        typeof AudioContext !== \"undefined\"\n            ? AudioContext\n            : (globalThis as { webkitAudioContext?: typeof AudioContext }).webkitAudioContext;\n\n    if (!Ctor) {\n        return { level: () => 0, stop: () => undefined };\n    }\n\n    const context = new Ctor();\n    const source = context.createMediaStreamSource(stream);\n    const analyser = context.createAnalyser();\n    analyser.fftSize = fftSize;\n    source.connect(analyser);\n\n    const samples = new Float32Array(analyser.fftSize);\n    let smoothed = 0;\n    let closed = false;\n\n    const read = (): number => {\n        if (closed) return 0;\n        analyser.getFloatTimeDomainData(samples);\n        let sum = 0;\n        for (let index = 0; index < samples.length; index += 1) {\n            sum += samples[index] * samples[index];\n        }\n        const rms = Math.sqrt(sum / samples.length);\n        smoothed = rms > smoothed ? rms : smoothed * decay + rms * (1 - decay);\n        return Math.min(1, smoothed);\n    };\n\n    return {\n        level: read,\n        stop: (): void => {\n            if (closed) return;\n            closed = true;\n            try {\n                source.disconnect();\n                analyser.disconnect();\n            } catch {\n                /* empty */\n            }\n            void context.close().catch(() => undefined);\n        },\n    };\n}\n"],"mappings":";AA6DA,SAAgB,EACZ,GACA,EAAE,aAAU,MAAM,WAAQ,OAA2B,CAAC,GAC5C;CACV,IAAM,IACF,OAAO,eAAiB,MAClB,eACC,WAA4D;CAEvE,IAAI,CAAC,GACD,OAAO;EAAE,aAAa;EAAG,YAAY,KAAA;CAAU;CAGnD,IAAM,IAAU,IAAI,EAAK,GACnB,IAAS,EAAQ,wBAAwB,CAAM,GAC/C,IAAW,EAAQ,eAAe;CAExC,AADA,EAAS,UAAU,GACnB,EAAO,QAAQ,CAAQ;CAEvB,IAAM,IAAU,IAAI,aAAa,EAAS,OAAO,GAC7C,IAAW,GACX,IAAS;CAcb,OAAO;EACH,aAbuB;GACvB,IAAI,GAAQ,OAAO;GACnB,EAAS,uBAAuB,CAAO;GACvC,IAAI,IAAM;GACV,KAAK,IAAI,IAAQ,GAAG,IAAQ,EAAQ,QAAQ,KAAS,GACjD,KAAO,EAAQ,KAAS,EAAQ;GAEpC,IAAM,IAAM,KAAK,KAAK,IAAM,EAAQ,MAAM;GAE1C,OADA,IAAW,IAAM,IAAW,IAAM,IAAW,IAAQ,KAAO,IAAI,IACzD,KAAK,IAAI,GAAG,CAAQ;EAC/B;EAII,YAAkB;GACV,QACJ;QAAS;IACT,IAAI;KAEA,AADA,EAAO,WAAW,GAClB,EAAS,WAAW;IACxB,QAAQ,CAER;IACA,EAAa,MAAM,CAAC,CAAC,YAAY,KAAA,CAAS;GAPjC;EAQb;CACJ;AACJ"}

package/dist/audio/use-audio-recorder.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"use-audio-recorder.cjs","names":[],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"use-audio-recorder.cjs","names":[],"sources":["../../src/audio/use-audio-recorder.ts"],"sourcesContent":["/**\n * @tempest-limits hook-lines — the hook is the recorder's lifecycle seen from React:\n * permission, the recorder handle, the clock, the level meter and the auto-stop\n * timer, all of which have to be torn down together on unmount. A second hook would\n * own half the teardown.\n */\nimport { useCallback, useEffect, useRef, useState } from \"react\";\n\nimport { useStableCallback } from \"@/hooks/use-stable-callback\";\n\nimport {\n    createAudioRecorder,\n    type AudioRecorderHandle,\n    type AudioRecorderOptions,\n    type AudioRecorderStatus,\n    type AudioRecording,\n} from \"./audio-recorder\";\nimport { createLevelMeter, type LevelMeter } from \"./level-meter\";\n\n/** Options for {@link useAudioRecorder}. */\nexport interface UseAudioRecorderOptions extends AudioRecorderOptions {\n    /**\n     * Stop automatically after this many milliseconds.\n     *\n     * Worth setting on anything user-facing: a recording left running by accident is\n     * a memory buffer that grows until the tab dies.\n     */\n    maxDurationMs?: number;\n    /** Called once the recording is assembled, whether by `stop()` or `maxDurationMs`. */\n    onRecorded?: (recording: AudioRecording) => void;\n    /** How often the clock and the level are published, in ms. Default 100. */\n    tickMs?: number;\n    /** Skip the level meter — it costs an `AudioContext`. Default `false`. */\n    disableLevelMeter?: boolean;\n}\n\n/** Value returned by {@link useAudioRecorder}. */\nexport interface UseAudioRecorderResult {\n    status: AudioRecorderStatus;\n    /** Recorded length so far, excluding paused time. */\n    durationMs: number;\n    /** Loudness 0–1, or `0` when the meter is off or nothing is recording. */\n    level: number;\n    /** The finished recording, or `null` before the first `stop()`. */\n    recording: AudioRecording | null;\n    /** Recorder-level error (encoder failure, device pulled mid-recording). */\n    error: unknown;\n    /** `false` when there is no stream yet, or the browser cannot record. */\n    ready: boolean;\n    start: () => void;\n    pause: () => void;\n    resume: () => void;\n    /** Stop and resolve with the recording. Also published on `recording`. */\n    stop: () => Promise<AudioRecording | null>;\n    /** Stop and throw the audio away. */\n    cancel: () => void;\n}\n\n/**\n * Record the given stream, with a clock, a level meter and a state machine.\n *\n * Pass the stream from {@link useMicrophone}; the hook stays `ready: false` until\n * there is one, so a page can render the whole recorder UI before permission is\n * granted and simply have it disabled.\n *\n * The clock and the level are published on an interval (`tickMs`, default 100 ms)\n * rather than per animation frame. A hook that set state 60 times a second would\n * re-render everything the recorder is inside; 10 Hz is smooth enough for a timer and\n * a meter, and the underlying `createLevelMeter` is still available for anyone who\n * wants a frame-accurate bar written straight to the DOM.\n *\n * @param stream - The stream to record, or `null` while permission is pending.\n * @param options - See {@link UseAudioRecorderOptions}.\n *\n * @example\n * const mic = useMicrophone();\n * const rec = useAudioRecorder(mic.stream, { maxDurationMs: 120_000 });\n * <button disabled={!rec.ready} onClick={rec.start}>Gravar</button>\n */\nexport function useAudioRecorder(\n    stream: MediaStream | null,\n    options: UseAudioRecorderOptions = {},\n): UseAudioRecorderResult {\n    const {\n        maxDurationMs,\n        onRecorded,\n        onChunk,\n        onError,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        tickMs = 100,\n        disableLevelMeter = false,\n    } = options;\n\n    const [status, setStatus] = useState<AudioRecorderStatus>(\"idle\");\n    const [durationMs, setDurationMs] = useState(0);\n    const [level, setLevel] = useState(0);\n    const [recording, setRecording] = useState<AudioRecording | null>(null);\n    const [error, setError] = useState<unknown>(null);\n    const [ready, setReady] = useState(false);\n\n    const recorderRef = useRef<AudioRecorderHandle | null>(null);\n    const meterRef = useRef<LevelMeter | null>(null);\n\n    const emitRecorded = useStableCallback((result: AudioRecording) => onRecorded?.(result));\n    const emitChunk = useStableCallback((chunk: Blob) => onChunk?.(chunk));\n    const emitError = useStableCallback((err: unknown) => {\n        setError(err);\n        onError?.(err);\n    });\n\n    /**\n     * Build the recorder and the meter for a stream, and tear both down when it\n     * changes.\n     *\n     * The recorder is rebuilt per stream because `MediaRecorder` is bound to the\n     * stream it was constructed with — swapping microphones mid-session hands us a\n     * new `MediaStream`, and reusing the old recorder would keep recording the device\n     * the user just switched away from. It is rebuilt on a container or bitrate change\n     * for the same reason: both are constructor arguments.\n     */\n    useEffect(() => {\n        if (!stream) {\n            setReady(false);\n            return;\n        }\n        let recorder: AudioRecorderHandle;\n        try {\n            recorder = createAudioRecorder(stream, {\n                mimeType,\n                audioBitsPerSecond,\n                timesliceMs,\n                onChunk: emitChunk,\n                onError: emitError,\n            });\n        } catch (err) {\n            setError(err);\n            setReady(false);\n            return;\n        }\n        recorderRef.current = recorder;\n        meterRef.current = disableLevelMeter ? null : createLevelMeter(stream);\n        setReady(true);\n        setStatus(\"idle\");\n\n        return () => {\n            if (recorder.status() === \"recording\" || recorder.status() === \"paused\") {\n                recorder.cancel();\n            }\n            meterRef.current?.stop();\n            meterRef.current = null;\n            recorderRef.current = null;\n            setReady(false);\n        };\n    }, [\n        stream,\n        disableLevelMeter,\n        mimeType,\n        audioBitsPerSecond,\n        timesliceMs,\n        emitChunk,\n        emitError,\n    ]);\n\n    const stop = useCallback(async (): Promise<AudioRecording | null> => {\n        const recorder = recorderRef.current;\n        if (!recorder) return null;\n        const current = recorder.status();\n        if (current !== \"recording\" && current !== \"paused\") return null;\n        const result = await recorder.stop();\n        setStatus(\"stopped\");\n        setDurationMs(result.durationMs);\n        setLevel(0);\n        setRecording(result);\n        emitRecorded(result);\n        return result;\n    }, [emitRecorded]);\n\n    /**\n     * Publish the clock and the level while something is running, and enforce\n     * `maxDurationMs`.\n     *\n     * The cap is checked on the same tick rather than with a `setTimeout` armed at\n     * `start()`, because a paused recording must not keep counting toward it — a\n     * timeout would fire while the user is paused mid-sentence.\n     */\n    useEffect(() => {\n        if (status !== \"recording\" && status !== \"paused\") {\n            setLevel(0);\n            return;\n        }\n        const id = setInterval(() => {\n            const recorder = recorderRef.current;\n            if (!recorder) return;\n            const elapsed = recorder.durationMs();\n            setDurationMs(elapsed);\n            setLevel(status === \"recording\" ? (meterRef.current?.level() ?? 0) : 0);\n            if (maxDurationMs !== undefined && elapsed >= maxDurationMs) void stop();\n        }, tickMs);\n        return () => clearInterval(id);\n    }, [status, tickMs, maxDurationMs, stop]);\n\n    const start = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        setRecording(null);\n        setError(null);\n        setDurationMs(0);\n        recorder.start();\n        setStatus(recorder.status());\n    }, []);\n\n    const pause = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.pause();\n        setDurationMs(recorder.durationMs());\n        setStatus(recorder.status());\n    }, []);\n\n    const resume = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.resume();\n        setStatus(recorder.status());\n    }, []);\n\n    const cancel = useCallback((): void => {\n        const recorder = recorderRef.current;\n        if (!recorder) return;\n        recorder.cancel();\n        setStatus(\"idle\");\n        setDurationMs(0);\n        setLevel(0);\n        setRecording(null);\n    }, []);\n\n    return {\n        status,\n        durationMs,\n        level,\n        recording,\n        error,\n        ready,\n        start,\n        pause,\n        resume,\n        stop,\n        cancel,\n    };\n}\n"],"mappings":"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"}