test(performance): add end-to-end Xtream benchmark harness (#1300)

* docs(performance): plan Xtream benchmark

* feat(xtream-mock-server): add deterministic 100k fixture

* style(xtream-mock-server): apply repository formatting

* fix(xtream-mock-server): harden performance fixture data

* feat(xtream-mock-server): add performance control plane

* docs(performance): correct Xtream capture plan

* fix(xtream-mock-server): harden performance controls

* fix(xtream-mock-server): harden control lifecycle

* feat(performance): add Xtream preload markers

* feat(performance): trace Xtream main phases

* feat(performance): mark Xtream store publications

* feat(performance): trace Xtream database phases

* feat(performance): trace Xtream delete cancellation

* feat(performance): capture Xtream phase attribution

* feat(performance): mark Sources Xtream refresh

* test(performance): define Xtream benchmark evidence contracts

* test(performance): add Xtream benchmark runner

* test(performance): surface failure evidence writes

* test(performance): align database read clock

* test(performance): preserve capture failure contracts

docs/architecture/sqlite-db-worker.md

@@ -172,6 +172,54 @@ explicit sum is `ipcStructuredCloneProxyMs`. See
 [M3U Playlist Module Architecture](./m3u-playlist-module.md#initial-url-import-performance-benchmark-electron)
 for the complete cross-process attribution.
 
+The same request envelope exposes count-only Xtream database phases for these
+operations:
+
+- `DB_GET_CATEGORIES`: `sqlite.categories.read`
+- `DB_SAVE_CATEGORIES`: `normalize.categories`, then
+  `sqlite.categories.write-transactions`
+- `DB_GET_CONTENT`: `sqlite.content.read`
+- `DB_SAVE_CONTENT`: `sqlite.content.category-map-read`, then
+  `normalize.content`, then `sqlite.content.write-transactions`
+- `DB_CLEAR_XTREAM_IMPORT_CACHE`:
+  `sqlite.xtream-cache-clear.write-transactions`
+- `DB_SEARCH_CONTENT`: `sqlite.search.query`, then `normalize.search-rank`
+- `DB_DELETE_XTREAM_CONTENT`:
+  `sqlite.xtream-delete.collect-user-data`, then
+  `sqlite.xtream-delete.write-transactions`
+- `DB_DELETE_PLAYLIST`: `sqlite.playlist-delete.collect-ids`, then
+  `sqlite.playlist-delete.write-transactions`
+
+Read and query phases cover the exact awaited Drizzle query. Normalization
+phases cover the existing synchronous transforms. The content-write phase is
+one aggregate pair around every existing 100-row transaction, cancellation
+checkpoint, and progress callback; it is not an exact measurement of SQLite
+commit time. Cache clear similarly uses one aggregate pair around all existing
+content and category chunk loops and transactions, including their JavaScript
+and autocommit overhead. A zero-category cache clear still emits one pair with
+`itemCount: 0` and performs no extra SQL.
+
+The Xtream-delete collection span includes its existing ordered category,
+favorite, recently-viewed, and content-ID work. Its `itemCount` deliberately
+counts only content and category deletion candidates; favorite,
+recently-viewed, and hidden-category user data is timed but is not added to
+that count. The matching write count uses the same deletion-candidate
+definition. Playlist-delete collection counts every collected favorite,
+recently-viewed, playback-position, download, content, and category ID. Its
+write count adds the final playlist row. Both write spans include every
+existing cooperative checkpoint, 100-row transaction, progress callback, and,
+for playlist deletion, the final playlist-row autocommit; they are not exact
+SQLite commit-time measurements.
+
+Successful end markers carry only row/item counts. Error or cancellation still
+closes the active phase without metadata and preserves the original error.
+Disabled profiling passes no adapter into the operations, so it performs no
+phase-event or metadata-callback allocation. Worker concurrency, SQL, chunk
+sizes, transaction boundaries, progress ordering, and cancellation checkpoints
+are unchanged. `DB_GLOBAL_SEARCH` is deliberately not instrumented: it
+interleaves queries and ranking across sources, so these single-query phases
+would be misleading.
+
 Formal initial-import comparison also requires both request-scoped captures in
 every measured run to have coherent event-loop delay, event-loop utilization,
 and worker-thread CPU values with no unavailable or invalid reason. Summary
@@ -266,6 +314,15 @@ If a worker operation is canceled:
 Cancellation is cooperative and chunk-based. Already committed SQLite batches
 stay committed.
 
+With the exact `IPTVNATOR_PERF_WORKER_PROFILING=1` opt-in, receipt of a cancel
+for a correlated active request also emits a
+`performance-cancel-received` worker diagnostic containing only safe
+operation/request IDs and its epoch. The functional cancellation flag is set
+first, this receipt remains distinct from the later authoritative
+`cancelled` event, and `DatabaseWorkerClient` ignores it without settling or
+exposing the pending request. Disabled profiling performs no receipt clock or
+transport work, and `DatabaseWorkerClient.cancel()` remains fire-and-return.
+
 ## Renderer Contract
 
 The preload bridge keeps the existing database methods but adds scoped worker