@dynatrace/rum-javascript-sdk 1.333.15 → 1.337.1

package/docs/4-useractions.md

@@ -11,12 +11,24 @@ The User Actions API provides fine-grained control over user action creation and
 The User Actions API is experimental and may change in future releases. The `dynatrace.userActions` property is `undefined` if the User Actions module is disabled.
 :::
 
+:::caution Deprecated names
+The following API names have been renamed to align with the Mobile agent API. The old names continue to work but are deprecated and will be removed with version 341:
+
+| Deprecated | Replacement |
+|------------|-------------|
+| `finish()` | `complete()` |
+| `autoClose` | `completeAutomatically` |
+| `name` | `customName` |
+
+The same applies to `UserActionStartOptions`: use `completeAutomatically` instead of `autoClose` and `customName` instead of `name`. If both old and new names are provided, the **new name takes precedence**.
+:::
+
 ## What you can do
 
 With the User Actions API, you can:
 
 - **Create** custom user actions to track specific workflows
-- **Control** when user actions start and finish
+- **Control** when user actions start and complete
 - **Customize** user action names for better identification
 - **Attach** custom properties to capture business context
 - **Adjust** timing by setting the start time
@@ -51,7 +63,7 @@ User actions can complete for various reasons, indicated by the `user_action.com
 
 - **`completed`** - The user action completed normally after the inactivity threshold was reached. This occurs when Dynatrace detects no more activity (DOM mutations, requests, etc.) related to the user interaction.
 
-- **`completed_by_api`** - The user action was completed explicitly by calling the `finish()` function through the API.
+- **`completed_by_api`** - The user action was completed explicitly by calling the `complete()` function through the API.
 
 - **`interrupted_by_api`** - The user action was interrupted when a new user action was created via the API using `create()`.
 
@@ -75,7 +87,7 @@ Access the API directly through the global `dynatrace.userActions` namespace:
 
 ```typescript
 const userAction = dynatrace?.userActions?.create();
-userAction?.finish();
+userAction?.complete();
 ```
 
 This approach requires optional chaining (`?.`) to handle cases where RUM JavaScript or the module is not loaded.
@@ -87,9 +99,9 @@ Use the safe wrapper functions from `@dynatrace/rum-javascript-sdk/api` that gra
 ```typescript
 import { create } from '@dynatrace/rum-javascript-sdk/api/user-actions';
 
-const userAction = create({ autoClose: false });
+const userAction = create({ completeAutomatically: false });
 // No need for optional chaining - returns undefined if module is unavailable
-userAction?.finish();
+userAction?.complete();
 ```
 
 ### Async API
@@ -100,9 +112,9 @@ Use the promise-based API from `@dynatrace/rum-javascript-sdk/api/promises` when
 import { create } from '@dynatrace/rum-javascript-sdk/api/promises/user-actions';
 
 try {
-    const userAction = await create({ autoClose: false });
+    const userAction = await create({ completeAutomatically: false });
     // Guaranteed to have a user action or will throw
-    userAction.finish();
+    userAction.complete();
 } catch (error) {
     console.error('User Actions module not available:', error);
 }
@@ -118,7 +130,7 @@ You can create custom user actions to track specific interactions or workflows i
 
 ### Basic user action
 
-Create a simple user action and finish it manually:
+Create a simple user action and complete it manually:
 
 ```typescript
 // Create a new user action with default settings
@@ -127,16 +139,16 @@ const userAction = dynatrace.userActions?.create();
 // Perform your application logic here
 performSomeWork();
 
-// Manually finish the user action
-userAction?.finish();
+// Manually complete the user action
+userAction?.complete();
 ```
 
 By default, user actions are automatically closed when Dynatrace detects that the action is complete according to the RUM JavaScript user action [rules](#rules).
 
 :::caution
-Calling `finish()` is reliable in this case because `performSomeWork()` is synchronous. If it was awaited, there is no
-guarantee that the action would still be open when `finish()` is called, leading to unreliable action durations. See
-(User action with manual control)[#user-action-with-manual-control] below.
+Calling `complete()` is reliable in this case because `performSomeWork()` is synchronous. If it was awaited, there is no
+guarantee that the action would still be open when `complete()` is called, leading to unreliable action durations. See
+[User action with manual control](#user-action-with-manual-control) below.
 :::
 
 ### User action with manual control
@@ -144,19 +156,19 @@ guarantee that the action would still be open when `finish()` is called, leading
 Disable automatic closing to maintain full control over when the user action completes:
 
 ```typescript
-// Create a user action that won't auto-close
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+// Create a user action that won't auto-complete
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 // Execute async operations
 await fetchData();
 await processResults();
 
-// Finish the user action when ready
-userAction?.finish();
+// Complete the user action when ready
+userAction?.complete();
 ```
 
 :::warning
-When `autoClose` is set to `false`, you must call `finish()` manually. Otherwise, the user action will remain open until the next user action is created or the maximum duration is reached, which may lead to incorrect timing measurements.
+When `completeAutomatically` is set to `false`, you must call `complete()` manually. Otherwise, the user action will remain open until the next user action is created or the maximum duration is reached, which may lead to incorrect timing measurements.
 :::
 
 ### Track user action completion
@@ -164,19 +176,19 @@ When `autoClose` is set to `false`, you must call `finish()` manually. Otherwise
 Subscribe to user action completion events to understand when actions would have been completed automatically:
 
 ```typescript
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 // Subscribe to completion events
 const unsubscribe = userAction?.subscribe(currentUserAction => {
-    // This is just an informational log - we intentionally ignore automatic closing. We finish the user action manually later on.
+    // This is just an informational log - we intentionally ignore automatic closing. We complete the user action manually later on.
     console.log(`User action would have been completed automatically`);
 });
 
 // Perform your operations
 await router.navigate('/home');
 
-// Finish the user action
-userAction?.finish();
+// Complete the user action
+userAction?.complete();
 
 // Clean up the subscription when done
 unsubscribe?.();
@@ -187,17 +199,17 @@ unsubscribe?.();
 Set a custom name for your user action to make it more identifiable in Dynatrace:
 
 ```typescript
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 // Set a descriptive name
 if (userAction) {
-    userAction.name = 'Checkout Flow - Payment Processing';
+    userAction.customName = 'Checkout Flow - Payment Processing';
 }
 
 // Perform payment processing
 await processPayment();
 
-userAction?.finish();
+userAction?.complete();
 ```
 
 ### Add custom properties
@@ -286,14 +298,14 @@ Change how user actions behave by modifying their properties:
 ```typescript
 dynatrace.userActions?.subscribe(userAction => {
     // Disable automatic completion for all user actions
-    userAction.autoClose = false;
+    userAction.completeAutomatically = false;
     
     // Perform custom logic
     performCustomTracking(userAction);
     
     // Manually control completion
     setTimeout(() => {
-        userAction.finish();
+        userAction.complete();
     }, 5000);
 });
 ```
@@ -305,18 +317,18 @@ Apply different behavior based on the user action context:
 ```typescript
 dynatrace.userActions?.subscribe(userAction => {
     // Only modify actions with name Add to Cart
-    if (userAction.name === 'Add to Cart') {
-        userAction.autoClose = false;
+    if (userAction.customName === 'Add to Cart') {
+        userAction.completeAutomatically = false;
         
         // Add custom completion logic
         whenCustomConditionMet().then(() => {
-            userAction.finish();
+            userAction.complete();
         });
     }
 });
 
 // some time later
-dynatrace.userActions?.create({ name: "Add to Cart"});
+dynatrace.userActions?.create({ customName: "Add to Cart"});
 ```
 
 ## Disable automatic detection
@@ -331,13 +343,13 @@ dynatrace.userActions?.setAutomaticDetection(false);
 
 // Now you have full control over user action creation
 async function handleNavigation(route) {
-    const userAction = dynatrace.userActions?.create({ autoClose: false });
+    const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
     
     // Navigate without triggering automatic user action
     await router.navigate(route);
     
-    // Manually finish when ready
-    userAction?.finish();
+    // Manually complete when ready
+    userAction?.complete();
 }
 ```
 
@@ -364,14 +376,14 @@ async function postMessage(message, channel) {
     
     if (currentUserAction) {
         // Prevent automatic completion
-        currentUserAction.autoClose = false;
+        currentUserAction.completeAutomatically = false;
     }
     
     // Perform async operation
     const response = await channel.send(message);
     
-    // Manually finish the user action
-    currentUserAction?.finish();
+    // Manually complete the user action
+    currentUserAction?.complete();
     
     return response;
 }
@@ -390,13 +402,13 @@ document.addEventListener('click', async (event) => {
     const target = event.target as HTMLElement;
     
     if (target.matches('[data-navigate]')) {
-        const userAction = dynatrace.userActions?.create({ autoClose: false });
+        const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
         
         const route = target.getAttribute('data-navigate');
         
         // Set custom name and properties
         if (userAction) {
-            userAction.name = `Navigate to ${route}`;
+            userAction.customName = `Navigate to ${route}`;
             userAction.event_properties = {
                 'event_properties.target_route': route,
                 'event_properties.navigation_trigger': 'click'
@@ -409,8 +421,8 @@ document.addEventListener('click', async (event) => {
         // Wait for the route to fully load
         await waitForRouteReady();
         
-        // Now finish the user action
-        userAction?.finish();
+        // Now complete the user action
+        userAction?.complete();
     }
 });
 ```
@@ -422,11 +434,11 @@ Create a user action that spans multiple asynchronous operations:
 ```typescript
 async function handleComplexWorkflow(workflowId: string, priority: string) {
     const startTime = Date.now();
-    const userAction = dynatrace.userActions?.create({ autoClose: false });
+    const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
     
     if (userAction) {
         // Set up user action metadata
-        userAction.name = 'Complex Data Workflow';
+        userAction.customName = 'Complex Data Workflow';
         userAction.startTime = startTime;
         userAction.event_properties = {
             'event_properties.workflow_id': workflowId,
@@ -486,7 +498,7 @@ async function handleComplexWorkflow(workflowId: string, priority: string) {
         }
     } finally {
         // make sure to complete the user action in any case
-        userAction?.finish();
+        userAction?.complete();
     }
 }
 ```
@@ -504,18 +516,18 @@ await loadConfiguration();
 await initializeServices();
 
 // Create the user action and set the start time
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 if (userAction) {
     // Set the start time to when the actual work began
     userAction.startTime = actualStartTime;
-    userAction.name = 'Data Processing Operation';
+    userAction.customName = 'Data Processing Operation';
 }
 
 // Perform the actual measured work
 await processData();
 
-userAction?.finish();
+userAction?.complete();
 ```
 
 ### Handle framework-specific routing
@@ -537,12 +549,12 @@ function useManualUserActionTracking() {
     }, []);
     
     const trackedNavigate = async (path: string) => {
-        // Don't use autoClose here to allow Dynatrace to determine when the navigation is complete
+        // Don't use completeAutomatically here to allow Dynatrace to determine when the navigation is complete
         const userAction = dynatrace.userActions?.create();
         
         // Add metadata if provided
         if (userAction) {
-            userAction.name = `Route: ${path}`;
+            userAction.customName = `Route: ${path}`;
             userAction.event_properties = {
                 'event_properties.route': path,
                 'event_properties.previous_route': location.pathname
@@ -569,10 +581,10 @@ class CheckoutTracker {
         // Record the actual start time
         const checkoutStartTime = Date.now();
         
-        this.checkoutAction = dynatrace.userActions?.create({ autoClose: false });
+        this.checkoutAction = dynatrace.userActions?.create({ completeAutomatically: false });
         
         if (this.checkoutAction) {
-            this.checkoutAction.name = 'Checkout Process';
+            this.checkoutAction.customName = 'Checkout Process';
             this.checkoutAction.startTime = checkoutStartTime;
             this.checkoutAction.event_properties = {
                 'event_properties.cart_id': cart.id,
@@ -630,7 +642,7 @@ class CheckoutTracker {
                 checkout_status: 'success'
             });
             
-            this.checkoutAction.finish();
+            this.checkoutAction.complete();
             this.checkoutAction = undefined;
         }
     }
@@ -642,7 +654,7 @@ class CheckoutTracker {
                 cancellation_reason: reason
             });
             
-            this.checkoutAction.finish();
+            this.checkoutAction.complete();
             this.checkoutAction = undefined;
         }
     }
@@ -697,11 +709,11 @@ function createTrackedAction() {
 
 ### Finish user actions in finally blocks
 
-Ensure user actions are always finished if `autoClose` is `false`, even when errors occur:
+Ensure user actions are always completed if `completeAutomatically` is `false`, even when errors occur:
 
 ```typescript
 async function performTrackedOperation() {
-    const userAction = dynatrace.userActions?.create({ autoClose: false });
+    const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
     
     try {
         await riskyOperation();
@@ -709,8 +721,8 @@ async function performTrackedOperation() {
         console.error('Operation failed:', error);
         throw error;
     } finally {
-        // Always finish the user action
-        userAction?.finish();
+        // Always complete the user action
+        userAction?.complete();
     }
 }
 ```
@@ -730,11 +742,11 @@ input.addEventListener('keypress', () => {
 let userAction: UserActionTracker | undefined;
 
 input.addEventListener('focus', () => {
-    userAction = dynatrace.userActions?.create({ autoClose: false });
+    userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 });
 
 input.addEventListener('blur', () => {
-    userAction?.finish();
+    userAction?.complete();
     userAction = undefined;
 });
 ```
@@ -805,7 +817,7 @@ If your user actions aren't appearing in Dynatrace:
 
 1. Verify that the User Actions module is enabled
 2. Check that `dynatrace.userActions` is defined
-3. Ensure you're calling `finish()` on user actions with `autoClose: false`
+3. Ensure you're calling `complete()` on user actions with `completeAutomatically: false`
 4. Check browser console for any errors
 
 ### User actions completing too early
@@ -813,8 +825,8 @@ If your user actions aren't appearing in Dynatrace:
 If user actions are completing before your operations finish:
 
 ```typescript
-// Ensure autoClose is set to false
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+// Ensure completeAutomatically is set to false
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 // Make sure to await all async operations
 await Promise.all([
@@ -823,8 +835,8 @@ await Promise.all([
     operation3()
 ]);
 
-// Then finish
-userAction?.finish();
+// Then complete
+userAction?.complete();
 ```
 
 ### Conflicts with automatic detection
@@ -849,11 +861,11 @@ If custom properties aren't showing up:
 1. Check the console logs in your browser for any issues related to Dynatrace SDK usage.
 2. Ensure property keys start with `event_properties.` prefix
 3. Verify the property values are of supported types (string, number, boolean)
-4. Check that properties are set before calling `finish()`
+4. Check that properties are set before calling `complete()`
 5. Make sure the user action state is `'active'` when setting properties
 
 ```typescript
-const userAction = dynatrace.userActions?.create({ autoClose: false });
+const userAction = dynatrace.userActions?.create({ completeAutomatically: false });
 
 if (userAction) {
     // ✅ Correct: Using proper prefix and supported types
@@ -867,7 +879,7 @@ if (userAction) {
     console.log('User action state:', userAction.state);
     
     // Complete the action
-    userAction.finish();
+    userAction.complete();
 }
 ```
 
@@ -889,8 +901,8 @@ Creates a new user action. Returns `undefined` if the module is not available.
 ```typescript
 import { create } from '@dynatrace/rum-javascript-sdk/api/user-actions';
 
-const userAction = create({ autoClose: false });
-userAction?.finish();
+const userAction = create({ completeAutomatically: false });
+userAction?.complete();
 ```
 
 **`subscribe(subscriber): Unsubscriber | undefined`**
@@ -925,7 +937,7 @@ import { getCurrent } from '@dynatrace/rum-javascript-sdk/api/user-actions';
 
 const current = getCurrent();
 if (current) {
-    current.autoClose = false;
+    current.completeAutomatically = false;
 }
 ```
 
@@ -941,8 +953,8 @@ Creates a new user action, waiting up to `timeout` ms (default: 10000) for the m
 import { create } from '@dynatrace/rum-javascript-sdk/api/promises/user-actions';
 
 try {
-    const userAction = await create({ autoClose: false });
-    userAction.finish();
+    const userAction = await create({ completeAutomatically: false });
+    userAction.complete();
 } catch (error) {
     console.error('User Actions module not available');
 }
@@ -960,13 +972,16 @@ All async functions follow the same pattern, accepting an optional `timeout` par
 
 | Property | Type                                          | Access | Description |
 |----------|-----------------------------------------------|--------|-------------|
-| `finish()` | Function                                      | - | Completes the user action and sends the event |
+| `complete()` | Function                                      | - | Completes the user action and sends the event |
+| `finish()` | Function                                      | - | **Deprecated.** Use `complete()` instead |
 | `subscribe(callback)` | Function                                      | - | Subscribes to automatic completion events |
-| `autoClose` | `boolean`                                     | Get/Set | Controls whether the action closes automatically |
+| `completeAutomatically` | `boolean`                                     | Get/Set | Controls whether the action completes automatically |
+| `autoClose` | `boolean`                                     | Get/Set | **Deprecated.** Use `completeAutomatically` instead |
 | `state` | `'active' \| 'complete'`                      | Get | Returns the current state of the user action |
 | `event_properties` | `Record<string, string \| number \| boolean>` | Get/Set | Custom properties for business context |
 | `startTime` | `number`                                      | Get/Set | Start time in milliseconds (must not be in future) |
-| `name` | `string \| undefined`                         | Get/Set | Display name for the user action |
+| `customName` | `string \| undefined`                         | Get/Set | Display name for the user action |
+| `name` | `string \| undefined`                         | Get/Set | **Deprecated.** Use `customName` instead |
 
 ### Key types and interfaces
 
@@ -977,7 +992,10 @@ All async functions follow the same pattern, accepting an optional `timeout` par
   - `current` - Access the currently active user action
 - `UserActionTracker` - Represents an individual user action (see properties table above)
 - `UserActionStartOptions` - Configuration options for creating user actions
-  - `autoClose?: boolean` - Whether the action should close automatically (default: `true`)
+  - `completeAutomatically?: boolean` - Whether the action should complete automatically (default: `true`)
+  - `autoClose?: boolean` - **Deprecated.** Use `completeAutomatically` instead
+  - `customName?: string` - A human-readable custom name to identify the user action
+  - `name?: string` - **Deprecated.** Use `customName` instead
 - `Unsubscriber` - Function type `() => void` for unsubscribing from events
 
 ## Additional resources

package/docs/5-interactions.md

@@ -0,0 +1,85 @@
+---
+title: Interactions API
+---
+# Interactions API
+
+This guide explains how to report custom interaction events that are not automatically detected.
+
+## What you can do
+
+- Report custom keyboard shortcuts or key combinations via `sendKeyPressEvent`
+- Attach `ui_element.custom_name` and `event_properties.*` fields
+- Provide an `Element` or `KeyboardEvent` to capture UI element fields
+
+## Prerequisites
+
+- New RUM Experience is enabled for your application
+
+## API approaches
+
+You can use the Interactions API directly, or via its synchronous or asynchronous SDK functions, matching the pattern established in the [RUM JavaScript SDK Overview](./1-overview.md):
+
+### Direct API (via `dynatrace.interactions`)
+
+```typescript
+dynatrace?.interactions?.sendKeyPressEvent({
+    keys: ["A"]
+});
+```
+
+### Safe Wrapper API (recommended)
+
+```typescript
+import * as interactions from "@dynatrace/rum-javascript-sdk/api/interactions";
+import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+
+interactions.sendKeyPressEvent({
+    keys: [UserInteractionSpecialKey.CTRL, "S"],
+    "event_properties.context": "editor"
+});
+```
+
+### Async API
+
+```typescript
+import { sendKeyPressEvent } from "@dynatrace/rum-javascript-sdk/api/promises/interactions";
+import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+
+await sendKeyPressEvent({
+    keys: [UserInteractionSpecialKey.CTRL, "S"]
+});
+```
+
+## `UserInteractionSpecialKey`
+
+The {@link UserInteractionSpecialKey} enum provides normalized string representations for specific [`KeyboardEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) values (e.g. `" "` → `"space"`, `"Control"` → `"ctrl"`, `"Escape"` → `"esc"`, `"ArrowUp"` → `"arrow_up"`).
+
+Using this enum is **optional** — raw [`KeyboardEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) values are also accepted and normalized internally. The enum is a convenience for readability, especially when constructing key arrays manually without a real keyboard event.
+
+```typescript
+import { UserInteractionSpecialKey } from "@dynatrace/rum-javascript-sdk/types/rum-events";
+
+// Modifier + regular key
+dynatrace.interactions?.sendKeyPressEvent({
+    keys: [UserInteractionSpecialKey.CTRL, "S"]
+});
+
+// Single special key
+dynatrace.interactions?.sendKeyPressEvent({
+    keys: [UserInteractionSpecialKey.ESC]
+});
+
+// Regular key (passed as its KeyboardEvent.key value)
+dynatrace.interactions?.sendKeyPressEvent({
+    keys: ["a"]
+});
+```
+
+## sendKeyPressEvent
+
+`sendKeyPressEvent(fields, elementOrEvent?)` reports a custom key_press interaction.
+
+- `fields` must be a JSON-serializable object with a non-empty `keys` array.
+- Keys can be [`UserInteractionSpecialKey`](#userinteractionspecialkey) members or raw [`KeyboardEvent.key`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) strings — raw values are normalized internally.
+- Optional `ui_element.custom_name` and `event_properties.*` entries are allowed.
+- `elementOrEvent` may be an [`Element`](https://developer.mozilla.org/en-US/docs/Web/API/Element) or [`KeyboardEvent`](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent) to derive UI element fields. If omitted, no UI element fields are added.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace/rum-javascript-sdk",
-  "version": "1.333.15",
+  "version": "1.337.1",
   "description": "JavaScript API for Real User Monitoring (RUM)",
   "sideEffects": false,
   "type": "module",
@@ -13,12 +13,18 @@
       "api/user-actions": [
         "./dist/api/user-actions.d.ts"
       ],
+      "api/interactions": [
+        "./dist/api/interactions.d.ts"
+      ],
       "api/promises": [
         "./dist/api/promises/index.d.ts"
       ],
       "api/promises/user-actions": [
         "./dist/api/promises/user-actions.d.ts"
       ],
+      "api/promises/interactions": [
+        "./dist/api/promises/interactions.d.ts"
+      ],
       "test": [
         "./dist/testing/index.d.ts"
       ],
@@ -63,11 +69,21 @@
       "import": "./dist/api/user-actions.js",
       "default": "./dist/api/user-actions.js"
     },
+    "./api/interactions": {
+      "types": "./dist/api/interactions.d.ts",
+      "import": "./dist/api/interactions.js",
+      "default": "./dist/api/interactions.js"
+    },
     "./api/promises/user-actions": {
       "types": "./dist/api/promises/user-actions.d.ts",
       "import": "./dist/api/promises/user-actions.js",
       "default": "./dist/api/promises/user-actions.js"
     },
+    "./api/promises/interactions": {
+      "types": "./dist/api/promises/interactions.d.ts",
+      "import": "./dist/api/promises/interactions.js",
+      "default": "./dist/api/promises/interactions.js"
+    },
     "./api/promises": {
       "types": "./dist/api/promises/index.d.ts",
       "import": "./dist/api/promises/index.js",
@@ -131,15 +147,15 @@
   "license": "ISC",
   "devDependencies": {
     "@types/node": "25.0.3",
-    "@vitest/coverage-v8": "4.1.0-beta.1",
-    "@vitest/ui": "4.1.0-beta.1",
+    "@vitest/coverage-v8": "4.1.0",
+    "@vitest/ui": "4.1.0",
     "eslint": "9.38.0",
-    "jsdom": "27.0.1",
-    "knip": "5.27.0",
-    "typedoc": "0.28.10",
-    "typedoc-plugin-mdn-links": "5.0.3",
+    "jsdom": "29.0.1",
+    "knip": "5.85.0",
+    "typedoc": "0.28.17",
+    "typedoc-plugin-mdn-links": "5.1.1",
     "typescript": "5.8.2",
-    "vitest": "4.1.0-beta.1"
+    "vitest": "4.1.0"
   },
   "scripts": {
     "build:lib": "tsc -b tsconfig.build.json",