Grade muse-glimmer-28b full 7-prompt battery — new benchmark leader
7 entries (30→37 total). Muse Glimmer 28B (GGUF) avg 80.7 — the strongest model in the benchmark, 6/7 prompts Minor Logic Flaws: lfu 76 | webhook 81 | automation 89 | rust 85 | data 88 | tts 58 | mcp 88 Standout results: - rust 85 (KAT 36, Qwen3-Coder 54) — real tokio channels (mpsc::channel, not hallucinated mpsc::bounded), two-tier CancellationToken, zero clippy lints; one-line E0507 compile fix. - automation 89 — first model to print a correct summary (98/2/0/100); atomic temp+fsync+rename checkpointing. - data 88 edges out Gemma-26B's 86; mcp 88 sets the bar on a new prompt. Only weak spot: tts 58 (backpressure raises instead of awaits, like Qwen3-Coder). Captured via the native /api/v1/chat fix (real tok/sec + TTFT). Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Also gitignore checkpoint.json (automation test runtime artifact). Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Aygea
@@ -1041,6 +1041,240 @@
|
||||
"patch_code": "# 1. Add a real acquire-timeout / pool-exhaustion test:\nasync def test_pool_exhaustion():\n state = MockDatabaseState()\n pool = MockPool(max_size=5, state=state)\n held = [await pool.acquire() for _ in range(5)]\n try:\n with pytest.raises(PoolExhaustedError):\n await asyncio.wait_for(pool.acquire(), timeout=3.0)\n finally:\n for c in held: await c.release()\n assert pool.in_use == 0\n\n# 2. Derive in_use from the semaphore so the counter cannot drift:\n@property\ndef in_use(self) -> int:\n return self.max_size - self._semaphore._value",
|
||||
"timestamp": "2026-07-29T04:30:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-lfu",
|
||||
"prompt_id": "lfu",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "python",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-lfu.py",
|
||||
"tok_sec": 19.38,
|
||||
"ttft_sec": 3.55,
|
||||
"total_tokens": 9095,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": false,
|
||||
"total_score": 76,
|
||||
"breakdown": {
|
||||
"complexity": 18,
|
||||
"concurrency": 15,
|
||||
"isolation": 12,
|
||||
"memory_edge_cases": 16,
|
||||
"test_integrity": 15
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "The strongest LFU result from a non-coder model in this benchmark — nails true O(1) freq-bucket eviction with correct min_freq tracking and __slots__ where both specialist coder models (KAT, Qwen3-Coder) failed catastrophically. Let down by one signature bug: rollback() is sync but awaited.",
|
||||
"critical_bugs": [
|
||||
"rollback() is a sync method (line 213, 'def rollback') returning None, but the test awaits it (line 252, 'await tx2.rollback()') -> TypeError: object NoneType can't be used in 'await' expression. The whole test suite crashes at the rollback assertion. Fix: make it 'async def rollback()'.",
|
||||
"_update_min_freq walks min_freq upward indefinitely with no upper bound; harmless while the cache is non-empty but an unbounded loop on a fully-drained cache.",
|
||||
"No transaction lifecycle guard: after commit() or rollback(), a stale Transaction handle can still call put/get/delete/commit again (double-commit) with no error.",
|
||||
"Transaction.get/commit acquire self.cache.lock directly — transactions share the cache's single lock rather than an isolation lock; correct for the buffer model but couples tx lifetime to cache lock contention."
|
||||
],
|
||||
"patch_code": "# Fix 1 (fatal): rollback must be async to match 'await tx2.rollback()'\nasync def rollback(self):\n self.pending_puts.clear()\n self.pending_deletes.clear()\n\n# Fix 2: bound _update_min_freq against a drained cache\ndef _update_min_freq(self):\n if not self.freq_map:\n self.min_freq = 0; return\n while self.min_freq not in self.freq_map:\n self.min_freq += 1\n\n# Fix 3: lifecycle guard on Transaction\ndef __init__(self, cache):\n self.cache = cache; self.pending_puts = {}; self.pending_deletes = set(); self._closed = False\ndef _check_open(self):\n if self._closed: raise RuntimeError(\"Transaction already committed/rolled back\")\nasync def commit(self):\n self._check_open(); # ... existing body ...; self._closed = True\nasync def rollback(self):\n self._check_open(); self.pending_puts.clear(); self.pending_deletes.clear(); self._closed = True",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-webhook",
|
||||
"prompt_id": "webhook",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "python",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-webhook.py",
|
||||
"tok_sec": 18.96,
|
||||
"ttft_sec": 3.01,
|
||||
"total_tokens": 6628,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": false,
|
||||
"total_score": 81,
|
||||
"breakdown": {
|
||||
"schema_io": 17,
|
||||
"transport": 16,
|
||||
"error_handling": 16,
|
||||
"state_safety": 16,
|
||||
"test_integrity": 16
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "Carefully designed async webhook bridge with correct constant-time HMAC, monotonic-clock idempotency with 300s eviction, real token-bucket rate limiting gating Discord forwards (not intake), and single-retry 429 Retry-After backoff. Suitable for production after minor hardening. (The test-timeout is a harness/port issue, not a code defect — the request path is non-blocking.)",
|
||||
"critical_bugs": [
|
||||
"forward_log grows unbounded — no eviction or cap, memory leak in a long-running process.",
|
||||
"int(self.headers.get('Content-Length', 0)) raises unhandled ValueError on a non-numeric Content-Length header, causing socket close instead of a clean 400.",
|
||||
"No Content-Type or Content-Length headers on any response — clients relying on Content-Length cannot determine body end without connection close."
|
||||
],
|
||||
"patch_code": "# Fix 1: guard Content-Length parsing\ntry: length = int(self.headers.get('Content-Length', 0))\nexcept (ValueError, TypeError):\n self.send_response(400); self.end_headers(); self.wfile.write(b'Invalid Content-Length'); return\nbody = self.rfile.read(length)\n\n# Fix 2: cap forward_log growth\ncap = 10000\nwith log_lock:\n forward_log.append({'event_id': event_id, 'ts': time.monotonic()})\n if len(forward_log) > cap: del forward_log[:len(forward_log) - cap]\n\n# Fix 3: add Content-Type + Content-Length to responses\ndef _respond(self, code, body=b''):\n self.send_response(code)\n self.send_header('Content-Type', 'text/plain')\n self.send_header('Content-Length', str(len(body)))\n self.end_headers()\n if body: self.wfile.write(body)",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-automation",
|
||||
"prompt_id": "automation",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "python",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-automation.py",
|
||||
"tok_sec": 17.18,
|
||||
"ttft_sec": 3.44,
|
||||
"total_tokens": 9012,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": true,
|
||||
"total_score": 89,
|
||||
"breakdown": {
|
||||
"idempotency": 18,
|
||||
"retry_backoff": 19,
|
||||
"checkpointing": 19,
|
||||
"signal_handling": 16,
|
||||
"test_integrity": 17
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "Reliable production-grade async batch processing with atomic checkpointing (temp+fsync+rename) where correctness of summary output and crash-safe state matter more than raw throughput. First model in the benchmark to print a correct, meaningful automation summary (98/2/0/100).",
|
||||
"critical_bugs": [
|
||||
"No explicit checkpoint flush on the SIGINT exit path — relied on per-item save being always-current, which is correct, but a worker that crashes between process()-success and the lock/save block could lose a completed item's state on hard kill mid-critical-section (narrow window).",
|
||||
"Signal handling does not cancel in-flight tasks — a worker past the sem-acquire running process() at SIGINT time runs to completion including all retry/backoff sleeps (up to ~0.7s), delaying exit. Spec allows 'finish' but exit latency can exceed expectations under load.",
|
||||
"Test asserts convergence, concurrency, and corruption-freedom but does NOT assert that a rerun avoids re-invoking process() on already-completed items — the idempotency no-rework guarantee is structurally enforced by the pending filter but unverified by an explicit call-count-on-rerun assertion.",
|
||||
"Queue.task_done() is called but q.join() is never awaited — cosmetic dead code."
|
||||
],
|
||||
"patch_code": "# 1. Explicit checkpoint flush + clean exit on SIGINT\nasync def run_batch(items):\n try:\n await asyncio.gather(*workers, return_exceptions=True)\n finally:\n save_checkpoint(completed, failed) # explicit final flush covers the gap\n try: loop.remove_signal_handler(signal.SIGINT)\n except (NotImplementedError, RuntimeError): pass\n\n# 2. Cancel in-flight on SIGINT for prompt exit (add cooperative bail between retries)\nasync def handle_item(item, ...):\n async with sem:\n if stop_event.is_set(): return\n backoff = 0.1\n for attempt in range(3):\n if stop_event.is_set(): return # bail between retries\n try:\n await process(item)\n async with lock: completed.add(item); save_checkpoint(completed, failed)\n return\n except ProcessingError:\n if attempt == 2:\n async with lock: failed.add(item); save_checkpoint(completed, failed)\n return\n await asyncio.sleep(backoff); backoff *= 2\n\n# 3. Assert no-rework on rerun\nsecond_calls = {k: v for k, v in calls.items()}\nawait run_batch(items) # third run, all should skip\nreprocess = {k: calls[k]-second_calls[k] for k in calls if calls[k] > second_calls.get(k, 0)}\nassert not reprocess, f\"idempotency violated, reprocessed: {reprocess}\"",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-rust",
|
||||
"prompt_id": "rust",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "rust",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-rust.rs",
|
||||
"tok_sec": 16.98,
|
||||
"ttft_sec": 3.58,
|
||||
"total_tokens": 9201,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": false,
|
||||
"total_score": 85,
|
||||
"breakdown": {
|
||||
"ownership": 16,
|
||||
"concurrency": 18,
|
||||
"error_handling": 18,
|
||||
"cancellation": 17,
|
||||
"test_integrity": 16
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "Production-grade async Rust service design with real tokio channels (mpsc::channel(32), not hallucinated mpsc::bounded), two-tier CancellationToken shutdown, per-watcher error isolation with >5-strike unhealthy marking, and zero clippy lints. The strongest Rust result in the benchmark by a wide margin (KAT 36, Qwen3-Coder 54). One compile-blocker: a partial-move E0507 fixable with Option+take().",
|
||||
"critical_bugs": [
|
||||
"E0507 compile error at line 152: self.consumer_handle.await attempts a partial move of JoinHandle<Aggregated> out of &mut self — the code cannot compile or run as written. Fix: declare the field as Option<JoinHandle<Aggregated>> and use self.consumer_handle.take().unwrap().await.",
|
||||
"Logic bug at line 180: tokio::time::Instant::now().elapsed() creates an Instant then immediately calls .elapsed() on it, always producing ~0 nanoseconds — the timestamp field is semantically meaningless. Should capture a process-start Instant or use SystemTime::now().duration_since(UNIX_EPOCH) for epoch millis.",
|
||||
"No fn main() — as a bin target this fails to compile (E0601). Harmless if configured as a lib/test target, but the file as-is is incomplete."
|
||||
],
|
||||
"patch_code": "// Fix 1: wrap consumer_handle in Option + take() in shutdown\npub struct WatcherManager {\n pub(crate) consumer_handle: Option<JoinHandle<Aggregated>>, // was: JoinHandle<Aggregated>\n}\n// in new(): consumer_handle: Some(consumer_handle)\n// in shutdown():\npub async fn shutdown(&mut self) -> Aggregated {\n self.shutdown_token.cancel();\n let mut watchers = self.watchers.lock().await;\n let mut handles = Vec::new();\n for (_, meta) in watchers.drain() { meta.token.cancel(); handles.push(meta.handle); }\n drop(watchers);\n for h in handles { let _ = h.await; }\n let h = self.consumer_handle.take().expect(\"already shut down\");\n h.await.unwrap()\n}\n\n// Fix 2: meaningful timestamp\nuse std::time::{SystemTime, UNIX_EPOCH};\nts: SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_millis() as u64,\n// was: tokio::time::Instant::now().elapsed().as_millis() as u64\n\n// Fix 3: add fn main (or configure as lib target)\nfn main() {}",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-data",
|
||||
"prompt_id": "data",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "python",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-data.py",
|
||||
"tok_sec": 17.17,
|
||||
"ttft_sec": 3.84,
|
||||
"total_tokens": 7308,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": true,
|
||||
"total_score": 88,
|
||||
"breakdown": {
|
||||
"query_safety": 18,
|
||||
"pooling": 19,
|
||||
"transactions": 17,
|
||||
"pagination": 19,
|
||||
"test_integrity": 15
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "Clean parameterized queries throughout (zero interpolation, with a real injection-attempt test storing DROP TABLE as a literal label), semaphore-pooled concurrency with 100-call leak proof, proven pagination (true COUNT, last-page remainder, out-of-range=empty), and snapshot-based rollback verified on partial failure. Edges out Gemma-26B's 86 on the same prompt.",
|
||||
"critical_bugs": [
|
||||
"Missing acquire-timeout test: the pool supports asyncio.wait_for timeout but no test exhausts the pool to force TimeoutError — spec pillar 5 (acquire timeout) is unproven.",
|
||||
"Rollback in relabel_users is manual snapshot/restore, not a real BEGIN/COMMIT/ROLLBACK transaction — a failure during the restore loop would leave inconsistent state.",
|
||||
"MockConnection.fetch dispatch uses fragile substring matching ('FROM users WHERE id =' in query) that would misroute if a param were ever interpolated into the query string — safe only because params never are."
|
||||
],
|
||||
"patch_code": "# 1. Add forced-timeout test (fills the test_integrity gap)\nasync def test_acquire_timeout():\n pool = MockPool(max_size=2, acquire_timeout=0.1)\n svc = UserService(pool)\n hold = [await pool.acquire() for _ in range(2)] # exhaust\n try:\n await asyncio.wait_for(svc.get_users(1, 10), timeout=1.0)\n assert False, 'should have timed out'\n except (TimeoutError, asyncio.TimeoutError): pass\n finally:\n for c in hold: await c.release()\n assert pool.checked_out == 0\n\n# 2. Strengthen rollback — track applied writes and undo only those\napplied = []\ntry:\n for uid, label in pairs:\n await conn.execute('UPDATE users SET label = $1 WHERE id = $2', [label, uid])\n applied.append(uid)\n return len(pairs)\nexcept Exception:\n for uid in reversed(applied): MockDB.users[uid]['label'] = snapshot[uid]\n return 0",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-tts",
|
||||
"prompt_id": "tts",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "python",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-tts.py",
|
||||
"tok_sec": 17.09,
|
||||
"ttft_sec": 2.83,
|
||||
"total_tokens": 9639,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": true,
|
||||
"total_score": 58,
|
||||
"breakdown": {
|
||||
"complexity": 16,
|
||||
"concurrency": 6,
|
||||
"error_handling": 14,
|
||||
"resource_safety": 10,
|
||||
"test_integrity": 12
|
||||
},
|
||||
"verdict": "Critical Bugs",
|
||||
"best_for": "Retry-heavy async job pipelines where backpressure-await is not required and a hard queue-reject is acceptable — the one weak prompt in muse-glimmer's battery. Retry/backoff and callback handling are sound, but the central bounded-concurrency mechanic is wrong.",
|
||||
"critical_bugs": [
|
||||
"submit() raises RuntimeError('Backpressure: queue full') when the deque hits 100 items instead of AWAITING a free slot — the spec explicitly requires blocking backpressure, not rejection. Same central failure as Qwen3-Coder (which scored 44 for the same reason). The backpressure test compounds this by asserting the raise is correct behavior, encoding the bug rather than catching it.",
|
||||
"No shutdown/stop mechanism: the 4 worker tasks are infinite 'while True' loops with no way to cancel or join them. drain() busy-polls and returns, but the workers keep running forever — every TTSPipeline instance leaks 4 tasks.",
|
||||
"Soft-cancel does not interrupt a job already inside mock_synthesize: the cancelled flag is only checked before start and between retry attempts. A first-try-success job cancelled mid-flight still completes and emits 'completed', not 'cancelled'."
|
||||
],
|
||||
"patch_code": "# Fix 1 — backpressure by awaiting a slot, not raising.\nclass TTSPipeline:\n def __init__(self):\n self._slots = asyncio.Semaphore(4) # bounded concurrency at the gate\n self._max_queued = 100\n self._queue = collections.deque()\n self._queue_lock = asyncio.Lock()\n self._queue_not_full = asyncio.Condition(self._queue_lock)\n self._queue_not_empty = asyncio.Condition(self._queue_lock)\n async def submit(self, text, voice):\n job_id = uuid.uuid4().hex\n async with self._queue_lock:\n while len(self._queue) >= self._max_queued:\n await self._queue_not_full.wait() # BACKPRESSURE: await, never raise\n self._queue.append({'id': job_id, 'text': text, 'voice': voice})\n self._queue_not_empty.notify()\n return job_id\n # workers call self._queue_not_full.notify() after popleft()\n\n# Fix 2 — add a real shutdown so workers don't leak\n async def stop(self):\n for w in self._workers: w.cancel()\n await asyncio.gather(*self._workers, return_exceptions=True)\n self._workers.clear()\n\n# Fix 3 — correct the test to assert backpressure, not raise\n async def flood():\n for i in range(120): await slow.submit(f't{i}', 'v') # never raises\n await asyncio.wait_for(flood(), timeout=30) # completes once workers drain",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
},
|
||||
{
|
||||
"id": "muse-glimmer-28b-gguf-mcp",
|
||||
"prompt_id": "mcp",
|
||||
"model_name": "Muse Glimmer 28B",
|
||||
"quant": "GGUF",
|
||||
"param_size": "28B",
|
||||
"format": "gguf",
|
||||
"lang": "typescript",
|
||||
"filename": "outputs/muse-glimmer-28b-gguf-mcp.ts",
|
||||
"tok_sec": 20.2,
|
||||
"ttft_sec": 2.57,
|
||||
"total_tokens": 5244,
|
||||
"speed_caveat": "Slow deep-thinker: ~17-19 t/s, 5-9 min/prompt, ~5-9k tokens incl. reasoning. Fast for quality, not throughput.",
|
||||
"tests_pass": false,
|
||||
"total_score": 88,
|
||||
"breakdown": {
|
||||
"schema_io": 18,
|
||||
"transport": 20,
|
||||
"error_handling": 17,
|
||||
"state_safety": 18,
|
||||
"test_integrity": 15
|
||||
},
|
||||
"verdict": "Minor Logic Flaws",
|
||||
"best_for": "Clean, idiomatic single-file MCP server with REAL SDK wiring (no hallucinated APIs — correct @modelcontextprotocol/sdk imports, setRequestHandler on ListTools/CallTool, StdioServerTransport), Zod-validated tool schemas, timeout-safe fetches via AbortController, and isError-flag error responses instead of bare throws. First model tested on the mcp prompt; sets a high bar.",
|
||||
"critical_bugs": [
|
||||
"Output is JSON.stringify'd into a text content block rather than returned as structured typed content — spec explicitly asks for typed/structured output not raw strings.",
|
||||
"clearTimeout(timer) is called before res.json() in fetchJson, so a slow/stuck JSON body parse has no timeout guard.",
|
||||
"Test 404 case (b) logs 'PASS' in both the success and catch branches, making it a tautological always-pass assertion that doesn't verify error semantics.",
|
||||
"Tests call the *Impl functions directly, bypassing the MCP CallToolRequest handler — the schema-to-handler wiring, isError flag, and content-block formatting are never exercised."
|
||||
],
|
||||
"patch_code": "// 1. Return structured content instead of stringified JSON\ncase 'get_user': {\n const { id } = GetUserSchema.parse(args);\n const user = await getUserImpl(id);\n return { content: [{ type: 'text', text: JSON.stringify(user) }], structuredContent: user };\n}\n\n// 2. Keep timeout alive through JSON parse (move clearTimeout to finally)\nasync function fetchJson(url, timeoutMs = 8000) {\n const controller = new AbortController();\n const timer = setTimeout(() => controller.abort(), timeoutMs);\n try {\n const res = await fetch(url, { signal: controller.signal });\n if (!res.ok) throw new Error(`HTTP ${res.status} ${res.statusText}`);\n return await res.json();\n } catch (err) {\n if (err.name === 'AbortError') throw new Error('Request timed out');\n throw err;\n } finally {\n clearTimeout(timer); // single clear, covers all paths incl. slow json()\n }\n}\n\n// 3. Make 404 test actually assert error semantics\ntry {\n const r = await getUserImpl(9999);\n console.log('b) FAIL — expected throw, got', r);\n} catch (e) {\n console.log('b) 404 handled -> PASS:', e.message);\n}",
|
||||
"timestamp": "2026-08-10T20:00:00Z",
|
||||
"ttft_note": null
|
||||
}
|
||||
]
|
||||
}
|
||||
Reference in New Issue
Block a user