WormaCeptor

https://wormaceptor.com/docs
Admin
WormaCeptor is an on-device Android debugging toolkit providing network inspection, performance...
Tokens:12,246
Snippets:137
Trust Score:2.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Before: Chucker Interceptor Setup

Source: https://wormaceptor.com/docs/migration/from-chucker

Configures OkHttp with ChuckerInterceptor using the Builder pattern, a collector, max content length, header redaction, and alwaysReadResponseBody. This is the original setup being replaced.

```kotlin
val client = OkHttpClient.Builder()
    .addInterceptor(
        ChuckerInterceptor.Builder(context)
            .collector(ChuckerCollector(context))
            .maxContentLength(250_000L)
            .redactHeaders("Authorization")
            .alwaysReadResponseBody(true)
            .build()
    )
    .build()
```

--------------------------------

### Launch via Intent

Source: https://wormaceptor.com/docs/launching-ui

Starts the WormaCeptor UI manually from a button, menu item, or any trigger.

```kotlin
startActivity(WormaCeptorApi.getLaunchIntent(context))
```

--------------------------------

### Install WormaCeptorKtorPlugin on HttpClient

Source: https://wormaceptor.com/docs/ktor

Install the WormaCeptor Ktor plugin on an HttpClient to capture HTTP traffic. Configure maxContentLength (default 250,000), retainDataFor (default null), and redaction methods that delegate to the global WormaCeptorApi.redactionConfig.

```kotlin
val client = HttpClient(CIO) {
    install(WormaCeptorKtorPlugin) {
        maxContentLength = 500_000L
        retainDataFor = WormaCeptorKtorConfig.RetentionPeriod.ONE_WEEK
        redactHeader("Authorization")
        redactJsonValue("password")
        redactXmlValue("apiKey")
    }
}
```

--------------------------------

### After: WormaCeptor Interceptor Setup

Source: https://wormaceptor.com/docs/migration/from-chucker

Configures OkHttp with WormaCeptorInterceptor using direct method chaining, no Builder or context, and enables notification and max content length. alwaysReadResponseBody is the default behavior.

```kotlin
val client = OkHttpClient.Builder()
    .addInterceptor(
        WormaCeptorInterceptor()
            .showNotification(true)
            .maxContentLength(250_000L)
            .redactHeader("Authorization")
    )
    .build()
```

--------------------------------

### Programmatic Deep Links with DeepLinkHandler

Source: https://wormaceptor.com/docs/deep-links

Use to open a specific WormaCeptor tool or tab programmatically. The first line creates an intent for a tool deep link and starts an activity; the helper methods return URIs for a tool, the Tools tab, and the Transactions tab. Unrecognized tool paths fall back to the Tools tab.

```kotlin
// Open a specific tool
val intent = DeepLinkHandler.createIntent(context, "wormaceptor://tools/memory")
startActivity(intent)

// Or use helper methods
val uri = DeepLinkHandler.createToolDeepLink("memory")      // "wormaceptor://tools/memory"
val tabUri = DeepLinkHandler.createToolsTabDeepLink()        // "wormaceptor://tools"
val txUri = DeepLinkHandler.createTransactionsTabDeepLink()  // "wormaceptor://transactions"
```

--------------------------------

### Runtime Queries: Check and Get Enabled Features

Source: https://wormaceptor.com/docs/feature-toggles

Use WormaCeptorApi.isFeatureEnabled() to check if a specific feature is enabled, and WormaCeptorApi.getEnabledFeatures() to retrieve all enabled features as a Set.

```kotlin
// Check if a specific feature is enabled
val leakEnabled: Boolean = WormaCeptorApi.isFeatureEnabled(Feature.LEAK_DETECTION)

// Get all enabled features
val enabled: Set<Feature> = WormaCeptorApi.getEnabledFeatures()
```

--------------------------------

### WormaCeptor Body Redaction Example

Source: https://wormaceptor.com/docs/migration/from-chucker

Shows WormaCeptor's body-level redaction features, which are not supported by Chucker. It redacts headers, JSON fields, XML elements, and body content matching a pattern.

```kotlin
WormaCeptorInterceptor()
    .redactHeader("Authorization")
    .redactHeader("Cookie")
    .redactJsonValue("token")       // Redacts JSON fields named "token"
    .redactXmlValue("apiKey")       // Redacts XML elements named "apiKey"
    .redactBody("pattern")          // Redacts body content matching pattern
```

--------------------------------

### Initialize WormaCeptorApi in Application.onCreate()

Source: https://wormaceptor.com/docs/quick-start

Call WormaCeptorApi.init() as early as possible in your Application.onCreate() to set up WormaCeptor with default features, crash logging, and leak notifications.

```kotlin
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        WormaCeptorApi.init(
            context = this,
            logCrashes = true,
            features = Feature.ALL,
            leakNotifications = true,
        )
    }
}
```

--------------------------------

### Show, check, and hide performance overlay

Source: https://wormaceptor.com/docs/performance-overlay

Use WormaCeptorApi to show the overlay, check its visibility, and hide it. Requires SYSTEM_ALERT_WINDOW permission; showPerformanceOverlay returns false if permission is not granted.

```kotlin
// Show the overlay (requires SYSTEM_ALERT_WINDOW permission)
val shown = WormaCeptorApi.showPerformanceOverlay(activity)

// Check visibility
val isVisible = WormaCeptorApi.isPerformanceOverlayVisible()

// Hide the overlay
WormaCeptorApi.hidePerformanceOverlay()
```

--------------------------------

### Selective Feature Initialization

Source: https://wormaceptor.com/docs/quick-start

Enable only performance and WebSocket monitoring by passing a set of specific features to WormaCeptorApi.init().

```kotlin
// Enable only performance and WebSocket monitoring
WormaCeptorApi.init(
    context = this,
    features = setOf(
        Feature.MEMORY_MONITOR,
        Feature.FPS_MONITOR,
        Feature.CPU_MONITOR,
        Feature.WEBSOCKET_MONITOR,
    ),
)
```

--------------------------------

### RecompositionTracker.getAll()

Source: https://wormaceptor.com/docs/recomposition

Returns a snapshot of every tracked composable.

```APIDOC
## RecompositionTracker.getAll()

### Description
Returns a snapshot of every tracked composable.

### Method
Function call

### Signature
`fun getAll(): Map<String, RecompositionData>`

### Returns
- **Map<String, RecompositionData>** - A map of composable names to their recomposition data.
```

--------------------------------

### createMonitoringClient

Source: https://wormaceptor.com/docs/webview

Creates a monitoring WebViewClient that can be set on a WebView to monitor network requests. Optionally accepts a delegate WebViewClient to wrap.

```APIDOC
## createMonitoringClient(webViewId: String, delegate: WebViewClient?)

### Description
Creates a monitoring WebViewClient that intercepts network requests made by a WebView instance. The delegate parameter allows you to wrap an existing WebViewClient, preserving its behavior while adding monitoring.

### Method
Factory Method

### Endpoint
N/A (SDK method)

### Parameters
- **webViewId** (String) - Required - A unique identifier for the WebView being monitored.
- **delegate** (WebViewClient?) - Optional - An existing WebViewClient to delegate to. If provided, the returned client wraps it.

### Return Value
Returns a WebViewClient instance configured for monitoring.

### Release Build Behavior
When WormaCeptor implementation is not available (e.g., release builds):
- If a `delegate` is provided, it is returned as-is.
- If no `delegate` is provided, a no-op `WebViewClient` is returned.

This allows safe usage of `createMonitoringClient()` in all build types.

```

--------------------------------

### WormaCeptorApi.canShowFloatingButton(context)

Source: https://wormaceptor.com/docs/performance-overlay

Checks the SYSTEM_ALERT_WINDOW permission before showing the overlay.

```APIDOC
## [CHECK] WormaCeptorApi.canShowFloatingButton(context)

### Description
Check the SYSTEM_ALERT_WINDOW permission before showing the performance overlay.

### Method
CHECK

### Endpoint
WormaCeptorApi.canShowFloatingButton(context)

### Parameters
#### Function Parameters
- **context** (Context) - Required - The context used to check the permission.

### Response
#### Success Response
- **Boolean** - `true` if permission granted, `false` otherwise.

#### Response Example
```kotlin
val canShow = WormaCeptorApi.canShowFloatingButton(context)
```

```

--------------------------------

### Before (Chucker) - build.gradle.kts dependencies

Source: https://wormaceptor.com/docs/migration/from-chucker

Chucker dependencies for debug and release builds. Replace these with WormaCeptor dependencies.

```kotlin
debugImplementation("com.github.chuckerteam.chucker:library:4.x.x")
releaseImplementation("com.github.chuckerteam.chucker:library-no-op:4.x.x")
```

--------------------------------

### Create a monitoring WebViewClient with WormaCeptorWebView

Source: https://wormaceptor.com/docs/webview

Use this snippet to monitor network requests from a WebView. It creates a monitoring WebViewClient with an optional delegate and loads a URL. In release builds, if no delegate is provided, a no-op WebViewClient is returned.

```kotlin
val webView: WebView = findViewById(R.id.webview)

webView.webViewClient = WormaCeptorWebView.createMonitoringClient(
    webViewId = "my_webview",
    delegate = myWebViewClient,  // Optional: your existing WebViewClient
)

webView.loadUrl("https://example.com")
```

--------------------------------

### Launch via Shake Gesture in MainActivity.kt

Source: https://wormaceptor.com/docs/launching-ui

Registers a lifecycle-aware shake detector that opens WormaCeptor when the device is shaken. The detector automatically stops when the activity is destroyed.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...
        WormaCeptorApi.startActivityOnShake(this)
    }
}
```

--------------------------------

### Launch via Floating Button

Source: https://wormaceptor.com/docs/launching-ui

Shows a draggable floating button overlay that opens WormaCeptor when tapped. Checks overlay permission first and requests it if needed, then hides the overlay when no longer needed.

```kotlin
// Check permission first
if (WormaCeptorApi.canShowFloatingButton(context)) {
    WormaCeptorApi.showFloatingButton(context)
} else {
    // Request overlay permission
    val intent = WormaCeptorApi.getOverlayPermissionIntent(context)
    if (intent != null) {
        startActivity(intent)
    }
}

// Hide when no longer needed
WormaCeptorApi.hideFloatingButton(context)
```

--------------------------------

### Add WormaCeptor dependencies in build.gradle.kts

Source: https://wormaceptor.com/docs/installation

Adds the required client dependency and a debug-only storage backend. Choose one storage backend from the comparison table.

```kotlin
dependencies {
    // Required: API client (lightweight, safe for all build types)
    implementation("com.azikar24.wormaceptor:wormaceptor-client:2.3.1")

    // Debug: Choose one storage backend
    debugImplementation("com.azikar24.wormaceptor:wormaceptor-persistence:2.3.1")
}
```

--------------------------------

### Configure repositories in settings.gradle.kts

Source: https://wormaceptor.com/docs/installation

Shows the default repository configuration for an Android project. If your settings.gradle.kts already includes mavenCentral(), no changes are needed.

```kotlin
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
    }
}
```

--------------------------------

### WormaCeptorApi.showPerformanceOverlay(activity)

Source: https://wormaceptor.com/docs/performance-overlay

Shows the draggable performance overlay. Returns false if the SYSTEM_ALERT_WINDOW permission is not granted.

```APIDOC
## [SHOW] WormaCeptorApi.showPerformanceOverlay(activity)

### Description
Display a draggable overlay showing real-time FPS, Memory, and CPU metrics. Requires SYSTEM_ALERT_WINDOW permission.

### Method
SHOW

### Endpoint
WormaCeptorApi.showPerformanceOverlay(activity)

### Parameters
#### Function Parameters
- **activity** (Activity) - Required - The activity context used to show the overlay.

### Response
#### Success Response
- **Boolean** - `true` if the overlay was shown successfully; `false` if permission not granted.

#### Response Example
```kotlin
val shown = WormaCeptorApi.showPerformanceOverlay(activity)
```

```

--------------------------------

### Register an ExtensionProvider with WormaCeptorApi

Source: https://wormaceptor.com/docs/extension-providers

Registers a custom ExtensionProvider to extract key-value pairs for each network transaction. The priority defaults to 50, with lower values running first. Extracted pairs are stored with each transaction and displayed in the WormaCeptor UI.

```kotlin
WormaCeptorApi.registerExtensionProvider(
    object : ExtensionProvider {
        override val name = "AuthExtension"
        override val priority = 50 // default is 50, lower runs first
        override fun extractExtensions(context: ExtensionContext): Map<String, String> {
            return mapOf(
                "user_id" to getCurrentUserId(),
                "session_type" to getSessionType(),
            )
        }
    },
)
```

--------------------------------

### After (WormaCeptor) - build.gradle.kts dependencies

Source: https://wormaceptor.com/docs/migration/from-chucker

WormaCeptor dependencies from Maven Central. No release no-op artifact is needed; the client auto-discovers the implementation at runtime and falls back to a built-in no-op in release builds.

```kotlin
implementation("com.azikar24.wormaceptor:wormaceptor-client:2.3.1")
debugImplementation("com.azikar24.wormaceptor:wormaceptor-persistence:2.3.1")
```

--------------------------------

### RecompositionTracker.getTopRecomposers(limit)

Source: https://wormaceptor.com/docs/recomposition

Returns the hottest recomposers, sorted by rate.

```APIDOC
## RecompositionTracker.getTopRecomposers(limit)

### Description
Returns the hottest recomposers, sorted by rate.

### Method
Function call

### Signature
`fun getTopRecomposers(limit: Int): List<RecompositionData>`

### Parameters
- **limit** (Int) - Required - The maximum number of recomposers to return.

### Returns
- **List<RecompositionData>** - A list of the top recomposers sorted by rate.
```

--------------------------------

### Add WormaCeptorInterceptor to OkHttpClient in NetworkModule.kt

Source: https://wormaceptor.com/docs

Add the WormaCeptorInterceptor to your OkHttpClient builder to enable network inspection.

```kotlin
val client = OkHttpClient.Builder()
    .addInterceptor(WormaCeptorInterceptor())
    .build()
```

--------------------------------

### ExtensionProvider interface definition

Source: https://wormaceptor.com/docs/extension-providers

Defines the ExtensionProvider interface with a name, priority (default 50, lower runs first), and a method to extract extensions from an ExtensionContext.

```kotlin
interface ExtensionProvider {
    val name: String
    val priority: Int // default 50, lower values run first
    fun extractExtensions(context: ExtensionContext): Map<String, String>
}
```

--------------------------------

### Configure Global Redaction

Source: https://wormaceptor.com/docs/data-redaction

Use WormaCeptorApi.redactionConfig to set global redaction rules for headers, JSON keys, XML tags, and body regex patterns.

```kotlin
WormaCeptorApi.redactionConfig
    .redactHeader("Authorization")
    .redactHeader("Cookie")
    .redactHeader("X-Api-Key")
    .redactJsonValue("password")
    .redactJsonValue("token")
    .redactXmlValue("apiKey")
    .redactBody("api_key=\\w+")       // Regex pattern
    .replacement("[REDACTED]")         // Custom replacement text
```

--------------------------------

### WormaCeptorApi.isPerformanceOverlayVisible()

Source: https://wormaceptor.com/docs/performance-overlay

Checks whether the performance overlay is currently visible.

```APIDOC
## [CHECK] WormaCeptorApi.isPerformanceOverlayVisible()

### Description
Check if the performance overlay is currently visible.

### Method
CHECK

### Endpoint
WormaCeptorApi.isPerformanceOverlayVisible()

### Parameters
None

### Response
#### Success Response
- **Boolean** - `true` if the overlay is visible, `false` otherwise.

#### Response Example
```kotlin
val isVisible = WormaCeptorApi.isPerformanceOverlayVisible()
```

```

--------------------------------

### RecompositionTracker.getRate(name)

Source: https://wormaceptor.com/docs/recomposition

Returns recompositions per second for the given name over the session.

```APIDOC
## RecompositionTracker.getRate(name)

### Description
Returns recompositions per second for the given name over the session.

### Method
Function call

### Signature
`fun getRate(name: String): Float`

### Parameters
- **name** (String) - Required - The name of the composable.

### Returns
- **Float** - Recompositions per second for the given name.
```

--------------------------------

### Configure WormaCeptorInterceptor for OkHttp

Source: https://wormaceptor.com/docs/okhttp

Adds WormaCeptorInterceptor to an OkHttpClient to capture HTTP/HTTPS traffic. Configures notification, max content length, retention period, and redaction for headers, JSON values, and XML values.

```kotlin
val interceptor = WormaCeptorInterceptor()
    .showNotification(true)
    .maxContentLength(500_000L)
    .retainDataFor(WormaCeptorInterceptor.Period.ONE_WEEK)
    .redactHeader("Authorization")
    .redactHeader("Cookie")
    .redactJsonValue("password")
    .redactXmlValue("apiKey")

val client = OkHttpClient.Builder()
    .addInterceptor(interceptor)
    .build()
```

--------------------------------

### RecompositionTracker.getTotalRecompositions()

Source: https://wormaceptor.com/docs/recomposition

Returns the sum of recomposition counts across every tracked composable.

```APIDOC
## RecompositionTracker.getTotalRecompositions()

### Description
Returns the sum of recomposition counts across every tracked composable.

### Method
Function call

### Signature
`fun getTotalRecompositions(): Long`

### Returns
- **Long** - The total number of recompositions across all tracked composables.
```

--------------------------------

### WormaCeptorInterceptor

Source: https://wormaceptor.com/docs/okhttp

Add the WormaCeptorInterceptor to an OkHttp client to capture HTTP/HTTPS traffic. Configure it with builder methods for notifications, content length limits, data retention, and redaction.

```APIDOC
## WormaCeptorInterceptor

### Description
Add `WormaCeptorInterceptor` to your OkHttp client to capture HTTP/HTTPS traffic. Configure it with builder methods for notifications, content length limits, data retention, and redaction.

### Usage Example
```kotlin
val interceptor = WormaCeptorInterceptor()
    .showNotification(true)
    .maxContentLength(500_000L)
    .retainDataFor(WormaCeptorInterceptor.Period.ONE_WEEK)
    .redactHeader("Authorization")
    .redactHeader("Cookie")
    .redactJsonValue("password")
    .redactXmlValue("apiKey")

val client = OkHttpClient.Builder()
    .addInterceptor(interceptor)
    .build()
```

### Builder Methods
All methods return `WormaCeptorInterceptor` for chaining.

#### `showNotification(show: Boolean)`
- **Description**: Enable/disable system notification on capture.
- **Default**: `true`

#### `maxContentLength(length: Long)`
- **Description**: Max body size to capture in bytes.
- **Default**: 250,000

#### `retainDataFor(period: Period)`
- **Description**: Auto-delete transactions older than the specified period.
- **Parameters**:
  - `period` (Period) - Required - The retention period.

#### `redactHeader(name: String)`
- **Description**: Redact a header value (case-insensitive).
- **Parameters**:
  - `name` (String) - Required - The header name to redact.

#### `redactBody(pattern: String)`
- **Description**: Redact body content matching a regex pattern.
- **Parameters**:
  - `pattern` (String) - Required - The regex pattern to match.

#### `redactJsonValue(key: String)`
- **Description**: Redact JSON values by key name.
- **Parameters**:
  - `key` (String) - Required - The JSON key to redact.

#### `redactXmlValue(tag: String)`
- **Description**: Redact XML element content by tag name.
- **Parameters**:
  - `tag` (String) - Required - The XML tag to redact.

### Period Enum
| Value | Duration |
|-------|----------|
| `ONE_HOUR` | 1 hour |
| `ONE_DAY` | 24 hours |
| `ONE_WEEK` | 7 days |
| `ONE_MONTH` | 30 days |
| `FOREVER` | No cleanup |

### Rate Limiting
Both the OkHttp interceptor and Ktor plugin automatically integrate with the Rate Limiter tool. When rate limiting is enabled in the WormaCeptor UI, artificial latency is applied to network calls.
```

--------------------------------

### ExtensionContext data class

Source: https://wormaceptor.com/docs/extension-providers

Provides access to the request, response, request duration, and timestamp for each transaction.

```kotlin
data class ExtensionContext(
    val request: Request,
    val response: Response?,
    val durationMs: Long?,
    val timestamp: Long,
)
```

--------------------------------

### RecompositionTracker.reset()

Source: https://wormaceptor.com/docs/recomposition

Clears all tracking data and resets the session timer.

```APIDOC
## RecompositionTracker.reset()

### Description
Clears all tracking data and resets the session timer.

### Method
Function call

### Signature
`fun reset()`

### Returns
- **Unit** - No return value.
```

--------------------------------

### Read recomposition data with RecompositionTracker

Source: https://wormaceptor.com/docs/recomposition

Access recomposition tracking data programmatically outside the Recomposition Inspector UI. Available in debug builds only. Provides total recompositions, top recomposers, rate per name, and reset functionality.

```kotlin
import com.azikar24.wormaceptor.core.ui.RecompositionTracker

val total = RecompositionTracker.getTotalRecompositions()
val top = RecompositionTracker.getTopRecomposers(limit = 5)
val rate = RecompositionTracker.getRate("ProductCard")

RecompositionTracker.reset()
```

--------------------------------

### RecompositionTracker.getSessionDuration()

Source: https://wormaceptor.com/docs/recomposition

Returns milliseconds since the first recorded event, or 0 before any.

```APIDOC
## RecompositionTracker.getSessionDuration()

### Description
Returns milliseconds since the first recorded event, or 0 before any.

### Method
Function call

### Signature
`fun getSessionDuration(): Long`

### Returns
- **Long** - Milliseconds since the first recorded event, or 0 before any.
```

--------------------------------

### Add Ktor dependency with compileOnly in build.gradle.kts

Source: https://wormaceptor.com/docs/ktor

Add the Ktor client core dependency as compileOnly in build.gradle.kts to avoid adding Ktor to apps that only use OkHttp. The Ktor plugin classes live in the wormaceptor-client module.

```kotlin
compileOnly("io.ktor:ktor-client-core:<ktor-version>")
```

--------------------------------

### WormaCeptorApi.hidePerformanceOverlay()

Source: https://wormaceptor.com/docs/performance-overlay

Hides the performance overlay if it is currently visible.

```APIDOC
## [HIDE] WormaCeptorApi.hidePerformanceOverlay()

### Description
Hide the draggable performance overlay.

### Method
HIDE

### Endpoint
WormaCeptorApi.hidePerformanceOverlay()

### Parameters
None

### Response
#### Success Response
- **Unit** - No return value.

#### Response Example
```kotlin
WormaCeptorApi.hidePerformanceOverlay()
```

```

--------------------------------

### Wrap WebSocketListener and Record Sent Messages

Source: https://wormaceptor.com/docs/websocket

Use WormaCeptorWebSocket.wrap to wrap a WebSocketListener for monitoring. OkHttp interceptors don't capture WebSocket traffic, so this wrapper is necessary. The wrapped listener is passed to client.newWebSocket, and sent messages are manually recorded using recordSentMessage because OkHttp doesn't notify listeners of outgoing messages.

```kotlin
val listener = object : WebSocketListener() {
    override fun onMessage(webSocket: WebSocket, text: String) {
        // Handle received message
    }
}

// Wrap your listener for monitoring
val monitor = WormaCeptorWebSocket.wrap(listener, "wss://example.com/ws")

// Use the wrapped listener with OkHttp
val request = Request.Builder().url("wss://example.com/ws").build()
val webSocket = client.newWebSocket(request, monitor.listener)

// Record sent messages (OkHttp doesn't notify listeners of outgoing messages)
webSocket.send(message)
monitor.recordSentMessage(message)
```

--------------------------------

### Tag a composable with Modifier.trackRecomposition

Source: https://wormaceptor.com/docs/recomposition

Opt a composable into recomposition tracking by applying the trackRecomposition modifier. The modifier records a recomposition event each time the host composable recomposes.

```kotlin
import com.azikar24.wormaceptor.core.ui.trackRecomposition

@Composable
fun ProductCard(product: Product) {
    Card(modifier = Modifier.trackRecomposition("ProductCard")) {
        // ...
    }
}
```

--------------------------------

### RecompositionTracker.record(name)

Source: https://wormaceptor.com/docs/recomposition

Manually records a recomposition. Usually invoked by the modifier.

```APIDOC
## RecompositionTracker.record(name)

### Description
Manually records a recomposition. Usually invoked by the modifier.

### Method
Function call

### Signature
`fun record(name: String)`

### Parameters
- **name** (String) - Required - The name of the composable to record.

### Returns
- **Unit** - No return value.
```

--------------------------------

### Release no-op trackRecomposition extension

Source: https://wormaceptor.com/docs/recomposition

Provide a no-op implementation of trackRecomposition for release builds. This makes the modifier a no-op with zero runtime cost in release.

```kotlin
fun Modifier.trackRecomposition(name: String): Modifier = this
```

--------------------------------

### Modifier.trackRecomposition(name)

Source: https://wormaceptor.com/docs/recomposition

Records a recomposition event each time the host composable recomposes. Use this modifier on composables you want to track.

```APIDOC
## Modifier.trackRecomposition(name)

### Description
Records a recomposition event each time the host composable recomposes. Use this modifier on composables you want to track.

### Method
Modifier extension function

### Signature
`fun Modifier.trackRecomposition(name: String): Modifier`

### Parameters
- **name** (String) - Required - The name to associate with the composable for tracking.

### Returns
- **Modifier** - The modified Modifier that records recomposition events.

### Example
```kotlin
import com.azikar24.wormaceptor.core.ui.trackRecomposition

@Composable
fun ProductCard(product: Product) {
    Card(modifier = Modifier.trackRecomposition("ProductCard")) {
        // ...
    }
}
```
```

--------------------------------

### Debug-only trackRecomposition extension

Source: https://wormaceptor.com/docs/recomposition

Isolate the trackRecomposition call behind a debug-only source set to keep release builds compiling. This extension delegates to the real implementation in debug builds.

```kotlin
import com.azikar24.wormaceptor.core.ui.trackRecomposition as wormaTrackRecomposition

fun Modifier.trackRecomposition(name: String): Modifier =
    this.wormaTrackRecomposition(name)
```
Tokens:
Raw