Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
fix(splat): record every frame of a camera-path video export and refuse to hand back an empty file
nirholascca237d7091d
diff --git a/data/changelog.json b/data/changelog.jsonindex d1c7823e6..81a129140 100644--- a/data/changelog.json+++ b/data/changelog.json@@ -1,6 +1,15 @@{"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security, desktop (desktop entries become the desktop app's release notes). `link` is optional and must be a live three.ws path.","entries": [+ {+ "date": "2026-10-23",+ "title": "Splat video export now records every frame of the camera path",+ "summary": "Exporting a camera path from the Splat Viewer could hand back an empty 0 MB video on slower machines, because the recorder sampled the WebGL canvas on a timer and sometimes never caught a finished frame. The export now pushes exactly one frame per rendered frame, keeps recording for two extra frames so the encoder flushes the end of the path, and says plainly when the scene rendered too slowly to encode anything instead of offering an empty download. Covered by new tests for the 25 saved camera view cap, the camera path sampler and the export flow.",+ "tags": [+ "fix"+ ],+ "link": "/splat"+ },{"date": "2026-10-23","title": "Revoking a connected app now stops it everywhere",diff --git a/prompts/finish/_context/best3d-PROGRESS.md b/prompts/finish/_context/best3d-PROGRESS.mdindex b55edece8..1bd2df205 100644--- a/prompts/finish/_context/best3d-PROGRESS.md+++ b/prompts/finish/_context/best3d-PROGRESS.md@@ -146,3 +146,6 @@ Append a dated entry per closed order, with commit SHAs.- No owner action needed: every lane either honors the new fields directly or reports its own limitation through the capability table; nothing in this order's work requires push, deploy, spend, or destroying data.- One judgment call: scoped batch submission to prompts only for v1 (not per-item image uploads), since the order's own wording ("submit up to N prompts or images") allows either, and prompt-only batching covers the dominant Workbench use case (generating variations from one description) without the added complexity of a multipart batch-upload contract; images can still be generated individually or added to the batch endpoint later without a breaking change.- Commits: `fa02fa82d` (schema: target_faces, bbox, pose, lane capability table), `9e8177875` (bbox GLB post-processing wiring, async LOD fix), `eb0c63223` (`/api/forge-batch` endpoint), `a39ae25c9` (Workbench UI: pose/bbox controls, Batch drawer, number-param rounding fix), `d98218c90` (docs + changelog), plus this entry and the order file deletion, which ship together.+- 2026-10-23: order 081 (splat parity) re-derived and PARTIALLY closed; the order file stays because only the live TripoSplat GPU step remains. Step 0 found Spark 2.3.1 with the LoD tree (`createLodSplats`, auto above 50k splats), the 25 camera hotspot cap, saved camera views, the camera timeline and in-browser video export already shipped (bd61fbd99, 3bd57493d, b72233fb8). Spark's `paged` option is deliberately not wired: it only streams `-lod-N` chunk files over HTTP and has no path for an in-memory buffer (documented in `src/splat-stage.js`). Gap found by driving the real Splat Viewer in Playwright with a real public .splat capture: video export returned an empty 110-byte WebM because the recorder sampled the canvas on a timer. Fixed (one `requestFrame` per rendered frame, two-frame tail flush, empty-output guard), with `tests/splat-hotspots.test.js` (11 tests: sampler, 25 cap, export flow). Re-run after the fix produced a 6.7 KB WebM that Chromium decodes (650x446). Caveat: the host was at load 60 to 120 on 32 cores with software GL, so only a 3000-splat prefix of the real capture was exported; the full 281k-splat file loaded and hotspots worked but rendered about 1 fps there.+ - Verified: `tests/splat-viewer-page.test.js`, `tests/splat-hotspots.test.js`, `tests/api/forge-splat.test.js` pass; `workers/model-triposplat/test_splat_prep.py` 6 passed; `workers/model-triposplat` README, STRUCTURE.md fleet row and changelog entry were already present (fulfils the triposplat README part of order 404); `check:rules` exit 0. `npm run build:pages` currently fails on another agent's changelog entry missing a tag, not this change.+ - Still open, owner: deploy the TripoSplat worker, set MODEL_TRIPOSPLAT_URL, run one real image through `/api/forge-splat` (row in production-100-OWNER-ACTIONS.md), then delete the order file.diff --git a/prompts/finish/_context/production-100-OWNER-ACTIONS.md b/prompts/finish/_context/production-100-OWNER-ACTIONS.mdindex e415e6675..a1ca792ff 100644--- a/prompts/finish/_context/production-100-OWNER-ACTIONS.md+++ b/prompts/finish/_context/production-100-OWNER-ACTIONS.md@@ -83,6 +83,7 @@ on it; some resolve themselves as other work lands.| 64 | **Create the mainnet native-launchpad curve config and pin it, activating the lane** (added 2026-10-14 by the evolve loop closing out order 512-integrate-13). `api/_lib/native-launch/config.js`'s curve now opens every pool at a 50% anti-snipe trading fee that decays exponentially to the steady-state 1% over the first 100 slots (Meteora DBC's own fee scheduler, verified by `tests/native-launch-curve.test.js`, a devnet e2e run against a local validator cloning the real DBC/Token-2022/ATA/Metaplex programs, and a zero-cost `--simulate` run against the live mainnet DBC program). Production currently has zero `NATIVE_LAUNCH_*` env vars set (`gcloud run services describe three-ws-api --region us-central1` env list checked), so this is first-time lane activation, not a change to a live config; no existing launch is affected. Exact command: `node scripts/native-launchpad-create-config.mjs --network mainnet`, needing `NATIVE_LAUNCH_PARTNER_SECRET_BASE58` (or `X402_TREASURY_SECRET_BASE58` as a fallback signer) funded with at least 0.05 SOL in that wallet (the script's own balance floor for rent + fees headroom); the on-chain spend itself is about 0.006 SOL (this order's own estimate for the `createConfig` transaction's rent and fee). Optionally set `NATIVE_LAUNCH_FEE_WALLET` first if the platform's fee claimer should be a wallet other than the signer. The script prints the created config pubkey and the exact env line to pin; run `gcloud run services update three-ws-api --region us-central1 --update-env-vars NATIVE_LAUNCH_CONFIG_KEY=<printed pubkey>` (config-only, pre-approved) to put the lane live. | one `node scripts/native-launchpad-create-config.mjs --network mainnet` run (~0.006 SOL) + one `gcloud run services update --update-env-vars` pin | Activates the native $THREE launchpad lane on mainnet with the decaying anti-snipe fee baked into the curve from the very first launch | [512-integrate-13-anti-snipe-native-lane.md](../512-integrate-13-anti-snipe-native-lane.md) || 65 | **Apply the payment-session policy-upgrades migration, then ship it with the next deploy** (added 2026-10-15 by the triage-lane deep sweep, order 518-integrate-19 close-out). `api/_lib/migrations/20261015100000_payment_session_policy_upgrades.sql` adds `approval_threshold_usdc`, `blocked_hosts` and `per_rail_daily_usdc` to `payment_sessions`, the signed-verdict columns (`policy_digest`, `verdict_code`, `verdict_signature`, `verdict_signed_at`) to `payment_session_executions`, and the new `payment_session_rail_reservations` table backing the rolling-window per-rail cap. `npm run db:status` lists it as one of the pending migrations today. Not yet an active production bug (the code half, `api/_lib/pay/spend-governor.js` and `api/pay/simulate.js`'s shared `policy.js`, is still only on `evolve`/this worktree, not deployed), but it must be applied in the same window as that code deploys: the governor's atomic enforcement and the simulator's parity check both read and write these columns unconditionally, so deploying the code first against the unmigrated table would 500 every payment-session create/execute call with Postgres `42703 undefined_column`. Apply with `node scripts/apply-migrations.mjs --apply --file 20261015100000_payment_session_policy_upgrades.sql` (or `npm run db:migrate`, which applies every pending migration immediately with no dry run) before or together with the deploy that ships `655b5a491`. Row 63 (above) covers the separate `PAY_VERDICT_HMAC_KEY` env var this same feature uses for signing; that row is independent of this migration and already works on a fallback secret. | one migration apply, timed with the deploy | Lets the new payment-session governance knobs (blocked hosts, approval threshold, per-rail daily caps) and tamper-evident signed verdicts go live without a schema mismatch | [docs/payment-sessions.md](../../docs/payment-sessions.md) || 66 | **DONE 2026-10-23, applied by the order 522 close-out.** **Apply the x402 outbound-receipts resolved-columns migration** (added 2026-10-15, order 522-integrate-23 close-out). `api/_lib/migrations/20261015110000_x402_outbound_resolved.sql` adds `resolved_payer`, `resolved_payee`, `resolved_mint`, `resolved_amount_atomics`, `resolved_decimals`, `resolved_fee_lamports`, `resolved_slot`, `resolved_block_time`, `resolved_at` and `resolve_error` to `payment_session_executions`, plus a partial index (`pse_user_settled_resolved`) for the settled-and-unresolved lookup. `npm run db:status` lists it as pending today. Not an active production bug yet: zero outbound-spend rows exist in `payment_session_executions` right now, so nothing has tried to resolve one. It becomes load-bearing the moment the new `GET /api/x402/outbound-receipts` endpoint (`api/x402/outbound-receipts.js`, `api/_lib/x402/outbound-receipts.js`) is deployed and a real agent spend lands: `resolveAndCacheRow()`'s UPDATE would fail with Postgres `42703 undefined_column` the first time anyone views that row. Apply with `node scripts/apply-migrations.mjs --apply --file 20261015110000_x402_outbound_resolved.sql` (or `npm run db:migrate`) before or together with the deploy that ships this feature. Independent of row 65's migration; both are currently pending in the same `npm run db:status` list and can be applied in the same pass. | one migration apply, timed with the deploy | Lets the Receipt Vault's new Outbound tab cache chain-verified settlement data instead of erroring the first time it resolves a real row | [docs/payment-sessions.md](../../docs/payment-sessions.md) |+| 67 | Deploy `workers/model-triposplat` (`gcloud builds submit --config workers/model-triposplat/cloudbuild.yaml`, stage weights with `stage-assets.sh`), set `MODEL_TRIPOSPLAT_URL` on `three-ws-api` with `--update-env-vars`, then run `POST /api/forge-splat` on a real photo and open the returned splat in `/splat`. Added 2026-10-23, order 081 close-out. | minutes | Image-to-splat Forge lane live (order 081 DoD line 2) | `workers/model-triposplat/README.md` |Deleted 2026-09-01: the former row 5 (`WALLET_ENCRYPTION_KEY_PREVIOUS` policy), whichdeclared itself "delete on reading" and had outlived that by three weeks.diff --git a/src/splat-hotspots.js b/src/splat-hotspots.jsindex a9f94545c..400adf169 100644--- a/src/splat-hotspots.js+++ b/src/splat-hotspots.js@@ -26,7 +26,7 @@ function smoothstep(u) {}// Sample the camera path at time `t`: clamp to the ends, ease each segment.-function sampleCamera(kfs, t) {+export function sampleCamera(kfs, t) {if (!kfs.length) return null;if (t <= kfs[0].time) return { position: kfs[0].position.clone(), target: kfs[0].target.clone() };const last = kfs[kfs.length - 1];@@ -50,6 +50,25 @@ function pickRecordingMimeType() {return null;}+const TAIL_FRAMES = 2;+const TAIL_TIMEOUT_MS = 1500;+// A real encoded clip is far larger than a container header; anything under this+// is a recorder that never received a frame.+const MIN_VIDEO_BYTES = 1024;++function flushTail(scene, track) {+ return new Promise((resolve) => {+ let left = TAIL_FRAMES;+ const finish = () => { clearTimeout(timer); resolve(); };+ const timer = setTimeout(finish, TAIL_TIMEOUT_MS);+ scene.setOnRendered(() => {+ track.requestFrame();+ left -= 1;+ if (left <= 0) finish();+ });+ });+}+function fmtTime(s) {return `${Math.max(0, s).toFixed(1)}s`;}@@ -262,18 +281,44 @@ export function initHotspotTimeline() {addBtn.disabled = true;setStatus('Recording camera path…');try {- const stream = scene.canvas.captureStream(EXPORT_FPS);+ // Frame rate 0 hands the encoder exactly the frames we push with+ // requestFrame() after each render. A fixed-rate capture samples the+ // WebGL canvas on a timer instead, and on a slow device it can finish a+ // whole recording without ever catching a finished frame.+ let stream = scene.canvas.captureStream(0);+ let track = stream.getVideoTracks()[0];+ const manual = typeof track?.requestFrame === 'function';+ if (!manual) {+ track?.stop();+ stream = scene.canvas.captureStream(EXPORT_FPS);+ track = stream.getVideoTracks()[0];+ }+ let framesCaptured = 0;+ if (manual) {+ scene.setOnRendered(() => { track.requestFrame(); framesCaptured += 1; });+ } else {+ framesCaptured = Infinity;+ }const recorder = new MediaRecorder(stream, { mimeType, videoBitsPerSecond: 8_000_000 });const chunks = [];recorder.ondataavailable = (e) => { if (e.data.size) chunks.push(e.data); };const stopped = new Promise((resolve) => { recorder.onstop = resolve; });- recorder.start();+ recorder.start(250);await new Promise((resolve) => {playback = { startWallMs: performance.now(), startTime: kfs[0].time, kfs, onDone: resolve };setPlayUI(true);});+ // Hold the recorder open for two more finished frames (or a short grace+ // period on a very slow device) so the encoder's look-ahead flushes the+ // last frames of the path instead of dropping them on stop().+ if (manual) await flushTail(scene, track);+ scene.setOnRendered(null);+ recorder.requestData();recorder.stop();await stopped;+ if (framesCaptured < 2 || chunks.reduce((n, c) => n + c.size, 0) < MIN_VIDEO_BYTES) {+ throw new Error('the browser encoded no video because the scene rendered too slowly while recording. Close other tabs or load a smaller scene and try again');+ }const blob = new Blob(chunks, { type: mimeType });const url = URL.createObjectURL(blob);setStatus('');@@ -286,6 +331,7 @@ export function initHotspotTimeline() {status.innerHTML = '';status.appendChild(a);} catch (err) {+ scene.setOnRendered?.(null);setStatus(`Recording failed: ${err.message}`, true);console.error('[splat] video export failed', err);} finally {diff --git a/src/splat-stage.js b/src/splat-stage.jsindex d52409705..4082d9eae 100644--- a/src/splat-stage.js+++ b/src/splat-stage.js@@ -256,12 +256,16 @@ export async function mountSplatScene(host, buffer, {// runs once per rendered frame, ahead of controls.update()/render, so camera// playback and the one render loop this stage owns never fall out of sync.let onFrame = null;+ // Runs right after each renderer.render(): the one moment the canvas holds a+ // finished frame, which is what a video recorder has to sample.+ let onRendered = null;const tick = () => {if (disposed) return;frame = requestAnimationFrame(tick);onFrame?.();controls.update();renderer.render(scene, camera);+ onRendered?.();};frame = requestAnimationFrame(tick);@@ -294,5 +298,9 @@ export async function mountSplatScene(host, buffer, {setOnFrame(fn) {onFrame = typeof fn === 'function' ? fn : null;},+ /** Install (or clear) a hook that runs after every rendered frame, for video capture. */+ setOnRendered(fn) {+ onRendered = typeof fn === 'function' ? fn : null;+ },};}diff --git a/tests/splat-hotspots.test.js b/tests/splat-hotspots.test.jsnew file mode 100644index 000000000..57a855168--- /dev/null+++ b/tests/splat-hotspots.test.js@@ -0,0 +1,205 @@+// @vitest-environment jsdom+//+// Camera hotspots, the camera timeline built from them, and in-browser video+// export for the Splat Viewer. The scene is a minimal host exposing the same+// surface mountSplatScene() returns (camera, controls, canvas, setOnFrame,+// setOnRendered); three.js vectors are real. The recorder is the only stub:+// jsdom has no MediaRecorder or canvas capture.++import { readFileSync } from 'node:fs';+import { resolve } from 'node:path';++import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { PerspectiveCamera, Vector3 } from 'three';++import { MAX_HOTSPOTS, initHotspotTimeline, sampleCamera } from '../src/splat-hotspots.js';++const PAGE = readFileSync(resolve(import.meta.dirname, '..', 'pages/splat.html'), 'utf8');+const CARD = PAGE.match(/<div class="sp-card sp-timeline-card"[\s\S]*?<div class="sp-note" id="sp-export-status"[^>]*><\/div>\s*<\/div>/)[0];++const kf = (time, x) => ({ time, position: new Vector3(x, 0, 5), target: new Vector3(x, 1, 0) });++function makeScene({ requestFrame = true } = {}) {+ let onFrame = null;+ let onRendered = null;+ const rendered = { frames: 0 };+ const track = requestFrame ? { requestFrame: vi.fn(), stop: vi.fn() } : { stop: vi.fn() };+ const canvas = {+ clientWidth: 400,+ clientHeight: 300,+ captureStream: vi.fn(() => ({ getVideoTracks: () => [track] })),+ };+ const camera = new PerspectiveCamera(50, 4 / 3, 0.1, 100);+ camera.position.set(0, 0, 5);+ camera.updateMatrixWorld(true);+ const scene = {+ canvas,+ camera,+ controls: { target: new Vector3(0, 0, 0), update() {} },+ setOnFrame: (fn) => { onFrame = fn; },+ setOnRendered: (fn) => { onRendered = fn; },+ };+ return {+ scene,+ track,+ /** Drive one render loop tick, the way splat-stage's rAF loop does. */+ tick() { onFrame?.(); rendered.frames += 1; onRendered?.(); },+ rendered,+ };+}++describe('sampleCamera', () => {+ it('clamps to the first and last keyframe outside the path', () => {+ const kfs = [kf(1, 0), kf(3, 10)];+ expect(sampleCamera(kfs, -5).position.x).toBe(0);+ expect(sampleCamera(kfs, 99).position.x).toBe(10);+ });++ it('eases between keyframes and hits the midpoint exactly at half time', () => {+ const kfs = [kf(0, 0), kf(4, 10)];+ expect(sampleCamera(kfs, 2).position.x).toBeCloseTo(5, 6);+ const early = sampleCamera(kfs, 1).position.x;+ expect(early).toBeGreaterThan(0);+ expect(early).toBeLessThan(2.5);+ });++ it('returns null for an empty path', () => {+ expect(sampleCamera([], 1)).toBeNull();+ });++ it('copies vectors so sampling never mutates a keyframe', () => {+ const kfs = [kf(0, 0), kf(2, 10)];+ sampleCamera(kfs, 1).position.x = 999;+ expect(kfs[0].position.x).toBe(0);+ expect(kfs[1].position.x).toBe(10);+ });+});++describe('hotspot timeline', () => {+ let api;+ beforeEach(() => {+ document.body.innerHTML = `<div id="sp-stage"></div>${CARD}`;+ api = initHotspotTimeline();+ });+ afterEach(() => { vi.unstubAllGlobals(); });++ it('is hidden until a scene mounts and export needs two views', () => {+ const card = document.querySelector('#sp-timeline-card');+ expect(card.hidden).toBe(true);+ const { scene } = makeScene();+ api.onSceneChanged(scene);+ expect(card.hidden).toBe(false);+ expect(document.querySelector('#sp-export-video').disabled).toBe(true);+ document.querySelector('#sp-hotspot-add').click();+ expect(document.querySelector('#sp-export-video').disabled).toBe(true);+ document.querySelector('#sp-hotspot-add').click();+ expect(document.querySelector('#sp-export-video').disabled).toBe(false);+ });++ it(`caps saved camera views at ${MAX_HOTSPOTS} and disables the add button`, () => {+ const { scene } = makeScene();+ api.onSceneChanged(scene);+ const add = document.querySelector('#sp-hotspot-add');+ for (let i = 0; i < MAX_HOTSPOTS + 5; i++) add.click();+ expect(document.querySelectorAll('#sp-hotspot-list li')).toHaveLength(MAX_HOTSPOTS);+ expect(add.disabled).toBe(true);+ expect(MAX_HOTSPOTS).toBe(25);+ });++ it('saves the live camera pose and spaces views along the timeline', () => {+ const { scene } = makeScene();+ api.onSceneChanged(scene);+ scene.camera.position.set(1, 2, 3);+ document.querySelector('#sp-hotspot-add').click();+ scene.camera.position.set(4, 5, 6);+ document.querySelector('#sp-hotspot-add').click();+ const times = [...document.querySelectorAll('.sp-hotspot-time')].map((i) => Number(i.value));+ expect(times).toEqual([0, 2.5]);+ expect(document.querySelector('#sp-timeline-time').textContent).toBe('0.0s / 2.5s');+ });++ it('clears every view when the scene is swapped', () => {+ const { scene } = makeScene();+ api.onSceneChanged(scene);+ document.querySelector('#sp-hotspot-add').click();+ api.onSceneChanged(makeScene().scene);+ expect(document.querySelectorAll('#sp-hotspot-list li')).toHaveLength(0);+ });++ describe('video export', () => {+ function stubRecorder() {+ class FakeRecorder {+ static isTypeSupported() { return true; }+ constructor(stream, opts) { this.stream = stream; this.opts = opts; }+ start() { this.started = true; }+ requestData() {}+ stop() {+ const track = this.stream.getVideoTracks()[0];+ const frames = track.requestFrame ? track.requestFrame.mock.calls.length : 5;+ if (frames > 0) this.ondataavailable?.({ data: new Blob([new Uint8Array(frames * 1000)]) });+ queueMicrotask(() => this.onstop?.());+ }+ }+ vi.stubGlobal('MediaRecorder', FakeRecorder);+ vi.stubGlobal('URL', Object.assign(URL, { createObjectURL: vi.fn(() => 'blob:fake') }));+ }++ async function runExport(host, fps = 60) {+ const timer = setInterval(() => host.tick(), 1000 / fps);+ try {+ document.querySelector('#sp-export-video').click();+ await vi.waitFor(() => {+ const s = document.querySelector('#sp-export-status');+ expect(s.hidden).toBe(false);+ expect(s.textContent).not.toMatch(/Recording camera path/);+ }, { timeout: 8000, interval: 50 });+ } finally { clearInterval(timer); }+ return document.querySelector('#sp-export-status');+ }++ function fastPath(host) {+ api.onSceneChanged(host.scene);+ const add = document.querySelector('#sp-hotspot-add');+ host.scene.camera.position.set(0, 0, 5); add.click();+ host.scene.camera.position.set(3, 0, 5); add.click();+ const times = document.querySelectorAll('.sp-hotspot-time');+ times[1].value = '0.4';+ times[1].dispatchEvent(new Event('change'));+ }++ it('plays the path, pushes one frame per render, and offers a download', async () => {+ stubRecorder();+ const host = makeScene();+ fastPath(host);+ const status = await runExport(host);+ const link = status.querySelector('a.sp-export-link');+ expect(link).not.toBeNull();+ expect(link.download).toBe('splat-camera-path.webm');+ expect(host.scene.canvas.captureStream).toHaveBeenCalledWith(0);+ expect(host.track.requestFrame.mock.calls.length).toBeGreaterThanOrEqual(2);+ const pushed = host.track.requestFrame.mock.calls.length;+ host.tick();+ expect(host.track.requestFrame.mock.calls.length).toBe(pushed);+ expect(host.scene.camera.position.x).toBeCloseTo(3, 5);+ });++ it('falls back to a fixed-rate capture when requestFrame is unavailable', async () => {+ stubRecorder();+ const host = makeScene({ requestFrame: false });+ fastPath(host);+ const status = await runExport(host);+ expect(host.scene.canvas.captureStream).toHaveBeenLastCalledWith(30);+ expect(status.querySelector('a.sp-export-link')).not.toBeNull();+ });++ it('says so instead of offering an empty file when too few frames render', async () => {+ stubRecorder();+ const host = makeScene();+ fastPath(host);+ const status = await runExport(host, 1.5);+ expect(status.querySelector('a.sp-export-link')).toBeNull();+ expect(status.textContent).toMatch(/Recording failed/);+ expect(status.classList.contains('sp-note--error')).toBe(true);+ });+ });+});