Changelog — Everframe SDK & service releases

This release contains no SDK changes, so you don’t need to upgrade the SDK. The service now discards common browser noise before storing it, groups errors that arrive without a stack trace by their message, and reads more stack formats. The improvements cover events from SDK versions you have already shipped. The dashboard also gains better controls for dismissing quick captures and a permanent link to the docs.

Service and dashboard

Less noise in your error list

• Browser noise is no longer stored. These web events are now dropped before they create an event or error group:
  • ResizeObserver loop warnings.
  • “Object Not Found Matching Id” errors, which come from link scanners calling into the page.
  • Errors where every located frame is inside a browser extension.
• Some errors are always kept. Reports filed by a person are never filtered. Errors with at least one frame in your own code are kept, including frames in the error’s cause chain. Existing groups of this noise stay as they are.

Better grouping

• Errors without a stack are grouped by message. Previously, every stackless error of the same type ended up in one group, under the first message seen. A new error could then hide inside an old group, even a resolved or ignored one.
  • Errors caught by your app or its runtime are now grouped by their type plus the first line of their message.
  • URLs, IDs and numbers are ignored, so errors that differ only by an ID still share a group.
  • App exits reported by the operating system keep their existing grouping.
• Your own react.esm.js is no longer mistaken for React.
  • If your app or a library you build ships a file named like react.esm.js, react.cjs.js or react.mjs, its frames now count as your code.
  • They appear under “Your code”, are used for grouping, and get function names.
  • React’s own builds, hashed chunks, CDN URLs and anything inside a react package folder are still treated as framework code.

More stack formats

• Safari and Firefox component stacks are read. React component stacks from Safari and Firefox are now recognised and source-mapped, just like Chrome’s. They no longer appear in the error header as a block of minified names and bundle URLs.
  • Events received before this release fold correctly but keep the lines as they were sent.
  • New events get mapped lines.
• iOS native stack rows without a load address are read. The stack card now reads iOS stack rows sent without a load address, including image names that contain spaces. Rows with an address read as before.

Quick captures

• Hide (✕) hides everything the dock is showing, not just the top card.
  • The choice is remembered across tabs and reloads, and applies live to your other open tabs.
  • Hidden captures stay available in the composer’s Recent captures picker.
  • A newer capture brings the dock back.
• Discard (trash) removes a capture for everyone who can see it, with Undo.
  • It is available on the dock’s card, on each row under “N more”, and on picker thumbnails when you hover or focus them. On touch devices it is always visible.
  • Discarding a shared team capture removes it for every member.
  • Discarded captures are erased after the usual 14-day grace period.

Navigation

• A Docs link is pinned to the bottom of the sidebar on every signed-in page, in both the desktop sidebar and the mobile drawer. It opens the documentation in a new tab.

For developers

• Filtered ingest responses. Ingest can now answer 200 with {"status": "filtered", "reason": "..."} for the browser noise described above. Nothing is stored for these events.
  • Every Everframe SDK already treats any 2xx response as delivered and won’t retry.
  • If you send events with your own client, treat any 2xx as success, and don’t assume a stored event exists for every accepted request.
• Stackless groups are re-keyed. New occurrences of existing stackless error groups get the new message-based key. They open new groups, and the old groups stop growing. Group titles are unchanged.
• Groups split by the React file-name mix-up will merge. The service re-checks web events that are still waiting for processing. Existing groups that were split this way should merge on their first app frame. New events now include function names, so one additional group may form, once.

Version 1.6.6 publishes @everframe/web, @everframe/react and @everframe/identity, and makes errors much easier to read in the dashboard. Minified React production errors now show what actually went wrong instead of a bare error code. DOM errors such as removeChild / insertBefore “not a child of this node” now come with an explanation of the likely cause. The integration Setup tab has been redesigned, and a new Set up with AI button hands the whole setup to a coding agent.

Service and dashboard

Readable React errors

• Minified React production errors are now titled by their meaning. For example, “Minified React error #185; visit …” becomes “Maximum update depth exceeded: a component keeps updating state in a loop (minified React error #185)”.
  • This covers the codes apps most often hit, in both the React 18 and React 19 message formats. Unknown codes keep React’s original message.
  • The readable wording appears in the errors list, the error page title, the stack trace card, the timeline’s crash row, and activity entries that name another error.
  • Under the title, a short “Minified React error #N.” line links to the full message on react.dev.
  • The Raw stack view and copied output keep React’s exact text.
• Existing error groups pick up the readable title on their next occurrence. Grouping is unaffected, so no groups split or merge.

DOM node errors

• For Chrome’s “is not a child of this node” errors from removeChild / insertBefore, and Safari’s “The object can not be found here.” NotFoundError, the error page now explains the problem. It says a node the app expected was no longer in the page and lists the usual causes: browser translation, extensions, or other code editing the page.
• When the occurrence recorded that the browser had translated the page, the hint says so, and This event shows a “Page: Translated by the browser” row.
• Other failures of these calls get no hint.

AI triage

• The triage prompt now includes the source-mapped stack (up to 20 frames) when symbolication has finished. Previously triage only saw raw minified frames.
• The prompt also explains known React error codes and notes when the page had been translated.

MCP search

• search no longer returns empty error groups left behind after web grouping moves events to their final group. One issue now appears once, matching the dashboard’s Errors list.

Setup tab

• A keys card now sits at the top of the Setup tab:

  • The SDK key is partly hidden, with a Show toggle and a Copy key button.
  • The App ID has its own copy button and is labelled as being for symbol uploads, not the SDK key.
  • A link goes to the SDK keys tab.

• Set up with AI opens a ready-to-paste prompt for any coding agent. It includes:

  • your key and App ID
  • install docs and every guide step with its snippets
  • rules for the agent, including keeping API tokens out of code and using the Everframe MCP server to confirm the first report.

  Toggles let you leave out optional steps or the key. The prompt is built from the same guide as the manual steps, so it is available for every SDK. See https://everframe.dev/docs/mcp/.

• Guide steps are tagged as recommended or optional. Required steps start expanded and the rest start collapsed.

• Try on device shows a single line when an SDK has no runnable targets.

• The Web integration now links to the React docs, since its guide installs @everframe/react.

• On React Native, the web step has moved to the end and is now the optional “Also shipping to web? (Expo web / React Native Web)”. It now covers what actually differs on the web:

  • keep the same imports
  • the browser entry uses the React reporter, with DOM screenshots and replay
  • the host needs React DOM
  • @everframe/react-native/web is the fallback when your bundler doesn’t select the browser export.

• The Flutter and Kotlin Multiplatform web steps are renamed to match: “Also shipping to web? (Flutter web)” and “(Kotlin/JS)”.

For developers

• The web and React setup guides add a recommended step, Report from your own error boundaries:

  captureException(error, { componentStack: info.componentStack });

  Passing componentStack gives the error page more context when every stack frame is inside React DOM. The web, React and React Native crash docs now document the componentStack option and the page-translation flag.

Everframe 1.6.5 publishes the web packages (@everframe/web, @everframe/react, @everframe/identity) and the build tools (@everframe/cli, @everframe/metro, @everframe/bundler-plugin, @everframe/expo). It contains no user-visible changes since 1.6.3: no SDK behaviour, configuration, or service changes. You can upgrade at your convenience, and no migration is needed.

This release republishes the tooling packages (@everframe/cli, @everframe/metro, @everframe/bundler-plugin, and @everframe/expo) at version 1.6.4. It contains no user-visible changes since v1.6.2, and no integration changes or migration steps are needed.

This release republishes the web SDK packages (@everframe/web, @everframe/react, and @everframe/identity) at version 1.6.3. No pull requests were merged since v1.6.2, so this release contains no functional changes to the SDKs, the hosted service, or the dashboard. You don’t need to change any code or configuration to upgrade.

This release adds features to the hosted service and dashboard only. No SDK packages change. You can now share reports and tickets through read-only links, add comments and status notes to errors, and see releases grouped across platforms. Release health alerts now also fire when a single platform falls below target. If you consume release health webhooks, read the payload change under For developers.

Service and dashboard

Read-only share links for reports and tickets

You can share a filed report or a saved ticket with someone who has no Everframe account. Use the Share control on the item to copy, switch off, switch on, or regenerate its link. Links take the form https://everframe.dev/s#<key>. Regenerating appears in the Share popover as “Make a new link.”

• What recipients see. They get a read-only view of the item as it is now, laid out like the signed-in report and ticket pages.
  • A shared report includes the reporter’s description, app, platform, device, version, severity, and the AI summary. It also includes screenshots, replay, page snapshots, and the Trail, Network, Console, Context, Files and Data tabs.
  • A shared ticket shows its description, files, linked reports, status, priority, assignee, dates, AI knowledge, and history.
• What is never included. Team comments, comment attachments, conversations, and agent transcripts are left out.
• Existing controls still apply. Deleting an item, moving it between apps, retention, and evidence settings all still apply to shared views.
• Media links expire. Media links in a shared view last at most five minutes.
• Replays keep their state. When a replay’s media link renews, playback keeps its position, play/pause state, and speed.
• Older links still work. Copying the link of an existing share returns the short form without changing its secret.
• Dead links explain themselves. When a link no longer works, the page says why and suggests asking the sender for the current link.

Comments and status notes on errors

Error pages now have a Comments & activity feed.

• Status notes. Resolving, snoozing, ignoring, reopening, resuming or restoring an error opens a small confirm popover where you can say why. The note is optional. This works from the error page and from the errors list, including bulk selection.
  • Leave the box empty to perform the plain action. Press ⌘/Ctrl+Enter to confirm.
  • The error’s header shows the current status note. You can add a note to your own status changes later from the feed.
  • Automatic changes, such as reopening on a new event or a regression, can’t take a note.
• Comments. Anyone on the project can post comments with markdown formatting.
  • You can edit and delete your own comments. Org admins can delete anyone’s.
  • A deleted comment leaves a “Comment deleted” placeholder.

Release health across platforms

• One row per release. When one release ships to several platforms, the Releases table now shows it as a single row instead of one row per version string. Each platform appears with its own sessions, crash-free rate, and first-seen date. Platforms that miss the crash-free target are flagged individually, so a release that passes overall but fails on one platform is still marked “Below target.”
• Xbox and Vega have their own chips. Builds for Xbox and Vega OS are no longer labelled “Web.”
• Per-platform alerts. A release health alert now fires when the release total is below target, or when any one platform is below target with enough sessions of its own.
  • You still get one alert per release, and the existing 24-hour cooldown still applies.
  • An episode closes only when the total and every platform have recovered.
  • A second platform failing during an open episode doesn’t send another notification.

Accurate TV and device names

Reports from TVs now name the actual platform. A Samsung TV reads as “Tizen 9.0 · Samsung TV” instead of “Chrome 120 · Linux.” webOS and Titan OS are no longer shown as Linux, and Vega OS web views are no longer shown as web.

• Already-stored reports are fixed too. Older web SDK versions didn’t send these details, so the dashboard reads them from each report’s stored user agent.
• Consistent everywhere. The corrected names appear on report headers and platform chips, shared reports, Environment groups, error pages and occurrences, the Reports and Errors lists, and AI triage context.
• Filters match the names. The OS filter, facets, and the error-group OS breakdown use the same names, so filtering by “webOS” also finds older webOS reports that were stored as Linux.
• More device detail. When the SDK sends them, Environment groups now show the app identifier, installer, manufacturer, brand, CPU ABI, memory, emulator status, and runtime versions. AI triage context also includes the app ID.

Reports list

The state key filter has been removed from the Reports toolbar. Old dashboard links that include a state filter no longer filter the list.

For developers

Webhook payload is now schema 2.1

Release health alert webhooks now use schema 2.1, and every subscriber receives it. This is a breaking change for receivers that strictly parse schema 2.0.

• platforms lists platforms as the dashboard shows them. Xbox and Vega appear as their own entries.
• belowTargetPlatforms is new. It lists each platform below target, with its counts.
• version now identifies the release, which can cover builds for several platforms.
• A queued notification is cancelled if neither the release nor any of its platforms is still below target when it is due to be sent.

How builds are grouped into releases

Builds are grouped into a release by their version string.

• Platform suffixes are stripped. A trailing build number and platform suffix are removed when the suffix is one of web, webos, tizen, vega, vidaa, titanos or xbox (case-insensitive). A leading v is optional.
  • 12.5.0-13-tizen joins release 12.5.0 as its Tizen build.
  • 2.5.0-beta-web joins 2.5.0-beta. Prerelease labels are kept, so a beta never merges into its final release.
• Other versions stay separate. Version strings without a platform suffix are their own release. Examples are 2.5.0-beta on iOS or main-abc123-web.

Error comment tools for agents (MCP)

• New tools. add_error_comment, update_error_comment, delete_error_comment and get_error_comment are available.
• get_error_group returns more. It now includes the error’s current state, its status note, and recent changes and comments, each with a changeId. Results are paginated with a cursor.
• Scope. Writing comments uses the existing tickets:write scope.

Reports API: state filter

The state_filter parameter on the reports API is still accepted. Only the dashboard control was removed.

Everframe 1.6.1 is a dashboard and service release with no SDK changes. Device linking has moved from organization settings into each project’s settings, so you link and manage devices where you already work on that project’s apps. Integrations that call the organization-level device routes need to switch to the project-level routes listed below.

Service and dashboard

• Devices now live in Project settings. A new Devices section in Project settings, second after General, lists the project’s linked devices. Link a device opens straight into that project, with no project picker. Linking was already per project, but the old organization page made you choose a project and showed every device in the organization.
• The organization Settings → Devices section has been removed. Links to it open General instead. The old Companion tab now redirects to the project’s Devices section.
• Quick capture and Record on device follow the move. The Quick capture card links to the project’s Devices section, and Record on device lists that project’s TVs.
• Device management is scoped to the project. A project lists and unlinks only its own devices. Roles are unchanged.

For developers

• Breaking: the device list and unlink endpoints are now project routes, and the organization-level routes have been removed:
  • GET /projects/:projectId/device-links
  • POST /projects/:projectId/device-links/:linkId/unlink
• Unlinking a device through a project it does not belong to returns 404.

Everframe 1.6.0 adds quick capture on real devices. Team members can link a phone or TV to themselves from the dashboard, and the device’s capture gesture then files a private quick-capture draft, as simulators already do. This covers phones, Android TV, Apple TV and Vega. Companion is removed and replaced by device linking, and the default quick capture shortcut is now ⇧B.

Service and dashboard

Quick capture on real devices

• Project settings → Devices lists every device linked to the project’s apps. It shows the app each device belongs to, who it is linked to (a person or the team), when it was linked and when it was last used. Members can unlink their own devices, and admins can unlink any device.
• Linking a device:
  • Choose Link a device to open a two-minute link window.
  • Do the capture gesture on the device: shake a phone, or use the remote gesture on a TV.
  • The device shows a number, and candidates appear live with their number, model, OS and app version. Pick the number your device shows.
  • The dialog follows the device until linking finishes, or tells you if it didn’t. This works even if you close the dialog or leave the tab in the background.
• Team devices: admins can choose Link as team device. That device’s captures go to the shared inbox.
• Moving a device: a device already linked to someone else can be moved to you. The dashboard shows its current owner before you approve.
• Per-app control: the Quick capture card has a Device linking switch for each app.

TV gestures

• Choosing a gesture: the Quick capture card now shows the app’s TV gesture binding. Record on device sets the binding from real remote presses on a linked TV.
  • The dashboard turns the recorded keys into a long press, a sequence or a chord.
  • It warns about navigation and system keys.
• Apple TV:
  • iOS apps now get the TV gesture section and Record on device, with a hint listing the Siri Remote’s keys.
  • A binding that uses keys the remote lacks gets a warning, because Apple TV then falls back to the default gesture: hold Play/Pause for about 1.5 seconds.
  • Only a linked Apple TV keeps the gesture’s presses from reaching the app.
• Vega:
  • The Quick capture card now appears for Vega apps; this settings section was previously hidden.
  • It lists the Vega remote’s keys and hides settings Vega doesn’t use.
  • A binding that uses keys Vega can’t send gets a warning, because the gesture is then off, with no fallback.
  • Every press reaches the app, so a capture also toggles playback once.
  • Vega captures have no screenshot or replay.

Quick capture shortcut and card

• New default shortcut: quick capture now defaults to ⇧B, the one shortcut that both the iOS Simulator and the Android emulator pass to the app. Apps still on double-tap Shift have been moved to ⇧B.
• Shortcut editor:
  • The editor now appears for Android apps too.
  • Double-tap Shift is offered only for apps that run on iOS.
  • The card says when a shortcut can’t reach the Android emulator; Android then uses ⇧B.
  • The iOS Simulator reserved-shortcut warning appears only for apps that run on iOS.
  • The card no longer points to the CLI hotkey.
• Screenshots: clicking the screenshot on a capture card opens the screenshot viewer. Closing the viewer returns you to the title field of the same capture.
• Titles on filed captures: a filed capture keeps the title you typed. The Reports list and report search show that title instead of the report id. Captures filed before this release have been backfilled.

Companion removed

• What’s gone: Companion is retired in favor of real-device quick capture. This removes the Companion tab, phone pairing and the phone reporter app.
• Old reports: reports originally filed through Companion still display normally.

For developers

• ⇧B needs SDK 1.5.1:
  • The service sends a plain-key or Shift+key binding, including the new ⇧B default, only to SDKs from 1.5.1 onward. Those SDKs skip the capture while a text field has focus.
  • Older SDKs keep receiving double-tap Shift, so typing a capital B doesn’t trigger a capture.
  • If the SDK falls back to its built-in config, the shortcut is ⇧B with quick capture turned off.
• Companion endpoints: the Companion pairing and relay endpoints now return 410 with {"error":"companion_removed"}, and old pairing links show a static page. Old SDK builds fail cleanly rather than hang.
• Compatibility kept:
  • Ingest still accepts and ignores the x-everframe-companion-attribution header, so uploads from older web SDKs keep working.
  • Configs that contain companionBadge still parse in current SDKs.
  • Reply threads and the X-Everframe-Device-Token header are unchanged.
• Device link tokens: a linked device holds a token prefixed evf_dev_. It is sent in X-Everframe-Capture-Token alongside capture tokens and expires after 30 days without use. On Vega, the token is kept in the app’s AsyncStorage.
• Vega: quick capture is controlled by the quickCaptureEnabled option.

Everframe 1.5.0 changes only the hosted service and dashboard. Simulator and emulator quick capture arrives on the platform side, with per-app hotkey settings, a draft inbox for fast captures, and personal capture tokens. JavaScript source maps can now be up to 256 MiB. React Native crashes from bundles delivered by Hot Updater now symbolicate correctly.

Service and dashboard

Quick capture from simulators and emulators

• Per-app setting. Each app has a new Quick capture card in its settings, and it is on by default. The service sends the hotkey configuration to SDKs that support quick capture.
• Captures start as drafts. A quick capture arrives as an unfiled draft. Until you file it, it stays out of Reports, search, MCP, AI features, webhooks, triage and reply threads. Unfiled drafts expire from the inbox after 7 days.
• Filing in one step. A live capture card shows new captures as they arrive. The new-ticket form lists Recent captures. Type a title and press Enter to file the ticket.
• Personal capture tokens. You can create a token under Settings → Agents or by signing in with the CLI. A draft captured with your token is private to you. Without a token, the draft is shared with your team.

Other changes

• Larger JavaScript source maps. The service now accepts JavaScript and Hermes source maps up to 256 MiB each, up from 32 MiB. Processing time and memory scale with the size of the map, so large React Native builds that previously had no source map can now be symbolicated.
• Hot Updater symbolication. React Native crashes from over-the-air bundles loaded by Hot Updater now resolve to original source positions when the matching Hermes build and source map have been uploaded. Previously they showed only bytecode offsets. This works for Android, iOS and tvOS bundle locations.
• Try on device cleanup. Cleanup of abandoned Try on device sessions now stops only sessions that Everframe started itself.

For developers

• Source map limits:

  • 256 MiB per map
  • 1 GiB per build
  • 10 GiB per project

  Earlier CLI releases refuse maps over 32 MiB before uploading and report source_map_too_large. Gzip-encoded uploads are accepted.

• Quick capture configuration. SDKs that negotiate the capturehotkey capability receive captureHotkey: { enabled, binding, replay } from the config endpoint. Reports sent with quickCapture: true are stored as unfiled drafts.

• Capture tokens. Personal capture tokens use the evf_cap_ prefix.

• CLI sign-in. The CLI signs in with a one-time code exchange (PKCE). Codes are single use and expire after 120 seconds. Tokens issued this way can be revoked.

Everframe 1.4.1 is a tools release that adds Try on device. The @everframe/cli package can now upload runnable builds of your app from CI. You can then open a report or error occurrence in the dashboard and reproduce it on a live device that runs a matching build. This release also lifts a 25 MB limit that was rejecting larger build-artifact uploads.

SDKs

CLI

• Runnable build uploads. The new everframe device-builds command uploads a runnable build of your app so the dashboard can start a device session from it. Run it from CI ahead of time. Builds are kept separate from your symbol and source map uploads.
• Upload recovery. You can wait for an upload to finish with --wait, or check on it later with status. Both report clear exit codes, so CI can tell a finished upload from a failed one.

Supported targets, accepted package formats and per-platform commands are listed at https://everframe.dev/docs/try-on-device/.

Service and dashboard

• Try on device. Report and error-occurrence media viewers have a new live device mode.

  • Matching. The service picks the build that best matches the report: first by commit, then by version and build number, then the latest upload. It then chooses a compatible device.
  • Starting a session. Selecting the device tab prepares the build and device. The session itself starts only when you press Start.
  • Default tab. Reports with no captured media open in device mode when they are eligible.
  • Reopening. If you dismiss the device view, or the report stops being eligible, it does not reopen when you refresh.

• Device controls. A live session has Screenshot, Back and Rotate controls. The device surface can be resized by dragging or with the keyboard, reset, or made fullscreen without ending the session, and its dimensions follow rotation.

• Reproduction pack. A new evidence tab, selected automatically in device mode, shows:

  • differences between the report and the build and device you are using
  • short numbered steps, setup and expected results
  • any uncertainty in the reproduction, stated rather than hidden

  The JSON and the full pack remain available under Technical details. Error occurrences get the same guidance. Switching evidence tabs keeps the device session running; leaving device mode or changing occurrence closes it.

• Setup and usage. “Enable Try on device” is an optional setup step next to debugging-artifact setup. Device sessions are metered against your organization’s allowance. Builds are confirmed as installed, with the exact build identity verified, before a session is controllable or billed.

• Session reliability.

  • A session keeps its existing valid credential through a brief interruption and recovers on its own.
  • It still ends at its original expiry, even if the browser’s clock changes or the tab is suspended.
  • A late response can’t restart a session after it has expired.

• Larger artifact uploads. Previously, any upload over 25 MB was refused before it reached the API. Source map and dSYM artifact uploads, including R8 mappings and native libraries, and runnable device build uploads now accept larger files. The API still applies its own per-type size limits.

For developers

• New command: everframe device-builds, available from @everframe/cli 1.4.1. Uploads use your Everframe artifact credentials.
• Error output: when the server refuses an upload, the CLI prints request_failed: HTTP <status>. The troubleshooting section at https://everframe.dev/docs/try-on-device/ lists every CLI error code and dashboard reason message.
• Size limits: the API accepts device builds up to 500 MiB and dSYM artifacts up to 512 MiB.
• Retries: rejected uploads are retried after the delay the service permits, up to eight attempts.

Everframe 1.4.0 brings two new kinds of context to React Native iOS and Android reports: the exact source commit behind each build, and typed application state with a history of changes. MCP responses for reports and error groups are now much more compact and informative. Reproduction is available to everyone in the dashboard, and the releases view no longer flags web builds that a newer upload has replaced.

Service and dashboard

React Native reports

• Build commit provenance. Reports from React Native iOS and Android builds can now show the exact source commit behind their uploaded Hermes bundle. This works even for ordinary feedback reports with release health turned off.
  • Native symbol provenance is resolved separately, so an over-the-air bundle commit and the native binary’s commit stay distinct.
  • Commit details remain available after the uploaded artifact expires.
  • Conflicting commit claims are rejected.
  • The same evidence appears in the report context, the report drawer, MCP, and Copy for AI. It is never guessed from version or build numbers.
• Application state. Reports now keep typed application state alongside breadcrumbs.
  • A report shows the state at capture time and the ordered changes that led up to it.
  • State changes appear in report and error timelines, and you can seek to them in replays.
  • The Reports feed can be filtered by exact string, number, or boolean state values. Boolean true and the string "true" are treated as different values.
  • Redaction is reapplied on ingest. Invalid optional state is dropped without rejecting the report.
  • State is removed when a report is erased or expires.

Reproduction

• Always available. The Reproduction view is now available in the dashboard without any setup.
  • On a report, open ⋯ → Data… → Reproduction.
  • On an error group, the standalone Reproduction button has been replaced by a Reproduction… item in the header’s ⋯ menu.
  • Packs load only when you open the view.
• Journeys from captured targets. Reproduction packs now turn captured interactions into step-by-step target and screen journeys.
  • Named remote-control buttons are kept as executable steps.
  • Shared setup runs once.
  • Interactions with the Everframe reporter and dev tools are left out.
  • Missing text or targets are shown as unknown rather than guessed.

Releases

• Superseded web builds. A web, Tizen, or webOS build without source maps no longer counts toward a release’s “Missing N of M” once a newer build of the same release has uploaded its maps and the older build has stopped sending events.
  • A missing build that keeps sending events still counts, because it is a live deploy without maps.
  • In the expanded release row, superseded builds sit behind an “N older builds without maps” toggle. They are marked Superseded and have no upload prompt.
  • Native artifacts (Hermes, R8, dSYM, ELF) are never treated as superseded.

MCP

• Richer error groups. get_error_group now returns more context in a single call:

  • a representative mapped stack trace
  • the top ten values for each affected environment
  • a 30-day trend
  • the first-seen version
  • recorded automatic regressions
  • breadcrumbs common across the latest 100 retained occurrences

  Alternative R8 frame mappings are kept and prefixed with or. Linked error groups opened with resolve_link get the same summary.

• Compact reports. get_report responses, and reports opened with resolve_link, are now compact by default.

  • Repeated navigation is grouped, and numeric series are summarized with extremes and first and last values.
  • Timestamps, unknown fields, and trim markers are kept.
  • Typical responses are about four to five times smaller.

• Clearer handling of report content. The fixed agent instructions now sit outside the section that holds untrusted report content. Generated AI analysis stays inside that section and is labelled as such.

For developers

• MCP view parameter. get_report and report resolve_link accept view: "full" to return the expanded evidence that was the default before this release. Omit it to get the new compact output.
• Hermes upload metadata. React Native Hermes source-map uploads can now carry optional commit, branch, and dirty-tree metadata. This metadata enables the commit provenance shown on reports. Existing uploads and manifests continue to work unchanged.

Everframe 1.3.0 is mainly a release of the hosted service and dashboard. Release health now covers web, TV web runtimes, Flutter and Kotlin Multiplatform, tvOS, native Vega and Roku. Error grouping is now automatic for every platform, with no per-app settings to maintain. Web releases are now identified by their version, and several fixes make issue lists, new-error counts and reporter inboxes more accurate.

Service and dashboard

Release health on more platforms

• Web and TV web. Web releases appear in Release health alongside native apps. Web, Tizen, webOS, Vega, Vidaa and TitanOS are included in rates, filters and existing alerts.
  • Unhandled global errors count as failed sessions.
  • Debug builds are excluded.
  • Sessions with an unknown outcome are left out of the rate.
  • The dashboard explains how an observed error is defined.
• Flutter and Kotlin Multiplatform. These integrations no longer have their release health sessions rejected. Android and iOS foreground sessions are accepted, as are supported browser and TV page sessions. The integrations appear in health views, alerts, dashboard filters and empty-state guidance. Flutter Dart errors are not counted in the native crash rate.
• tvOS. tvOS sessions appear in Release health with their own runtime badge and filter, version detail, alerts, and a runtime-scoped link from release rows. They are accepted through the existing Apple integration key. A native crash is attributed to a session only when it can be matched to that session. Inferred terminations are not counted as proven crashes.
• Native Vega. Native Vega integrations appear in Release health, with version rows, fatal JavaScript crash evidence, alerts, release links and webhook setup. A fatal crash report counts only when it matches its session and is still retained. Browser Vega keeps its existing page-session behavior.
• Roku. Roku integrations appear in Release health, with monitored-launch counts, version rows, platform filtering, new-error links, alerts and a BrightScript crash breakdown.
  • Only confirmed BrightScript or native crash exits count as crashes.
  • A launch that ends with user navigation counts as completed.
  • Resource and system exits, conflicting exits, and launches with missing evidence count as unknown and are excluded from the crash-free rate.

Accurate new-error counts per platform

“New errors” counts, their links, and Top errors now include only errors first seen in the version by the apps and runtimes the view covers. Previously, an error from one app could be counted against another app that shipped the same version number. One example is a web error appearing on an Android-only release row. The same applies when one integration key reports the same version on more than one runtime, such as iOS and tvOS, or native and browser for Flutter and KMP.

Automatic error grouping

Error grouping is now automatic, and the per-app grouping settings have been removed from the dashboard. Existing events and issues keep their grouping.

• Android R8 and Hermes: the existing grouping rules now always apply.
• Apple native and Android native: errors group on the first frame that the app’s uploaded symbols can map, skipping system libraries. You no longer need to declare a module or source root.
• Web and React: once source maps are uploaded, errors group by the function they occurred in. This uses the original source file and the function’s scope (for example cart > save). When the function can’t be verified, grouping falls back to the exact mapped position. Events grouped under the previous web scheme keep their existing grouping.

Known limitations:

• Manual merge and split are not yet available for issues grouped under the new web scheme.
• Android native grouping cannot yet distinguish libraries built by the app from bundled prebuilt libraries.
• Indexed source maps can split one web error across builds.

Web releases are identified by version

On web, Tizen and webOS, a release is now identified by its version alone. Previously, every deploy created a separate, near-duplicate release.

• Each deploy’s build ID is listed under its release, along with its source-map status.
• Version strings such as 12.3.5-12-web are shown exactly as reported. On these platforms they are not treated as pre-releases.
• Releases are ordered by their numeric version (12.3.5 < 12.3.6 < 12.3.10).
• A new deploy of an already-resolved version is the same release, so its resolved issues stay resolved.
• Web events that report the placeholder version 0.0.0 still use their build ID to tell releases apart.
• Native platforms keep standard semantic versioning. For example, 2.4.0-12 on iOS is still a pre-release.

Fixes

• Stale issues no longer reappear. When an error first lands in a temporary group and is later moved to its mapped issue, the temporary group now reverts to only what it still contains. Previously, it could keep reappearing in the issue list as recently seen and unread next to the correct issue.
• Reply threads only for reports people file. On apps with replies enabled, automatically captured errors and crashes no longer get a reply thread or show up in the reporter’s “Your reports” inbox. Existing threads on automatic captures have been removed, along with their messages.

MCP: create and edit tickets

MCP connections can now create and edit tickets, not just read them.

• Ticket and comment changes: create and update tickets; add, edit and delete comments; link and unlink reports; restore archived tickets.
• Discovery: list the valid boards, columns, assignees and repositories.
• Richer reads: ticket reads now include editable fields, comment IDs, versions and pagination.
• Rules and limits: writes follow the same validation, permissions, history and notifications as the dashboard. Edits made against an outdated ticket or comment are rejected. File uploads and ticket deletion are not supported.

For developers

• Grouping settings removed from the admin API. The per-app error grouping fields and routes no longer exist. Remove any integration code that reads or writes them; grouping is now automatic.

• MCP write access requires reconnecting. OAuth connections remain read-only by default. To enable ticket writes, reconnect and request the scopes mcp:read tickets:write. Consent shows the requested write access, and granted scopes are kept when tokens refresh. API-token project allowlists now apply to both reads and writes.

• Roku release health requirements:

  • Roku OS 13 or later.
  • The updated channel-side Main() bridge.
  • An explicit launch-marker handoff from the host to start().

  Channels that still use the older inline exit snippet keep error reporting but do not report release health.

• Release health needs a compatible SDK. Web, Flutter, KMP, tvOS, native Vega and Roku release health all require an SDK that sends release health sessions for that platform. Native apps on existing SDKs continue to work unchanged.

Release 1.2.1 is a service and dashboard release: the SDK changes described here need no code changes in your app. Error pages can now play back the session replay leading up to a handled error. The hosted service can now symbolicate native Apple and Android crashes in production. A new crash-only sessions coverage setting is ready in the dashboard ahead of SDK support.

Service and dashboard

• Replays on error occurrences. The error page can now play the session replay leading up to a handled error, for each occurrence. When no replay is available, it shows an empty state that explains why.
• Replay retention per error group. Each error group keeps its ten newest replays. Older replays are trimmed automatically, including after an error is regrouped or merged. Trimming never removes the occurrences themselves, their board links, or unrelated attachments.
• Lower native frame rates. Native session video can now be set to 1, 2, 5 or 10 fps, with a suggested sampling setting shown alongside.
• Native crash symbolication. The hosted service can now symbolicate Apple crashes using dSYMs and Android native crashes using ELF symbols. Before this release, production could not symbolicate either.
• Crash-only sessions coverage. The Session replay card has a second coverage control, “Crash-only sessions”, which defaults to 0%. The existing control is now labelled “Sessions that can file a report”. When the two coverages differ, the error page’s empty replay state names both.
• The companion device list no longer labels devices as running an “older SDK”.

For developers

• Frame rate negotiation. The 1 and 2 fps native video settings are sent only to SDKs that report support for low frame rates. SDKs without that support keep receiving 5 fps, so existing integrations behave as before.
• Crash-only sampling rate. The app endpoints of the admin API now accept and return crashOnlySamplingRate, a value from 0 to 1. The default is 0.
• Crash-only sessions. GET /api/config sends crashOnlySamplingRate to SDKs that declare crash-only support, as SDK 1.2.1 does. Other SDKs never receive it.

Everframe 1.2.0 turns crash reporting and release health on by default. Android and iOS/tvOS capture crashes with no extra setup, and crash-free rates are reported for each app version. Releases now create themselves from incoming events, and the errors list and error page are redesigned. The SDK key option is renamed to sdkKey on every platform. The old names still work, so upgrading needs no code changes.

SDKs

Android

• Crash reporting is on by default. It covers JVM exceptions, native crashes, ANRs and, on Android 11 and later, low-memory kills while the app was visible or audible to the user.
• Android TV devices now report their form factor as TV.
• The SDK declares the INTERNET permission itself, so you no longer need to add it to your manifest.

iOS and tvOS

• Native crashes are recorded automatically and sent on the next launch. This covers Swift traps, uncaught Objective-C exceptions, memory faults, abort() and fatal signals. On tvOS, stack overflows are not captured.
• Native crash capture on tvOS has been verified on the tvOS 26.5 and 27.0 simulators.
• The SDK now reports when the OS ended a previous foreground session with SIGKILL. It sends this as a crash labeled inferred, with a cause of low memory, unresponsive or unexplained. These events have no stack trace.
• The same setup code now compiles on iOS and tvOS, in both a SwiftUI App and a UIKit app delegate.

React and React Native

• React render errors are now reported as a single fatal JavaScript error with the component stack. On React Native they no longer show up separately as a native RCTFatal or JavascriptException issue.
• Unhandled JavaScript errors in React Native apps now count as crashed sessions in release health. The native termination that follows is not counted a second time.
• Unhandled promise rejections can now be reported on React Native, as an opt-in.

All mobile SDKs

• Release health is on by default on Android, iOS and React Native.
• Debug builds are marked as such. They are not counted in release health and never create releases.

Vega OS (preview)

• JavaScript crash reporting for Amazon Vega OS apps is available as a preview. It reports JavaScript errors only, without cause chains, and React Native 0.83 on Vega OS 1.2 is untested. See https://everframe.dev/platforms/vega-os/.

Symbol uploads

• Symbol uploads can now run automatically from the CLI and the Android Gradle plugin.
• In lenient mode, an upload continues past a single failed file instead of stopping.

Service and dashboard

Errors list

• Each row now shows the culprit frame, a 14-day trend, the event count and when the error was last seen. On phones, rows use a compact two-line layout.
• A single status control switches between Open, Snoozed, Ignored and Resolved.
• You can filter by type (crashes, errors or both), version and app, and sort by last seen, most events or newest.
• From a selection, you can resolve, reopen, snooze, ignore or restore up to 100 errors at once, and merge 2–20 errors.
• Owner assignment has been removed.

Error page

• The page is rebuilt around a header with Resolve, Snooze, Ignore, Copy link and “Copy for AI”.
• A stats band shows events, users affected, first and last seen, and a 14-day chart.
• An event navigator lets you step through events or open the full list.
• Stacks from every runtime now use one stack trace card, with “Your code”, “All frames” and “Raw” views. The crashing frame in your code opens with surrounding source lines.
• A “Before the crash” timeline ends on the crash.
• An Activity feed lists resolves, regressions, merges and moves, and lets you split a merged error back out.

Grouping and symbolication

• Mapped Hermes, Android native and Apple native issues can now be merged within an app, and split back out later.
• ANRs on Android now appear as “ANR” issues under Crashes. Each is retraced and grouped by app and main-thread stack.
• Android low-memory kills appear as “Low-memory kill” issues. They show the app’s importance at the time it was killed and its memory use.
• Inferred Apple terminations are labeled as inferred and are not counted as fatal crashes.
• tvOS native crashes now appear in the native stack view instead of falling back to “Source maps missing”.
• React Native crashes on tvOS now have their JavaScript frames mapped.
• Mapped JavaScript frames are now named after the function they are in, not the function being called.
• Apple crashes from a new build now join the existing issue once that build’s dSYM is uploaded.
• Universal dSYMs that contain a slice already uploaded are now accepted.
• Android crashes inside Kotlin lambdas now group across builds.
• Swift stacks no longer always show as “Partially mapped”. Compiler-generated frames and entry points are labeled as having no source line.
• Includes fixes for React Native Android Hermes issues.
• Roku BrightScript frames now display correctly.
• JVM frames that older SDKs over-redacted are now classified by their package.

Symbol files

• Apple dSYMs and Android R8 mapping files up to 512 MiB are now accepted. R8 mappings are downloaded once and reused for later crashes, which speeds up retracing.
• The per-project symbol storage quota is 10 GiB. When an upload would exceed it, old builds are removed automatically instead of the upload failing.
• A removed or expired build can be uploaded again to restore processing.
• When symbols are missing, the dashboard names the missing identifier and gives the exact upload command.

Releases

• Releases are now learned automatically from incoming events and sessions. Each release is identified by app version and build for each platform, plus React Native OTA updates. Releases are ordered by version.
• Each integration page has a Releases card showing symbol status, with Hide/Unhide for admins.
• “Resolve in next release” works on any error with an event from a known release.
• Regression alerts are available on every app.

Release health

• Release health now has one page per app version, covering the project’s Android, iOS and React Native apps.
• The overview shows the latest release’s crash-free sessions and users compared with the previous release. It also shows sessions by version, daily crash-free sessions against your target, and a releases table that flags versions below target.
• Each version page shows tiles, a comparison with any other version, top errors and a breakdown of what crashed.
• A single alert rule per project sends a webhook when a version drops below a crash-free sessions target.
• Until sessions arrive, the page explains that release health is on by default.

Other

• The Setup tab now shows the app’s App ID with a copy button.
• Ingest-side redaction of JSON Web Tokens no longer masks class names, bundle IDs or version strings that happen to contain eyJ. It is also no longer slow on large bodies.
• Ingest accepts JSON request bodies, which Vega OS reporting needs.
• The reports list now matches the errors list design, and the board has layout fixes and a “New card” button.
• Playback is hidden from the project menu while it is unfinished.

For developers

• sdkKey replaces apiKey and appId for the SDK key.
  • JavaScript SDKs use <EverframeProvider config={{ sdkKey: '…' }}>.
  • iOS uses EverframeConfig(sdkKey:), and the missing-key error is now EverframeConfigError.missingSdkKey.
  • The old names are deprecated but still accepted.
  • 1.2.0 is the first release with sdkKey: use SwiftPM from: "1.2.0" or @everframe/[email protected]. For automatic patch updates on the web script tag, use @~1.2.
• Android appId is the App ID. This is the app’s UUID shown in the Setup tab, the same value symbol uploads take. It is not an evf_app_… value.
• Android crash capture is on by default. To turn it off, use CaptureConfig(crash = false).
  • Low-memory kill reports need API 30 or later and isLowMemoryKillReportSupported().
  • Kernel OOM kills are recorded as SIGNALED.
• Release health is on by default on Android, iOS and React Native. Flutter and KMP keep it off. Debug builds are not counted.
• React Native promise rejections are opt-in with crashReporting.promiseRejections.enabled.
  • They are supported only on react-native-tvos 0.85.3-0 with Hermes, in Release builds, on phones and tablets.
  • Other runtimes and TVs report unsupported.
• tvOS setup: EFReporterPresenter.installResolver() is now a no-op on tvOS. On SDK 1.1.0 and earlier, keep it inside #if !os(tvOS).
• Android INTERNET permission: on 1.1.0, declare it yourself. From 1.2.0, the SDK merges it in.
• Releases are automatic.
  • Previously registered releases, the manual artifact registry and the “Fixed in release X” picker have been removed.
  • Debug builds, identified by context.app.debug, never create releases.
  • Releases in the issue.regressed webhook payload are now objects with id, platform, version, build and OTA update fields. Check any integration that parses them.
• Symbol uploads:
  • Artifact uploads accept Content-Encoding: gzip. The quota counts uncompressed bytes.
  • Apple dSYMs can be uploaded with npx @everframe/cli dsym upload-build --binary … --dsym-dir …. See https://everframe.dev/docs/ios/crash/.
• Vega OS (preview): initialize the SDK with AsyncStorage and upload bundles with upload-vega.

Everframe 1.1.0 makes crash and error data easier to read. The dashboard now shows real stack frames for Flutter errors, source maps match more reliably, larger React Native maps are accepted, and replays of React Native Web sessions show their images again. In the SDKs, the Android reporter recovers cleanly when its Activity is destroyed while it is open, and mobile error reports now include each error’s underlying causes. The hosted MCP server now marks every tool as read-only.

SDKs

React Native on Android

• Destroying the host Activity while the bug reporter is open is now handled. The JavaScript call that opened the reporter resolves as a cancellation instead of staying pending forever, and the reporter no longer stays marked as open. Session replay capture no longer freezes, and the reporter can be opened again afterwards.

Error causes

• Error reports now include each error’s chain of underlying causes for:
  • React Native JavaScript errors
  • Android Throwables
  • supported Apple Foundation errors

Service and dashboard

• Readable Flutter stack traces. The error-group page now reads Dart VM stack frames. Handled Dart errors from the Flutter SDK show the function, file, line and column for each frame, where they previously showed <anonymous> rows.
  • <asynchronous suspension> markers are no longer listed as frames.
  • dart: and package:flutter/ frames are treated as framework code and fold like other framework frames.
  • Obfuscated release builds (--obfuscate / --split-debug-info) have not been tested and are not expected to show readable frames.
• Images in React Native Web replays. Images set through inline styles, which is how React Native Web renders every <Image>, used to replay blank. They now load correctly.
• Larger source maps. The source-map processor has more memory. React Native maps of around 30 MB, which were previously rejected with processing_limit, are now processed.
• Source-map setup in quick starts. The React Native and web quick starts in the dashboard have a new optional “Readable stack traces” step, with your app ID already filled in.
• MCP server. All eight tools on the hosted MCP server now have a human-readable title and are marked read-only. Clients can use this to decide whether a call needs your confirmation. Everframe is also listed in the official MCP Registry as dev.everframe/everframe, a Streamable HTTP remote at https://everframe.dev/mcp.

For developers

• Source-map matching. Web stack frames are now matched to uploaded maps in two steps:

  1. by exact URL;
  2. failing that, by the longest matching path among the maps uploaded for the crash’s build.

  Any URL scheme is supported, including the file:// URLs that packaged TV apps load scripts from. Maps you have already uploaded keep working without changes.

• MCP tool annotations. Every tool in tools/list now returns a title and these annotations: readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false. Previously annotations was null.

Everframe SDKs now share a stable 1.0.0 release across web, React, React Native, Android, iOS, tvOS, Flutter, Kotlin Multiplatform, Roku, and the identity companion package.

SDKs

• Flutter web and Kotlin/JS reporting. Renderer-owned screenshots and replay capture support host-rendered interfaces while retaining privacy masking.
• Aligned native dependencies. Flutter and React Native resolve the matching 1.0.0 Android and Apple SDKs. Kotlin Multiplatform 1.0.0 includes Android, iOS, JVM, and JavaScript artifacts.
• Example fixes. The Java Views example uses the current SDK configuration, and the KMP Compose mobile probe uses stable dependencies while keeping Android minimum SDK 24.

Distribution

JavaScript SDKs use the @everframe npm scope, Android and Kotlin Multiplatform use dev.everframe on Maven Central, Flutter uses everframe_flutter on pub.dev, and Apple integrations use the Everframe CocoaPod or the public Swift Package Manager release tagged v1.0.0.

This release renames the product from TraceItX to Everframe across the hosted service and dashboard. It has no changes to SDK behaviour, and most of the remaining work is internal restructuring with no effect on integrations. Your existing projects, reports and stored data carry over unchanged.

Service and dashboard

• Everframe rebrand. The admin dashboard and hosted API now use the Everframe name. Existing data, stored report attachments and saved settings are preserved, so no action is needed on your side.

SDK distribution

• New Everframe package coordinates. JavaScript packages are published under @everframe, Android artifacts under dev.everframe, CocoaPods as Everframe, and SwiftPM from scriptx-com/everframe. The production ingest endpoint is https://everframe.dev.

Reports and crashes now arrive with a short, high-resolution window of CPU and memory usage leading up to the failure, while playback sessions stop carrying the idle CPU/memory samples that made long sessions expensive for no benefit. The web and React SDKs now take their report hotkey from the dashboard, and the SDK surface has been simplified so the platforms behave the same way. On the service side, the dashboard gets a full-page report and error workbench, playback sessions are attributed to the person watching, an error-monitoring stack lands with symbolication and release regression detection, and a read-only MCP endpoint lets coding agents pull the evidence for a bug themselves.

SDKs

All platforms

• Reports and crashes now include a resource window: CPU and memory sampled at two-second resolution around the moment of the failure, so the evidence is aligned to what went wrong.
• Session Vitals no longer ships periodic CPU/memory samples. Playback sessions carry only playback events; the resource window above replaces the old low-resolution stream. The service also discards samples from older SDK versions, so nothing needs to be redeployed to benefit.
• The public SDK surface has been simplified so the platforms have parity with each other, and the size limit for extra data attached to a report has been raised.
• Report titles can be longer.
• The screenshot capture deadline has been extended so captures on heavy screens, such as TV home pages, no longer fail.
• Android, iOS and React Native: structured error details now respect both the emitted JSON and JavaScript byte limits.

Web and React

• The report hotkey is now configured from the dashboard and applied live by the SDK, including when the configuration is refreshed. The default binding is Mod+Shift+B, and the matcher accepts any two-to-four-key chord.
• Playback sessions are attributed to the person watching: the web and React SDKs send the same identity they already use for reports along with the vitals summary.

Android

• Fixed the on-screen keyboard overlapping the report form.

Service and dashboard

Report and error workbench

• The report drawer is replaced by a full-page workbench. The device sits on a stage at its real aspect ratio inside a phone, tablet, TV or browser frame, with a switch between annotated screenshots and the replay. Beside it, a developer panel offers Trail (every breadcrumb, filterable and searchable, following playback), Network (with request and response bodies where captured, and each row expanding to its full URL), Console, Context, Resources and Thread.
• A four-lane timeline (taps, screens, network, logs and errors) sits under the stage with a playhead and a compact trail strip. Report time starts at the first event, the recording is shown as a band on the axis, and seeks land paused so you can inspect a moment.
• The panel docks right or bottom with a fold, remembers its state, and supports a focus mode and keyboard shortcuts (arrows seek, / search, 1–6 switch tabs, j/k move between siblings). On short screens the page flows naturally, the timeline starts folded behind a Timeline toggle, and the stage keeps a usable minimum size.
• Screenshots are capped at 1120px wide (never upscaled); the lightbox and fullscreen remain for reading larger captures.
• The error-group page shows one occurrence at a time: pick the latest or step through older and newer ones, see the exception and stack (with Copy), and view the trail relative to the crash, the replay frozen at the crash, network, console and context. The Occurrences tab adds an OS / release / route breakdown above the table. A generic cause view is available, and causes are recovered when a source map arrives late.

Reports and Errors lists

• Both lists gain search (a word from the title, or the start of an id) plus Platform and Version filters backed by distinct-value facets with counts, so you can pick a version and then widen the date range.
• The Reports list adds Platform and Version columns, a replay icon in Attachments, a test-ping badge beside the title, and an inline Add to board button.

Error monitoring

• Error monitoring is integrated into the service: explicit capture, private web, Hermes and R8 artifacts for symbolication, grouping promotion once frames are mapped, release regression detection, and webhook routing.

Playback sessions and people

• The Sessions section is renamed Playback. Each playback session is attributed to the person watching, across both identity tiers (verified token and self-declared user), and rendered exactly as people appear on reports, including the unverified badge.
• The playback list has a person column and per-person filter; session detail shows the person; a person’s profile lists their playback sessions beside their reports.
• A person can now be erased: their identity is detached from all sessions and reports, which remain intact and anonymous.

Hosted MCP server

• A read-only MCP endpoint lets a coding agent fetch bug evidence directly. Eight tools, each scoped to one project: list_projects, get_report, get_screenshot, get_error_group, get_ticket, get_ticket_attachment, search and resolve_link. Paste any dashboard URL into resolve_link and the agent gets the matching report, error group or ticket without knowing any ids. Images are listed and fetched on demand, never dumped into the conversation.
• Connection uses browser-based authorisation with a consent screen; a grant acts as the person who approved it and is re-checked on every call. There are no write tools, user-submitted text is wrapped in an explicit untrusted-content boundary, content types are decided by sniffing bytes, and refresh tokens rotate with whole-family revocation on reuse.

Companion

• The Companion tab attaches to one device at a time. Attaching to a second device while connected is refused with a dialog naming the current one; Detach is the only way to move. The attached device is dropped from the list.
• Fixed Detach staying disabled after a successful detach, which previously required a page reload before re-attaching.
• Centred dialogs now use an even glow on all sides instead of a shadow that dropped below the bottom edge.

SDK configuration

• The SDK configuration overview is redesigned into Report Entry, Communication, Session Context and Evidence Trail groups with live previews, a phone-friendly accordion layout, and a hotkey recorder for arbitrary two-to-four-key chords.

For developers

• Breaking (web and React): the SDK-side config.hotkey option and the public registerHotkey helper are removed. The report hotkey is now the dashboard’s reportHotkeyBinding setting (default Mod+Shift+B) and is authoritative; the SDK negotiates and applies it, including on live configuration refreshes.
• SDK surface parity: the public API was simplified so all platforms expose the same surface. Review the updated SDK documentation when upgrading, as some calls have changed.
• Session Vitals: the SDKs no longer emit CPU/memory sample entries. The sample type remains accepted by ingest so chunks from older SDKs still validate; the service drops samples after validation and writes nothing for a sample-only chunk.
• New endpoints:
  • DELETE /api/admin/projects/:projectId/people/:identityId (admin-only) erases a person, setting the identity to null on every referencing record.
  • GET /projects/:id/events/facets returns distinct platform and version values with counts, scoped like the events feed but never by date.
• MCP: the endpoint is at /mcp over stateless Streamable HTTP. Authorisation implements the OAuth 2.1 subset MCP clients expect — RFC 9728 protected-resource metadata, RFC 8414 authorisation-server metadata, RFC 7591 dynamic client registration, RFC 7636 PKCE (S256 only), RFC 7009 revocation, and RFC 8252 native-app rules including loopback port variation. Clients that cannot run the browser flow can use an API token (txx_api_ prefix) as a bearer credential.

Release 0.8.1 is a stability and compatibility release. Native replay no longer crashes on iPad when a layer holds an opaque backing object, Android replay records normally on screens that mount hidden background WebViews, and the web and React SDKs now handle older TV browsers — fewer stalls during recording, correct screenshots on apps with hidden scrollbars, and successful report preparation on runtimes missing modern browser APIs. On the dashboard side, the retired native view-tree recorder’s image-asset settings are gone and the remaining video replay setting is now correctly labelled as applying to both iOS and Android.

SDKs

iOS / tvOS

• Fixed a crash inside replay snapshot collection that could bring down the host app when a layer’s contents were an opaque backing object rather than an image. Snapshot diagnostics now record only the runtime type name for unsupported contents; image classification, fallback rendering and privacy behaviour are unchanged.

Android

• Native replay no longer records zero frames when a screen keeps an always-mounted background WebView (for example a hidden 1×1 measurement view). WebViews that are proven hidden — GONE, fully transparent, or fully clipped — no longer block capture, and visibility is rechecked at each capture boundary so a view that becomes visible or moves into an overlay cannot slip past the checks. Visible and partially transparent WebViews, explicitly marked sensitive views, inputs, surfaces and uncertain animation or overlay cases remain excluded from capture.

Web and React

• Large reductions in recording overhead on constrained TV browsers. Replay buffer accounting no longer re-serialises the buffer repeatedly, deep DOM snapshots use a bounded fallback instead of tripping the size cap, and snapshot work is cheaper overall. On an LG TV running Chrome 53, buffer accounting work fell by roughly 64%, sampled full-snapshot work by roughly 29%, and worst observed frame gaps dropped from about 1.0–1.1 s to about 0.8 s. These are small on-device experiments, not guarantees.
• Screenshots now preserve an app’s own scrollbar styling instead of reintroducing native scrollbars, so previews look like the real screen.
• Compatibility fixes for older runtimes that previously produced grey screenshot previews or failed report preparation: Blob bytes are read via FileReader when arrayBuffer is unavailable, DOM cloning and matrix/transform handling fall back to legacy-safe paths, hashing no longer requires BigInt, and schema validation correctly detects when its optimised parser is unsupported.
• Time pruning keeps working after an incomplete checkout while preserving the only playable anchor, so replays remain playable.

Service and dashboard

• The Replay images card has been removed from app settings, along with its configuration end to end. It controlled the retired native view-tree recorder and no longer had any effect.
• The remaining frame-rate control is now labelled Native video replay (iOS and Android); it always applied to both platforms, but the old wording described it as iOS-only.

For developers

• Removed configuration: replay image assets. The image-asset settings for the retired native view-tree recorder are gone from the dashboard, the hosted API, and the shared, Android and iOS SDK configuration models, including the related public exports. If you referenced these options in your integration code, remove them. SDK versions that still request an image override receive none and fall back to their built-in defaults, so no action is required to keep older builds working.
• No schema removal in this release. The now-unused replay-image column remains physically present so that the previous API version keeps working during migrate-before-restart deployments and after a rollback. Nothing in current code reads or writes it.
• Native video replay is unchanged. The shared frame-rate setting continues to apply to both iOS and Android; only the label changed.
• Bundled browser patches. The web and React SDKs now ship the patched versions of their recording dependencies together with the corresponding dependency notices. Capture and replay code remains lazily loaded, so this does not change your initial bundle cost.

Session Vitals lands in this release across every platform: the SDKs now report video playback quality, memory and responsiveness continuously, and the dashboard gains a Sessions tab with per-session timelines and aggregate metrics. iOS, tvOS and Android reports can now carry a native video replay of the moments before the report was filed, replacing the older tree-based replay on those platforms. The dashboard splits the old Events feed into Reports and Errors with team-shared unseen state and a rebuilt error-triage page, and billing now computes and collects VAT on checkout. Session Vitals is off by default and enabled per app from the dashboard, so upgrading the SDK alone changes nothing you have not opted into.

SDKs

Session Vitals (all platforms). When enabled for an app, the SDKs collect a lightweight session record: video playback quality (startup time, buffering, bitrate and quality changes, player lifecycle events) alongside memory, CPU and responsiveness sampling. Sampling pauses while the app is backgrounded or the page is hidden, sessions rotate after 30 minutes idle, and the collector is byte-capped and never throws — if the transport fails, your app is unaffected. Reports and crashes now carry the session id and the last 60 seconds of vitals, so a filed report links straight to the session it came from.

Playback tracking is per player, so a page or screen with a main player, a picture-in-picture player and an ad player reads as three distinct timelines rather than one merged stream. Where a player library sits above the platform’s media element, an optional integration supplies what the element cannot see: source URL and streaming protocol, DRM key system, the bitrate ladder, current quality, and a startup breakdown (manifest, licence, first fragment, first frame).

• Web and React — automatic tracking of plain media elements, plus opt-in integrations for hls.js and Shaka Player. Neither library is added as a dependency or peer dependency; you hand us your existing instance.
• React Native — a library-agnostic player bridge with adapters for react-native-video (v7) and THEOplayer. CPU and memory sampling and session ids were already inherited from the native SDKs; this adds playback.
• Android — a native collector with CPU and memory sampling, and playback tracking for Media3/ExoPlayer through a new companion artifact.
• iOS and tvOS — a native collector and AVPlayer playback tracking, shipped inside the existing framework: no new package, product or target to add.

Native video replay on iOS, tvOS and Android. Reports from these platforms can now include an MP4 replay of the seconds before the report, played back inline in the dashboard with seek-to-event markers. Capture is masked for sensitive views, runs at a dashboard-selected 5 or 10 fps, is bounded in size and duration, and is stored encrypted on device until upload succeeds — surviving process restart and retrying through network failures. Opening the reporter freezes the footage, so time spent writing or annotating a report does not eat into what gets submitted. On tvOS, replay is validated end to end through the companion reporting flow.

Web reporter captures the page before it takes focus. Previously the reporter dialog moved focus to its own title field before photographing the page, so focus rings were missing from screenshots, anything the host page closes on blur (comboboxes, autocomplete, menus, popovers) collapsed out of the shot, and the recorded focused element described the reporter’s own input instead of the user’s. Most visible when opening the reporter with the keyboard shortcut. The page is now captured with focus intact.

Service and dashboard

• Sessions. A new Sessions tab lists sessions with health columns (startup, rebuffer percentage, errors, peak memory) and filters for integration, time range and errors. Session detail shows a lane timeline with buffering regions, memory and CPU, per-player cards (source, DRM, startup breakdown, quality range, health), a bitrate line per player, custom entries, and the events linked to that session. A Metrics view charts session counts, rebuffer ratio, startup p50/p95 and error rate over time, optionally grouped by app version or platform.
• Reports and Errors are now separate. The project Events feed splits into Reports (user-filed) and Errors (automatically captured crashes and errors, grouped by fingerprint). Both carry a team-shared unseen flag — one per report, one per group, not per user — surfaced as badges on the project rail. Error groups have a resolve/reopen lifecycle, so a new occurrence on a resolved group reopens it and badges as a regression. Existing links to individual events keep resolving, and nothing badges on deploy: everything already in the database is marked seen.
• Rebuilt error-group page. Built around triage: a one-line headline taken from the message rather than the exception type, the full message and stack trace rendered as code, stack frames parsed into function/file/line with app frames highlighted and framework runs folded, breadcrumbs leading up to the error, contextual occurrence rows, an environment/app/reporter aside with a crash card for native crashes, and a 14-day occurrence sparkline.
• List pages share one anatomy. Errors, Reports, Sessions and People now use the same title row, filter toolbar with a Clear filters control, table styling and reading order. Tables get a distinct header band, visible row hover and focus, and right-aligned tabular numerals for numeric columns.
• Numbered pagination. The four list pages replace opaque Previous/Next cursors with real numbered page links that state position in rows (“301–350 of 2,081”). Page number and size live in the URL, so pages are shareable and Back returns where you left. Very large lists show a capped total (for example “10,000+”). Reports and Sessions freeze the walk’s base instant so rows arriving mid-walk cannot shift pages under you.
• AI-ready report envelope. Report detail gains an AI Envelope tab with copy-ready Markdown containing the title, description, AI overview, runtime variables, extra captured data and every breadcrumb, plus seven-day signed attachment and replay links that stay usable outside an authenticated dashboard session. A standalone, origin-restricted replay viewer accompanies it.
• Session Vitals controls. Each app’s Overview gains a Session Vitals card (on/off, plus 100/50/10% sampling presets), and each project gains a vitals retention setting. An hourly sweeper removes vitals past the retention window.
• Billing. Both checkout flows — subscriptions and credit packs — now enable Stripe Tax, collect the customer’s address and name, and collect VAT IDs so EU business customers can be reverse-charged instead of paying Lithuanian VAT they cannot reclaim. Subscription changes were reworked: upgrades prorate and charge immediately, downgrades take effect at the end of the current period, cancellation now distinguishes “will end on a date” from “ended”, and cards needing reauthorization are handled.
• Mobile layout fixes across the dashboard.

For developers

Enabling Session Vitals. Vitals are off until switched on per app in the dashboard, and the dashboard is the source of truth: local SDK configuration can only opt out or lower the sample rate, never enable what the dashboard has off. Per-app settings are vitalsEnabled and vitalsSampleRate; per-project retention is configurable from 1 to 365 days, defaulting to 30. Data is ingested at POST /api/ingest/vitals under its own rate limits, and a disabled app is silently dropped rather than erroring. Configuration is only emitted to SDKs that advertise the vitals feature, so older SDKs are unaffected.

Web and React.

• trackPlayer(opts) returns a handle and never throws; pass { hls } or { shaka } to attach the corresponding integration. Plain media elements are tracked automatically with no call at all.
• trackVitals(name, data) writes a custom entry onto the session timeline. Payloads are capped at 2 KB serialised and truncated rather than dropped.
• React adds useTrackPlayer(ref, opts). Declare it before the effect that calls loadSource()/load() so the integration’s startup baseline is attached before the library emits its first event.
• Neither hls.js nor Shaka is a dependency or peer dependency; any 1.x/4.x/5.x instance you already have works.
• Modal gains a deferAutoFocus option, used by the reporter to leave focus on the host page until after capture.

React Native.

• trackPlayer(), trackVitals() and useTrackPlayer() mirror the web surface, backed by a new player bridge.
• A vitals config object accepts enabled, sampleRate and captureSourceQuery. An out-of-range sampleRate is dropped with a development warning rather than failing SDK start.
• Adapters ship as separate entry points: integrations/react-native-video (targets v7’s headless VideoPlayer; error capture is opt-in via captureErrors) and integrations/theoplayer. Neither library is a dependency — the adapters use structural types only.

Android.

• traceitx-core moves to 0.8.0 and gains trackPlayer / trackVitals.
• Media3/ExoPlayer tracking lives in a new artifact, com.traceitx:media3:0.8.0, used as TraceItX.trackPlayer(exoPlayer). It is built against Media3 1.8.0; 1.11 is not yet supported because it requires compileSdk 36.
• Native video replay requires Android 10 (API 29). Reporting works as before on older supported versions, without replay.
• The Android tree-replay producers are retired in favour of native video. Previously recorded tree replays remain readable in the dashboard.

iOS and tvOS.

• TraceItX.shared.trackPlayer(_:name:) tracks an AVPlayer. Everything ships inside TraceItXKit — there is no new xcframework, subspec, SwiftPM product or Xcode target to add.
• VitalsConfig exposes enabled, sampleRate and captureSourceQuery.
• The iOS tree replay implementation is removed and replaced by native video replay. Web rrweb replay is unchanged.

Admin API paging. The Errors, Reports, Sessions and People list endpoints accept a page parameter and return total plus totalIsLowerBound. Totals are capped at 10,000. The existing cursor parameter continues to work unchanged; sending both page and cursor in one request returns a 400.

iOS packaging fix: the distributed xcframeworks now carry a proper version string, so apps embedding the iOS SDK pass App Store validation. Binary-only repackage — no API changes.

The 0.4.x line, June 2026. Reliability and screenshot-fidelity improvements across the JS SDKs, including a new screenshot engine that preserves nested scroll positions without touching the live page, so captures match exactly what the user was looking at.

Simpler reporter API for the JS SDKs: useTraceItX().open() is now the single entry point and resolves with the submit outcome (submitted, queued, or cancelled), so you can react to what happened after a report is sent. This was a breaking change — see the migration notes in the release.

The big one. Full annotation tooling landed across every platform:

• Annotation tools — pen, blur, and arrow with undo/redo, on web, Android, and iOS.
• Tablet two-pane reporter — screenshot and form side by side on larger screens.
• React Native Fabric (RN ≥ 0.80, including tvOS) supported out of the box.

First public release — capture, the AI-ready envelope, and signed webhook delivery across the initial SDKs.