OmniRoute/docs/i18n/km/docs/compression/RTK_COMPRESSION.md

RTK Compression (ខ្មែរ)

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW

---

ការបង្ហាប់ RTK គឺជាម៉ាស៊ីនបង្ហាប់របស់ OmniRoute ដែលយល់ដឹងអំពី command សម្រាប់ output របស់ terminal និង tool។ វាត្រូវបាន រចនាឡើងសម្រាប់ session របស់ coding-agent ដែលការកើនឡើងនៃ context ភាគច្រើនកើតចេញពី test logs, build output, សំឡេងរំខានពី package manager, shell transcripts, Docker output, git output និង stack traces។

RTK អាចដំណើរការដោយផ្ទាល់ជាមួយ defaultMode: "rtk" ឬជាជំហានដំបូងក្នុង pipeline ដែលដាក់តគ្នា ជាទូទៅ៖

rtk -> caveman

លំដាប់នេះបង្ហាប់ machine output ដែលមានសំឡេងរំខានជាមុនសិន បន្ទាប់មកអនុញ្ញាតឱ្យ Caveman សង្ខេប prose ដែលនៅសល់។

RTK ដើមរាយការណ៍ពីការសន្សំ command-output ចំនួន 60-90%។ session គំរូក្នុង README របស់វាបានថយចុះពី standard tokens ប្រហែល ~118,000 មកនៅ RTK tokens ប្រហែល ~23,900 ដែលសន្សំបាន 79.7% (~80%)។ OmniRoute ប្រើ មធ្យមភាគដើមនោះសម្រាប់ការគណនាការសន្សំរួមជាមួយការបង្ហាប់ input របស់ Caveman៖

មធ្យមភាគ RTK:    សន្សំបាន 80%
input របស់ Caveman: សន្សំបាន 46%
ដាក់តគ្នា:       1 - (1 - 0.80) * (1 - 0.46) = សន្សំបាន 89.2%
ចន្លោះ:         1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%

អ្វីដែលវាបង្ហាប់

catalog ដែលភ្ជាប់មកជាមួយបច្ចុប្បន្នមាន filter ចំនួន 49 នៅក្នុងប្រភេទទាំងនេះ៖

ប្រភេទ	ឧទាហរណ៍
git	git status, git branch, git diff, git log
test	Vitest, Jest, Pytest, Playwright, Go tests, Cargo tests
build	TypeScript, ESLint, Biome, Prettier, Vite, Webpack, Turbo, Nx
package	npm install, npm audit, pip, uv sync, Poetry, Bundler
shell	ls, find, grep, generic shell logs
docker	docker ps, Docker logs
infra	Terraform, OpenTofu, systemctl status
generic	JSON output, stack traces, generic output fallback

detector នៅក្នុង open-sse/services/compression/engines/rtk/commandDetector.ts ចាត់ថ្នាក់ output មុនពេលជ្រើសរើស filter។ filter ក៏អាចផ្គូផ្គងតាម command pattern ឬ output regex នៅពេល command class មិនគ្រប់គ្រាន់។

ការកំណត់ Filter

RTK ផ្ទុក filter តាមលំដាប់នេះ៖

1. Project filters ពី .rtk/filters.toml និង .rtk/filters.json តែនៅពេលត្រូវបានទុកចិត្តប៉ុណ្ណោះ។
2. Global filters ពី DATA_DIR/rtk/filters.toml និង DATA_DIR/rtk/filters.json។
3. Built-in filters ពី open-sse/services/compression/engines/rtk/filters/។

នៅក្នុង scope ដូចគ្នា RTK TOML schema v1 filters មានអាទិភាពលើ OmniRoute JSON filters។ TOML match_command expressions ត្រូវបានពិនិត្យមុន command-type matching ដូច្នេះ filter ជាក់លាក់សម្រាប់ command ដែលបាន import អាច override filter ដែលទូលំទូលាយជាងនៅក្នុង scope នោះ។ Project scope នៅតែមានអាទិភាពលើ global scope ដោយមិនគិតពី file format។

Project filters ត្រូវបានកម្រិតដោយការទុកចិត្តដោយចេតនា ពីព្រោះ regex filters អាចផ្លាស់ប្តូររបៀបដែល tool output ត្រូវបាន បង្ហាញទៅកាន់ agents។ project filter file ត្រូវបានទទួលយកនៅពេលលក្ខខណ្ឌមួយក្នុងចំណោមលក្ខខណ្ឌខាងក្រោមជាការពិត៖

• rtkConfig.trustProjectFilters គឺ true។
• OMNIROUTE_RTK_TRUST_PROJECT_FILTERS=1 ត្រូវបានកំណត់។
• .rtk/trust.json មាន SHA-256 hash ដែលត្រូវគ្នាសម្រាប់ project filter file។

ឧទាហរណ៍ trust file៖

{
  "filtersSha256": "0123456789abcdef...",
  "filtersTomlSha256": "fedcba9876543210..."
}

hash ទាំងនេះដាច់ដោយឡែកពីគ្នា៖ filtersSha256 ទុកចិត្ត .rtk/filters.json ខណៈដែល filtersTomlSha256 ទុកចិត្ត .rtk/filters.toml។ ការកែសម្រួល file ណាមួយនឹងធ្វើឱ្យតែ trust entry របស់វាផ្ទាល់អស់សុពលភាពប៉ុណ្ណោះ។ Global files ត្រូវបានដំឡើងដោយ administrator ហើយប្រើ behavior នៃការទុកចិត្ត global-filter ដែលមានស្រាប់។

Custom filters អាចជា filter object មួយ ឬ array នៃ filter objects។ Custom filters ដែលមិនត្រឹមត្រូវត្រូវបាន រំលង និងរាយការណ៍ដោយ diagnostics របស់ /api/context/rtk/filters។ Built-in filters ដែលមិនត្រឹមត្រូវបញ្ឈប់ដំណើរការភ្លាមៗ។

ភាពត្រូវគ្នាជាមួយ RTK TOML schema v1

OmniRoute អាចញែក វាយតម្លៃសុពលភាព សាកល្បង និងដំឡើងឯកសារតម្រងបែបប្រកាសដោយប្រើ RTK TOML schema v1។ វាលដែលគាំទ្ររួមមាន description, match_command, strip_ansi, filter_stderr, strip_lines_matching, keep_lines_matching, replace, match_output, truncate_lines_at, head_lines, tail_lines, max_lines, on_empty និងការធ្វើតេស្តក្នុងបន្ទាត់ [[tests.<filter>]]។ វាលដែលមិនស្គាល់ កន្សោមធម្មតាដែលមិនត្រឹមត្រូវ ឬមិនមានសុវត្ថិភាព ការប្រើច្បាប់ដកចេញ/រក្សាទុកក្នុងពេលដំណាលគ្នា ឯកសារដែលមានទំហំលើស 1 MiB និងសេចក្ដីយោងទៅតម្រងដែលមិនស្គាល់ នឹងត្រូវបានបដិសេធ។ ឯកសារដែលការធ្វើតេស្តក្នុងបន្ទាត់របស់វាបរាជ័យ អាចត្រូវបាន វាយតម្លៃសុពលភាពដើម្បីពិនិត្យមើល ប៉ុន្តែមិនអាចដំឡើង ឬផ្ទុកបានទេ។ ការបរាជ័យក្នុងការផ្ទុកឯកសារផ្ទាល់ខ្លួននៅតែមានលក្ខណៈ fail-open៖ ឯកសារមិនត្រឹមត្រូវត្រូវបានរំលង ហើយតម្រងដែលនៅសល់បន្តដំណើរការ។

OmniRoute ទទួលលទ្ធផលពីឧបករណ៍ បន្ទាប់ពី client បានចាប់យកវារួចហើយ ដូច្នេះ filter_stderr = true មិនអាចផ្លាស់ប្ដូរការចាប់យក process បានទេ។ វាលនេះត្រូវបានទទួលយកដោយគ្មានប្រតិបត្តិការ ហើយការវាយតម្លៃសុពលភាពនឹងបញ្ជូនការព្រមានត្រឡប់មកវិញ។ វាត្រូវបានពិពណ៌នាដោយចេតនាថាជា ភាពត្រូវគ្នាជាមួយ RTK TOML schema v1 មិនមែនជាភាពត្រូវគ្នាពេញលេញ ជាមួយឯកសារប្រតិបត្តិ RTK, shell hooks, ការអនុវត្ត command ជា Rust ឬប្លង់ trust-store របស់វាទេ។

ទិដ្ឋភាព RTK កម្រិតខ្ពស់របស់ dashboard ទទួលយក TOML ដែលបានបិទភ្ជាប់ ឬផ្ទុកឡើង។ ការវាយតម្លៃសុពលភាពគឺបានតែអានប៉ុណ្ណោះ។ ការដំឡើងសរសេរ DATA_DIR/rtk/filters.toml ជាប្រតិបត្តិការអាតូមិក ដោយប្រើសិទ្ធិដ៏តឹងរ៉ឹង និងធ្វើឱ្យ កាតាឡុកតម្រងដែលកំពុងដំណើរការស្រស់ឡើងវិញដោយមិនចាំបាច់ចាប់ផ្ដើមឡើងវិញ។ ការជំនួសឯកសារដែលមានស្រាប់ តម្រូវឱ្យបញ្ជាក់ overwrite យ៉ាងច្បាស់ ហើយបង្កើត DATA_DIR/rtk/filters.toml.bak ជាមុន។

DSL របស់តម្រង

តម្រងប្រើ JSON schema ដែលបានពិពណ៌នានៅក្នុង ទម្រង់ច្បាប់បង្ហាប់។ runtime អនុវត្តដំណាក់កាលទាំងនេះតាមលំដាប់៖

stripAnsi -> filterStderr -> replace -> matchOutput -> ដកចេញ/រួមបញ្ចូលបន្ទាត់
  -> truncateLineAt -> head/tail/maxLines -> onEmpty

វាលសំខាន់ៗ៖

វាល	គោលបំណង
rules.stripAnsi	លុបលំដាប់ពណ៌/ការគ្រប់គ្រងរបស់ terminal មុនពេលផ្គូផ្គង
rules.filterStderr	ធ្វើឱ្យបុព្វបទ stderr ទូទៅមានទម្រង់ស្របគ្នា មុនពេលផ្គូផ្គង/ត្រង
rules.replace	អនុវត្តការជំនួសដោយកន្សោមធម្មតាតាមលំដាប់
rules.matchOutput	បញ្ជូនសេចក្ដីសង្ខេបខ្លីត្រឡប់មកវិញ នៅពេលលទ្ធផលត្រូវនឹងលក្ខខណ្ឌដែលស្គាល់
rules.matchOutput[].unless	រំលងផ្លូវកាត់ នៅពេលមានលំនាំកំហុស/បរាជ័យ
rules.dropPatterns	លុបបន្ទាត់ដែលរំខាន
rules.includePatterns	ផ្ដល់អាទិភាពដល់បន្ទាត់ដែលអាចចាត់វិធានការបាន
rules.collapsePatterns	បង្រួមបន្ទាត់ដែលផ្គូផ្គងដដែលៗ
rules.deduplicate	ជម្រើសចូលរួមសម្រាប់តម្រងនីមួយៗ៖ បង្រួមបន្ទាត់ស្ទួនដែលនៅជាប់គ្នា
rules.truncateLineAt	កាត់បន្ទាត់នីមួយៗដោយសុវត្ថិភាពសម្រាប់ Unicode
rules.onEmpty	សារជំនួស ប្រសិនបើបន្ទាត់ទាំងអស់ត្រូវបានត្រងចេញ
tests[]	គំរូក្នុងបន្ទាត់ដែលប្រើដោយច្រកផ្ទៀងផ្ទាត់

តម្រងដែលមានស្រាប់ត្រូវបានរំពឹងថានឹងរួមបញ្ចូលគំរូ tests[] ក្នុងបន្ទាត់។ តម្រងផ្ទាល់ខ្លួនក៏គួរតែរួមបញ្ចូល គំរូទាំងនេះផងដែរ ជាពិសេសនៅពេលពួកវាត្រូវបានចែករំលែករវាងគម្រោងនានា។

ការលុបបន្ទាត់ស្ទួន (ពីរស្រទាប់)

RTK បង្រួមបន្ទាត់ស្ទួននៅស្រទាប់ឯករាជ្យពីរ៖

1. deduplicate តាម filter នីមួយៗ (ត្រូវបើកប្រើដោយចេតនា, លំនាំដើម false)។ Filter មួយអាចកំណត់ rules.deduplicate: true ដើម្បីបង្រួមបន្ទាត់ស្ទួនជាប់គ្នា នៅក្នុងលទ្ធផលដែលត្រូវគ្នារបស់ filter នោះ មុនពេលកាត់ខ្លី។ ដំណើរការនេះប្រព្រឹត្តទៅនៅក្នុង lineFilter.ts។ សម្រាប់ filter ចាស់ៗ វាត្រូវបានបើកដោយស្វ័យប្រវត្តិ នៅពេល filter កំណត់ collapsePatterns។ Schema៖ deduplicate: z.boolean().default(false) នៅក្នុង open-sse/services/compression/engines/rtk/filterSchema.ts។
2. deduplicateThreshold ទូទាំង engine (លំនាំដើម 3)។ បន្ទាប់ពី filter ទាំងអស់ដំណើរការ engine នឹងបង្រួម លំដាប់បន្ទាត់ដូចគ្នាជាប់គ្នាណាមួយដែលមានចំនួន >= deduplicateThreshold នៅទូទាំងលទ្ធផលទាំងមូល (deduplicateRepeatedLines ដែលត្រូវបានអនុវត្តនៅក្នុង engines/rtk/index.ts)។ តម្លៃនេះត្រូវបានកម្រិតចន្លោះ 2–100 នៅពេល ធ្វើ normalization។

ការដំណើរការតាម filter ធ្វើឡើងមុន (នៅខាងក្នុង filter) ចំណែកការដំណើរការទូទាំង engine ធ្វើឡើងចុងក្រោយ (លើលទ្ធផលដែលបានតភ្ជាប់) ដូច្នេះទាំងពីរអាចដំណើរការរួមគ្នាដោយមិនរាប់ស្ទួនពីរដង។

ការដាក់បន្ទាត់ជាក្រុម (enableGrouping)

នៅពេល rtkConfig.enableGrouping មានតម្លៃជា true (លំនាំដើម false) RTK ដំណើរការ groupSimilarLines បន្ថែមទៀតលើលទ្ធផលក្រោយការលុបស្ទួន ដើម្បីបង្រួមលំដាប់បន្ទាត់ជាប់គ្នាដែល ប្រហាក់ប្រហែលគ្នា (មិនមែនដូចគ្នាគ្រប់ byte) ។ rtkConfig.groupingThreshold (លំនាំដើម 3) គឺជាប្រវែងអប្បបរមានៃលំដាប់ដែលធ្វើឱ្យការដាក់ជាក្រុម ចាប់ផ្តើម។ នេះគឺជាសមភាគីផ្នែករចនាសម្ព័ន្ធរបស់ deduplicateThreshold៖ ការលុបស្ទួនដោះស្រាយការកើតឡើងម្តងទៀតដែលដូចគ្នាបេះបិទ ចំណែកការដាក់ជាក្រុមដោះស្រាយ «ទម្រង់ដូចគ្នា ប៉ុន្តែមានភាពខុសគ្នាបន្តិចបន្តួច»។ Flag ទាំងពីរគឺជាផ្នែកនៃ JSON rtkConfig ដែលត្រូវបានរក្សាទុកក្នុងតារាង key_value (សូមមើលការកំណត់រចនាសម្ព័ន្ធខាងលើ) ដូច្នេះការកំណត់នេះនៅតែមានក្រោយការចាប់ផ្តើមឡើងវិញ។

ការដក Comment របស់កូដ (stripCodeComments / preserveDocstrings)

នៅពេល rtkConfig.applyToCodeBlocks ត្រូវបានបើក RTK ក៏អាចដក comment ចេញពី fenced code block ផងដែរ៖

• stripCodeComments (លំនាំដើម false) — ត្រូវបើកប្រើដោយចេតនា។ នៅពេលមានតម្លៃជា true RTK នឹងដក comment ចេញពី fenced block របស់ JavaScript និង TypeScript។ ជាប្រវត្តិសាស្ត្រ flag នេះត្រូវបានអាន ប៉ុន្តែមិនដែលត្រូវបានអនុវត្តទេ ដូច្នេះលំនាំដើមនៅតែជា «រក្សាទុក» ដើម្បីចៀសវាងការផ្លាស់ប្តូរក្នុង production ដោយមិនមានការជូនដំណឹង។
• preserveDocstrings (លំនាំដើម true) — នៅពេលដក comment ចេញ block comment ប្រភេទ JSDoc//** … */ ត្រូវបាន រក្សាទុក (ពួកវាផ្ទុកឯកសារ API ដែលមានតម្លៃលើសពីចំនួន byte ដែលពួកវាប្រើ)។ កំណត់ជា false ដើម្បីដក comment ទាំងនោះចេញផងដែរ។

ការដក comment ត្រូវបានអនុវត្តនៅក្នុង open-sse/services/compression/engines/rtk/codeStripper.ts។ វាប្រើ TypeScript parser (មិនមែន regex ទេ) ដូច្នេះ string literal, template literal និង regex literal មិនត្រូវបានយល់ច្រឡំ ថាជា comment ឡើយ ហើយវានឹងបោះបង់ដំណើរការទាំងស្រុងនៅពេលរកឃើញ JSX (ដូច្នេះ comment ក្នុង JSX expression container មិនត្រូវបានធ្វើឱ្យខូចឡើយ)។ បច្ចុប្បន្ន ការដក comment អនុវត្តតែចំពោះ JavaScript និង TypeScript ប៉ុណ្ណោះ — ភាសាផ្សេងទៀត នៅក្នុងសំណុំ CodeLanguage របស់ stripper (Python, Rust, Go, Ruby, Java) មានការបង្រួមបន្ទាត់ទទេ និង ចន្លោះទទេ ប៉ុន្តែមិនមានការដក comment ទេ។ ការដំណើរការលើ block ដែលត្រូវបានដក comment ត្រូវបានដាក់ស្លាក rtk:code-strip នៅក្នុង rulesApplied។

ចំណាំ — GCF / ការអ៊ិនកូដជាតារាងគឺជា engine ដាច់ដោយឡែក។ RTK មិន មាន encoder JSON ជាទម្រង់តារាង/ជួរឈរ "GCF" (Graph Compact Format) ទេ។ Encoder នោះ — ដែលបានជំនួស encoder omni-tabular ចាស់ជាង — ស្ថិតនៅក្នុង engine headroom (open-sse/services/compression/engines/headroom/ ដោយមាន codec ដែលបានបញ្ចូលមកជាមួយនៅក្រោម headroom/gcf/)។ វាមិនទាក់ទងនឹង pipeline របស់ filter RTK ដែលបានចងក្រងជាឯកសារនៅទីនេះទេ។

ការកំណត់រចនាសម្ព័ន្ធ

ការកំណត់សកលអាចប្រើបានតាមរយៈ /api/settings/compression។ ការកំណត់ជាក់លាក់សម្រាប់ RTK ក៏អាចប្រើបានតាមរយៈ /api/context/rtk/config ផងដែរ។

{
  "defaultMode": "stacked",
  "autoTriggerMode": "stacked",
  "autoTriggerTokens": 32000,
  "stackedPipeline": [
    { "engine": "rtk", "intensity": "standard" },
    { "engine": "caveman", "intensity": "full" }
  ],
  "rtkConfig": {
    "enabled": true,
    "intensity": "standard",
    "applyToToolResults": true,
    "applyToCodeBlocks": false,
    "applyToAssistantMessages": false,
    "enabledFilters": [],
    "disabledFilters": [],
    "maxLinesPerResult": 120,
    "maxCharsPerResult": 12000,
    "deduplicateThreshold": 3,
    "customFiltersEnabled": true,
    "trustProjectFilters": false,
    "rawOutputRetention": "never",
    "rawOutputMaxBytes": 1048576,
    "enableGrouping": false,
    "groupingThreshold": 3,
    "stripCodeComments": false,
    "preserveDocstrings": true
  }
}

enabledFilters និង disabledFilters ប្រើលេខសម្គាល់តម្រង ឧទាហរណ៍ test-vitest ឬ git-diff។

ទម្រង់ពេញលេញរបស់ rtkConfig ត្រូវបានកំណត់ដោយ RtkConfig / DEFAULT_RTK_CONFIG នៅក្នុង open-sse/services/compression/types.ts។ អាប់ជិកទាំងមូលត្រូវបានរក្សាទុកជាតម្លៃ JSON តែមួយនៅក្នុង តារាង SQLite key_value ក្រោម namespace = "compression", key = "rtkConfig" (src/lib/db/compression.ts) ហើយត្រូវបានធ្វើឱ្យមានលក្ខណៈស្តង់ដារនៅពេលអានដោយ normalizeRtkConfig។ ដូច្នេះ វាលនីមួយៗខាងក្រោម — រួមទាំង enableGrouping, groupingThreshold, stripCodeComments និង preserveDocstrings — ត្រូវបានរក្សាទុក និងអានត្រឡប់តាមរយៈឃ្លាំងដូចគ្នា ហើយនៅតែមានបន្ទាប់ពីចាប់ផ្ដើមឡើងវិញ។

សោ	លំនាំដើម	គោលបំណង
deduplicateThreshold	3	ទូទាំងម៉ាស៊ីន៖ ចំនួនអប្បបរមានៃបន្ទាត់ដូចគ្នាជាប់គ្នាដែលត្រូវបង្រួម (កំណត់ចន្លោះ 2–100)
enableGrouping	false	ជាជម្រើស៖ បង្រួមស៊េរីបន្ទាត់ជាប់គ្នាដែលប្រហាក់ប្រហែលគ្នា
groupingThreshold	3	ចំនួនអប្បបរមានៃស៊េរីបន្ទាត់ស្រដៀងគ្នាជាប់គ្នាដែលបង្កឱ្យមានការដាក់ជាក្រុម
stripCodeComments	false	ជាជម្រើស៖ ដកមតិយោបល់ចេញពីប្លុកកូដដែលហ៊ុមព័ទ្ធ (តម្រូវឱ្យមាន applyToCodeBlocks)
preserveDocstrings	true	នៅពេលដកមតិយោបល់ចេញ រក្សាទុកប្លុក JSDoc//** … */

API

ផ្លូវ	វិធីសាស្ត្រ	គោលបំណង
/api/context/rtk/config	GET	អានការកំណត់ RTK
/api/context/rtk/config	PUT	ធ្វើបច្ចុប្បន្នភាពការកំណត់ RTK
/api/context/rtk/filters	GET	រាយបញ្ជីកាតាឡុកតម្រង និងព័ត៌មានវិនិច្ឆ័យការផ្ទុក
/api/context/rtk/import	POST	ផ្ទៀងផ្ទាត់ ឬដំឡើងឯកសារគ្រោងការណ៍ RTK TOML v1
/api/context/rtk/test	POST	មើលការបង្រួម RTK ជាមុនសម្រាប់ទិន្នន័យអត្ថបទមួយ
/api/context/rtk/raw-output/[id]	GET	អានលទ្ធផលដើមដែលបានកែសម្រួលលាក់ព័ត៌មាន និងរក្សាទុក
/api/compression/preview	POST	មើលជាមុននូវរបៀបបង្រួមណាមួយ

ទិន្នន័យផ្ញើសាកល្បង RTK៖

{
  "command": "npm test",
  "text": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed",
  "config": {
    "intensity": "standard"
  }
}

ទិន្នន័យផ្ញើសម្រាប់មើលការបង្រួមជាមុន៖

{
  "mode": "stacked",
  "messages": [
    {
      "role": "tool",
      "content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed"
    }
  ],
  "config": {
    "rtkConfig": {
      "rawOutputRetention": "failures"
    }
  }
}

ផ្លូវគ្រប់គ្រងតម្រូវឱ្យមានការផ្ទៀងផ្ទាត់សិទ្ធិគ្រប់គ្រងផ្ទាំងបញ្ជា ឬគោលការណ៍ API-key ដែលត្រូវគ្នា។

ទិន្នន័យផ្ញើសម្រាប់ផ្ទៀងផ្ទាត់ RTK TOML៖

{
  "action": "validate",
  "content": "schema_version = 1\n\n[filters.my-tool]\nmatch_command = \"^my-tool\\\\b\"\nmax_lines = 20\n"
}

ប្រើ "action": "install" ដើម្បីដំឡើងឯកសារដែលបានផ្ទៀងផ្ទាត់ជាសកល។ បន្ថែម "overwrite": true តែបន្ទាប់ពី បានពិនិត្យ និងបញ្ជាក់ការជំនួសឯកសារសកលដែលមានស្រាប់រួចហើយប៉ុណ្ណោះ។

ការសង្គ្រោះលទ្ធផលដើម

ជាធម្មតា RTK ត្រឡប់តែអត្ថបទដែលបានបង្ហាប់ប៉ុណ្ណោះ។ សម្រាប់ការបំបាត់កំហុស rawOutputRetention អាចរក្សាទុក លទ្ធផលដើមដែលបានលាក់ព័ត៌មានរសើប៖

តម្លៃ	ឥរិយាបថ
never	មិនរក្សាទុកលទ្ធផលដើម
failures	រក្សាទុកតែលទ្ធផលដែលទំនងជាបរាជ័យ
always	រក្សាទុករាល់លទ្ធផលដើម RTK ដែលបានបង្ហាប់ បន្ទាប់ពីលាក់ព័ត៌មានរសើប

ឯកសារដែលបានរក្សាទុកត្រូវបានសរសេរនៅក្រោម៖

DATA_DIR/rtk/raw-output/

ព័ត៌មានសម្ងាត់ត្រូវបានលាក់មុនពេលរក្សាទុកជាអចិន្ត្រៃយ៍ រួមទាំង bearer token ទូទៅ, API key, Slack token, AWS access key និងតម្លៃក្នុងទម្រង់កំណត់ token=..., secret=..., password=...។ ទិន្នន័យវិភាគ រក្សាទុកតែ pointer id, ទំហំ និង metadata របស់ hash ប៉ុណ្ណោះ។

ច្រកផ្ទៀងផ្ទាត់

ច្រកផ្ទៀងផ្ទាត់ដែលផ្តោតជាក់លាក់ ដំណើរការការធ្វើតេស្ត filter inline ដែលមានស្រាប់ ដោយមិនហៅពាក្យបញ្ជាខាងក្រៅតាម shell៖

node --import tsx/esm --test tests/unit/compression/rtk-verify.test.ts

ច្រក RTK ដែលទូលំទូលាយជាងគឺ៖

node --import tsx/esm --test \
  tests/unit/compression/rtk-*.test.ts \
  tests/unit/compression/pipeline-integration.test.ts \
  tests/unit/compression/context-compression-api.test.ts

ដំណើរការច្រកបង្ហាប់ទូលំទូលាយ មុនពេលចេញផ្សាយ៖

node --import tsx/esm --test \
  tests/unit/compression/*.test.ts \
  tests/golden-set/*.test.ts \
  tests/integration/compression-pipeline.test.ts \
  tests/unit/api/compression/compression-api.test.ts

ការពង្រីក RTK

1. បន្ថែម ឬធ្វើបច្ចុប្បន្នភាពឯកសារ JSON របស់ filter។
2. រួមបញ្ចូលគំរូ tests[] យ៉ាងហោចណាស់មួយ ដែលបញ្ជាក់ពីឥរិយាបថសំខាន់។
3. បន្ថែម fixture នៅក្រោម tests/unit/compression/fixtures/rtk/ សម្រាប់ក្រុមពាក្យបញ្ជាថ្មី។
4. បន្ថែមការគ្របដណ្តប់លើការរកឃើញពាក្យបញ្ជា នៅពេលណែនាំថ្នាក់លទ្ធផលថ្មី។
5. ដំណើរការច្រកផ្ទៀងផ្ទាត់ និងច្រក RTK ទូលំទូលាយ។
6. ប្រសិនបើ filter ជារបស់គម្រោងមូលដ្ឋាន សូម commit .rtk/filters.json ហើយធ្វើឱ្យ .rtk/trust.json ស្រស់ឡើងវិញ តែបន្ទាប់ពីការពិនិត្យប៉ុណ្ណោះ។

---

កម្រិតអាំងតង់ស៊ីតេ (v3.8.16+)

RTK គាំទ្រ កម្រិតអាំងតង់ស៊ីតេចំនួន 3 ដែលធ្វើការថ្លឹងថ្លែងរវាង ភាពខ្លាំងនៃការបង្ហាប់ និង សុវត្ថិភាព។ កម្រិតត្រូវបានកំណត់តាមរយៈ config.intensity នៅក្នុង config របស់ engine។

កម្រិតទាំង 3

កម្រិត	កម្រិតកាត់ខ្លី	ការសន្សំ token	ហានិភ័យ	ស័ក្តិសមបំផុតសម្រាប់
minimal	24 បន្ទាត់ក្នុងមួយផ្នែក	~20-40%	ទាបបំផុត	Production ដែលមានបរិបទសំខាន់
standard (លំនាំដើម)	24 បន្ទាត់ក្នុងមួយផ្នែក	~50-70%	ទាប	វគ្គសរសេរកូដប្រចាំថ្ងៃ
aggressive	16 បន្ទាត់ក្នុងមួយផ្នែក	~70-90%	មធ្យម	វគ្គវែងៗ និងការសន្សំអតិបរមា

ទីតាំងដែលការកាត់ខ្លីកើតឡើង

កម្រិតកាត់ខ្លីប៉ះពាល់ដល់ lineFilter.ts៖

// មកពី open-sse/services/compression/engines/rtk/index.ts:329-330
config.intensity === "aggressive" ? 16 : 24,
config.intensity === "aggressive" ? 16 : 24,

ទាំង ផ្នែកដើម និង ផ្នែកចុង នៃផ្នែកនីមួយៗត្រូវបានរក្សាទុក។ ខ្លឹមសារកណ្តាលត្រូវបានដកចេញ នៅពេលការកាត់ខ្លីចាប់ផ្តើមអនុវត្ត។

អ្វីដែលត្រូវបានរក្សាទុក និងអ្វីដែលត្រូវបានកាត់ចេញ

ខ្លឹមសារ	minimal	standard	aggressive
កំហុស / stack trace	✅ រក្សាទុក	✅ រក្សាទុក	✅ រក្សាទុក
ការធ្វើតេស្តបរាជ័យ	✅ រក្សាទុក	✅ រក្សាទុក	✅ រក្សាទុក
កំហុសក្នុងការ build	✅ រក្សាទុក	✅ រក្សាទុក	✅ រក្សាទុក
ការធ្វើតេស្តជោគជ័យ (លម្អិត)	✅ រក្សាទុក	🟡 បង្រួម	🟡 បង្រួម
លទ្ធផលទូទៅ (info log)	🟡 បង្រួម	🟡 បង្រួម	❌ ដកចេញ
របារវឌ្ឍនភាព	🟡 បង្រួម	❌ ដកចេញ	❌ ដកចេញ
Banner / សិល្បៈ ASCII	🟡 បង្រួម	❌ ដកចេញ	❌ ដកចេញ

ការជ្រើសរើសអាំងតង់ស៊ីតេត្រឹមត្រូវ

                  តើការបាត់បង់បរិបទបង្កមហន្តរាយឬ?
                  │
      ┌───────────┼───────────┐
      │           │           │
    បាទ/ចាស      ទេ       មិនប្រាកដ
      │           │           │
      ▼           │           │
   minimal        │           │
      │           │           │
      │           ▼           ▼
      │      តើលំហូរការងារ   សាកល្បង `standard` មុន
      │      សំខាន់កម្រិតណា?  (ដំណើរការល្អសម្រាប់ 80%
      │           │          នៃករណី)
      │      ┌────┴────┐
      │      │         │
      │     ទាប       ខ្ពស់
      │      │         │
      │      ▼         ▼
      │   standard   aggressive
      │      │         │
      └──────┴─────────┘

ការកំណត់រចនាសម្ព័ន្ធអាំងតង់ស៊ីតេ

តាម combo នីមួយៗ (ក្នុង combo config)៖

{
  "combo": "my-coding-combo",
  "routing": {/* ... */},
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive"
  }
}

តាមកម្មវិធី៖

rtkEngine (@omniroute/open-sse/services/compression/engines/rtk) គឺជា CompressionEngine ហើយមិនមាន method updateConfig ទេ។ ធ្វើបច្ចុប្បន្នភាព config របស់ engine តាមរយៈ registry helper ជំនួសវិញ៖

import { updateEngineConfig } from "@omniroute/open-sse/services/compression/engines/registry";

updateEngineConfig("rtk", { intensity: "aggressive" });

ការផ្ទៀងផ្ទាត់ប្រសិទ្ធភាព

ប្រើ ច្រកផ្ទៀងផ្ទាត់ (សូមមើលខាងក្រោម) ដើម្បីបញ្ជាក់ថា filter របស់អ្នកមានសុវត្ថិភាពនៅអាំងតង់ស៊ីតេដែលអ្នកបានជ្រើសរើស៖

import { runRtkFilterTests } from "omniroute/compression/engines/rtk/verify";

const result = runRtkFilterTests({ intensity: "aggressive" });
if (!result.passed) {
  console.error("Filters failed at aggressive intensity");
}

---

ការអភិវឌ្ឍតម្រងផ្ទាល់ខ្លួន (v3.8.16+)

ថត engines/rtk/filters/ មាន ឯកសារ JSON តម្រងដែលភ្ជាប់មកជាមួយចំនួន 49+។ អ្នកអាចបន្ថែមតម្រងផ្ទាល់ខ្លួនរបស់អ្នក ដើម្បីបង្រួមលទ្ធផលពីឧបករណ៍ផ្ទាល់ខ្លួនដែលមិនត្រូវបានគ្របដណ្ដប់ដោយលំនាំដើម។

គ្រោងការណ៍តម្រង (Zod)

{
  "id": "string",                      // តម្រូវឱ្យមាន។ អត្តសញ្ញាណតម្រង (ទម្រង់ kebab-case ឧ. "python-traceback")
  "label": "string",                   // តម្រូវឱ្យមាន។ ឈ្មោះតម្រងដែលមនុស្សអាចអានបាន
  "description": "string",             // ជាជម្រើស (លំនាំដើម៖ "")។ ការពិពណ៌នាខ្លីអំពីអ្វីដែលតម្រងធ្វើ
  "category": "git|test|build|shell|docker|package|infra|cloud|generic",
  "priority": number,                  // ជាជម្រើស (0-100, លំនាំដើម៖ 50)។ លំដាប់ប្រតិបត្តិ (តម្លៃខ្ពស់ជាង = ដំណើរការមុន)
  "match": {
    "commands": ["string"],            // ឈ្មោះពាក្យបញ្ជាដែលត្រូវផ្គូផ្គង (ឧ. "python", "pytest")
    "patterns": ["string"],            // លំនាំ regex សម្រាប់ផ្គូផ្គងលទ្ធផល
    "outputTypes": ["string"]          // ប្រភេទលទ្ធផលដែលបានរកឃើញ (ឧ. "test-failure")
  },
  "rules": {
    "stripAnsi": boolean,              // ជាជម្រើស (លំនាំដើម៖ false)។ ដកកូដពណ៌ ANSI ចេញ
    "replace": [                       // ច្បាប់ស្វែងរក និងជំនួស (លំនាំដើម៖ [])
      { "pattern": "regex", "replacement": "..." }
    ],
    "matchOutput": [                   // បញ្ឈប់ដំណើរការបន្តភ្លាមៗ នៅពេលលំនាំត្រូវគ្នា (លំនាំដើម៖ [])
      {
        "pattern": "regex",
        "message": "short summary",
        "unless": "regex"              // រំលង ប្រសិនបើលំនាំនេះត្រូវគ្នា
      }
    ],
    "includePatterns": ["string"],     // បន្ទាត់ដែលត្រូវរក្សាទុក (លំនាំ regex, លំនាំដើម៖ [])
    "dropPatterns": ["string"],        // បន្ទាត់ដែលត្រូវលុបចោល (លំនាំ regex, លំនាំដើម៖ [])
    "collapsePatterns": ["string"],    // បន្ទាត់ដែលត្រូវបង្រួមឱ្យនៅសល់តែមួយដង (លំនាំដើម៖ [])
    "deduplicate": boolean,            // ជាជម្រើស (លំនាំដើម៖ false)។ លុបបន្ទាត់ស្ទួន
    "truncateLineAt": number,          // ជាជម្រើស (លំនាំដើម៖ 0)។ កាត់បន្ទាត់ត្រឹមចំនួនតួអក្សរអតិបរមា
    "maxLines": number,                // ជាជម្រើស (លំនាំដើម៖ 0)។ កំណត់ចំនួនបន្ទាត់សរុបជាអតិបរមាដាច់ខាត
    "headLines": number,               // ជាជម្រើស (លំនាំដើម៖ 20)។ រក្សាទុក N បន្ទាត់ដំបូងនៃលទ្ធផលដែលត្រូវគ្នា
    "tailLines": number,               // ជាជម្រើស (លំនាំដើម៖ 20)។ រក្សាទុក N បន្ទាត់ចុងក្រោយនៃលទ្ធផលដែលត្រូវគ្នា
    "onEmpty": "string",               // ជាជម្រើស (លំនាំដើម៖ "")។ សារជំនួស ប្រសិនបើបន្ទាត់ទាំងអស់ត្រូវបានត្រងចេញ
    "filterStderr": boolean            // ជាជម្រើស (លំនាំដើម៖ false)។ ត្រងលទ្ធផល stderr ផងដែរ
  },
  "preserve": {
    "errorPatterns": ["string"],       // លំនាំដែលត្រូវតែរក្សាទុកជានិច្ច (លំនាំដើម៖ [])
    "summaryPatterns": ["string"]      // លំនាំសម្រាប់បន្ទាត់សង្ខេបចុងក្រោយ (លំនាំដើម៖ [])
  },
  "tests": [                           // ការធ្វើតេស្តក្នុងតួសម្រាប់ការផ្ទៀងផ្ទាត់ (លំនាំដើម៖ [])
    {
      "name": "string",               // តម្រូវឱ្យមាន។ ឈ្មោះការធ្វើតេស្ត
      "input": "sample output",        // តម្រូវឱ្យមាន។ អត្ថបទលទ្ធផលគំរូ
      "expected": "expected output",   // តម្រូវឱ្យមាន។ លទ្ធផលបង្រួមដែលរំពឹងទុក
      "command": "optional command"    // ជាជម្រើស។ បរិបទពាក្យបញ្ជា
    }
  ]
}

ឧទាហរណ៍៖ តម្រង Python Traceback

{
  "id": "python-traceback",
  "label": "Python Traceback Filter",
  "description": "Compresses Python tracebacks to essential file/line locations and error type",
  "category": "test",
  "priority": 60,
  "match": {
    "commands": ["python", "python3", "pytest", "uv", "poetry"],
    "patterns": ["Traceback \\(most recent call last\\)", "Error", "Exception"],
    "outputTypes": ["error-traceback"]
  },
  "rules": {
    "stripAnsi": true,
    "includePatterns": [
      "Traceback \\(most recent call last\\)",
      "^\\s*File \".+\", line \\d+",
      "^\\s*[A-Z][a-zA-Z]+Error:",
      "^\\s*[A-Z][a-zA-Z]+Exception"
    ],
    "dropPatterns": ["site-packages/", "^\\s+[a-z_]+\\([^)]*\\)$"],
    "headLines": 5,
    "tailLines": 3,
    "maxLines": 25,
    "filterStderr": true
  },
  "preserve": {
    "errorPatterns": ["Error:", "Exception:", "Traceback"],
    "summaryPatterns": ["^[A-Z][a-zA-Z]+(?:Error|Exception):"]
  },
  "tests": [
    {
      "name": "preserves-error-type-and-location",
      "input": "Traceback (most recent call last):\n  File \"app.py\", line 42, in main\n    do_thing()\n  File \"lib/utils.py\", line 17, in helper\n    return 1 / 0\nZeroDivisionError: division by zero",
      "expected": "Traceback (most recent call last):\n  File \"app.py\", line 42, in main\n  File \"lib/utils.py\", line 17, in helper\nZeroDivisionError: division by zero",
      "command": "python app.py"
    }
  ]
}

ការផ្ទុកតម្រងផ្ទាល់ខ្លួន

ដាក់ឯកសារនៅក្នុងទីតាំងដែលប្រព័ន្ធស្គាល់៖

~/.omniroute/rtk/filters/my-filter.json     # កម្រិតអ្នកប្រើប្រាស់
<project>/.rtk/filters/my-filter.json      # កម្រិតគម្រោង

តម្រងត្រូវបានផ្ទុកដោយស្វ័យប្រវត្តិនៅពេលចាប់ផ្ដើម តាមរយៈ loadRtkFilters() ក្នុង open-sse/services/compression/engines/rtk/filterLoader.ts។ កម្មវិធីផ្ទុកស្វែងរកតម្រងពី៖

• កាតាឡុកដែលភ្ជាប់មកជាមួយ៖ open-sse/services/compression/engines/rtk/filters/
• ថតអ្នកប្រើប្រាស់៖ ~/.omniroute/rtk/filters/
• ថតគម្រោង៖ <project>/.rtk/filters/

ដើម្បីផ្ទុកតម្រងតាមកម្មវិធី៖

import { loadRtkFilters } from "@omniroute/open-sse/services/compression/engines/rtk/filterLoader";

// ជម្រើស៖ customFiltersEnabled (ផ្ទុកតម្រងអ្នកប្រើប្រាស់/គម្រោង ដែលបើកតាមលំនាំដើម),
// trustProjectFilters, refresh។
const filters = loadRtkFilters({ customFiltersEnabled: true });

ការផ្ទៀងផ្ទាត់សុពលភាព

តម្រងត្រូវបានផ្ទៀងផ្ទាត់ធៀបនឹងគ្រោងការណ៍ Zod នៅពេលផ្ទុក។ តម្រងដែលមានរចនាសម្ព័ន្ធមិនត្រឹមត្រូវនឹងផ្ទុកបរាជ័យ ហើយកត់ត្រាកំហុស៖

RTK_FILTER_LOADER: filter "my-filter" failed validation:
  - rules.replace.0.pattern: Invalid regex
  - match.commands: must not be empty

ដើម្បីផ្ទៀងផ្ទាត់តម្រងដែលបានដំឡើងទាំងអស់ សូមហៅ runRtkFilterTests() ដែលត្រូវបាននាំចេញពី open-sse/services/compression/engines/rtk/verify.ts។

ការអនុវត្តល្អបំផុត

1. តែងតែបញ្ចូល tests[] — វាបញ្ជាក់ថាតម្រងរបស់អ្នកដំណើរការ និងការពារកុំឱ្យបញ្ហាចាស់កើតឡើងវិញ
2. ប្រើ matchOutput សម្រាប់ការបញ្ចប់មុនកំណត់ — ប្រសិនបើបន្ទាត់តែមួយអាចបង្ហាញខ្លឹមសារបានគ្រប់គ្រាន់ សូមជំនួសប្លុកទាំងមូល
3. ផ្តល់អាទិភាពដល់ keep ជាង strip — ច្បាប់ជាក់លាក់ដែលកំណត់ថា "រក្សាទុកជានិច្ច" មានសុវត្ថិភាពជាងច្បាប់ដែលកំណត់ថា "លុបចេញជានិច្ច"
4. សាកល្បងនៅកម្រិតអាំងតង់ស៊ីតេទាំង 3 — minimal មិនគួរធ្វើការផ្លាស់ប្តូរអ្វីឡើយ ហើយ aggressive នៅតែគួររក្សាទុកកំហុស
5. ប្រើវាល unless — ការពារការបញ្ចប់មុនកំណត់ដោយលក្ខខណ្ឌ "កុំដំណើរការ ប្រសិនបើមាន X"

---

ការសង្គ្រោះលទ្ធផលដើម និងច្រកផ្ទៀងផ្ទាត់

នៅពេល RTK បង្ហាប់លទ្ធផលយ៉ាងខ្លាំង អ្នកអាច សង្គ្រោះអត្ថបទដើម សម្រាប់ការបំបាត់កំហុស សវនកម្ម ឬការចាក់ឡើងវិញ។

របៀបដែលការសង្គ្រោះលទ្ធផលដើមដំណើរការ

លទ្ធផលដើម (10K tokens)
        │
        ▼
RTK បង្ហាប់ (ដោយប្រើ rawOutput.enabled=true)
        │
        ├─▶ លទ្ធផលដែលបានបង្ហាប់ (2K tokens)  ──▶ ទៅកាន់ LLM
        │
        └─▶ លទ្ធផលដើម (10K tokens)           ──▶ រក្សាទុកក្នុង DB
                                                  (ភ្ជាប់ដោយ request_id)

ការបើកការរក្សាទុកលទ្ធផលដើម

តាមសំណើនីមួយៗ (នៅក្នុងការកំណត់រចនាសម្ព័ន្ធ combo):

{
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive",
    "rawOutput": {
      "enabled": true,
      "maxBytes": 1048576 // ពិដាន 1MB
    }
  }
}

លំនាំដើម: rawOutput.enabled: false (សន្សំទំហំផ្ទុក)។

ថ្លៃដើមនៃការរក្សាទុក

ក្នុងមួយសំណើ	ពិដាន 1MB	ពិដាន 10MB
លទ្ធផលដែលបានបង្ហាប់ជាមធ្យម	~5KB	~5KB
លទ្ធផលដើមដែលបានរក្សាទុក	~50-500KB	~500KB-5MB
ជាមួយ 1000 សំណើ/ថ្ងៃ	50-500MB/ថ្ងៃ	500MB-5GB/ថ្ងៃ

អនុសាសន៍: បើកលទ្ធផលដើមសម្រាប់តែ វគ្គបំបាត់កំហុស ឬ សវនកម្មដោយការយកសំណាក ប៉ុណ្ណោះ មិនត្រូវបើកជាប់ជានិច្ចឡើយ។

ការសង្គ្រោះលទ្ធផលដើម

import { readRtkRawOutput } from "omniroute/compression/engines/rtk/rawOutput";

const raw = readRtkRawOutput(pointerId); // pointerId ពីស្ថិតិនៃការបង្ហាប់
if (raw) {
  console.log("Original output:", raw);
}

pointerId ត្រូវបានត្រឡប់មកវិញក្នុង CompressionStats.rtkRawOutputPointers[] បន្ទាប់ពីការបង្ហាប់។ សូមមើល open-sse/services/compression/engines/rtk/rawOutput.ts:102 សម្រាប់ទម្រង់ហត្ថលេខារបស់អនុគមន៍។

ច្រកផ្ទៀងផ្ទាត់

ការផ្ទៀងផ្ទាត់តម្រង RTK (open-sse/services/compression/engines/rtk/verify.ts) ផ្ទៀងផ្ទាត់តម្រងទាំងអស់ធៀបនឹង tests[] របស់ពួកវា ហើយធានាថាឥរិយាបថត្រឹមត្រូវនៅគ្រប់កម្រិតអាំងតង់ស៊ីតេទាំង 3។

ហៅ runRtkFilterTests() ដើម្បីដំណើរការការផ្ទៀងផ្ទាត់៖

import { runRtkFilterTests } from "open-sse/services/compression/engines/rtk/verify";

const result = runRtkFilterTests();
console.log(`Passed: ${result.outcomes.filter((o) => o.passed).length}`);
console.log(`Failed: ${result.outcomes.filter((o) => !o.passed).length}`);
if (!result.passed) {
  console.error("Filters failed verification");
  result.outcomes
    .filter((o) => !o.passed)
    .forEach((o) => {
      console.error(
        `  - ${o.filterId} / ${o.testName}: expected "${o.expected}", got "${o.actual}"`
      );
    });
}

អ្វីដែលវាផ្ទៀងផ្ទាត់៖

1. តម្រងនីមួយៗត្រូវបានផ្ទុក និងឆ្លងកាត់ការផ្ទៀងផ្ទាត់ schema
2. ធាតុនីមួយៗក្នុង tests[] បង្កើតលទ្ធផលដែលបានរំពឹងទុក
3. អាំងតង់ស៊ីតេ minimal មិនធ្វើប្រតិបត្តិការអ្វីឡើយ (រក្សាលទ្ធផលដើម និងអនុវត្តតែតម្រងតាមរចនាសម្ព័ន្ធប៉ុណ្ណោះ)
4. អាំងតង់ស៊ីតេ aggressive រក្សាកំហុស ភាពបរាជ័យនៃការធ្វើតេស្ត និង stack traces
5. លទ្ធផលដែលបានបង្ហាប់មិនដែលធំជាងទិន្នន័យបញ្ចូលដើមទេ

• ប្រភព៖ open-sse/services/compression/engines/rtk/ (63 ឯកសារ, ~70KB)

• មុនពេលបញ្ចូលការផ្លាស់ប្តូរតម្រងចូលគ្នា — ត្រូវធានាជានិច្ចថាការធ្វើតេស្តឆ្លងកាត់

• បន្ទាប់ពីដំឡើងកំណែ RTK engine — schema អាចត្រូវបានផ្លាស់ប្តូរ

• ជាប្រចាំក្នុងការត្រួតពិនិត្យ — ការពារទល់នឹងការប្រែប្រួលនៅក្នុង test fixtures

• នៅពេលបន្ថែម tool/command family ថ្មី — បញ្ជាក់ថាតម្រងថ្មីដំណើរការ

---

សូមមើលផងដែរ

• COMPRESSION_GUIDE.md — ទិដ្ឋភាពទូទៅពេញលេញនៃខ្សែដំណើរការបង្ហាប់
• COMPRESSION_ENGINES.md — បញ្ជីចុះឈ្មោះម៉ាស៊ីន និងម៉ាស៊ីនដែលមានស្រាប់
• EXTENDING_COMPRESSION.md — ម៉ាស៊ីនផ្ទាល់ខ្លួន កញ្ចប់ភាសា និងខ្សែដំណើរការដែលដាក់ជាស្រទាប់
• កូដប្រភព៖ open-sse/services/compression/engines/rtk/ (63 ឯកសារ, ~70KB)