@cortexkit/opencode-magic-context 0.41.0 → 0.41.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.41.0",
+  "version": "0.41.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -35,9 +35,10 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/*-*.js && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external @huggingface/transformers --external onnxruntime-web --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
+    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/transformers-web.js dist/transformers-node-wasm.js dist/*-*.js && bun build src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun scripts/build-transformers-node-wasm.ts dist && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
     "build:tui": "bun scripts/build-tui.ts",
     "check:tui-compiled": "bun run build:tui && git diff --exit-code -- src/tui-compiled && test -z \"$(git status --porcelain -- src/tui-compiled)\"",
+    "check:transformers-node-wasm": "bun scripts/verify-transformers-node-wasm.ts",
     "typecheck": "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
     "test": "bun install --frozen-lockfile && bun test --parallel --timeout 30000",
     "test:serial": "bun install --frozen-lockfile && bun test --timeout 30000",
@@ -51,7 +52,6 @@
   },
   "dependencies": {
     "@cortexkit/subc-client": "0.4.1",
-    "@huggingface/transformers": "^4.1.0",
     "@jitl/quickjs-singlefile-cjs-release-asyncify": "0.32.0",
     "@opencode-ai/plugin": "^1.17.11",
     "@opencode-ai/sdk": "^1.17.11",
@@ -65,8 +65,13 @@
     "solid-js": "1.9.12",
     "zod": "^4.1.8"
   },
+  "optionalDependencies": {
+    "onnxruntime-node": "1.24.3",
+    "sharp": "^0.35.0"
+  },
   "devDependencies": {
     "@ai-sdk/anthropic": "3.0.82",
+    "@huggingface/transformers": "^4.1.0",
     "@ai-sdk/openai-compatible": "2.0.41",
     "@biomejs/biome": "^2.5.1",
     "@types/better-sqlite3": "^7.6.13",

package/src/config/index.test.ts

@@ -2,7 +2,14 @@ import { describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+
 import { resolveHistorianModel } from "../shared/model-resolution";
+import { createTestTempDir } from "../shared/test-temp-dir";
+import {
+    getWindowOverlay,
+    reloadWindowOverlay,
+    setWindowOverlayPath,
+} from "../shared/window-geometry";
 import { loadPluginConfig, loadPluginConfigDetailed } from "./index";
 import { resolveConfigProfile } from "./profiles";
 import { DEFAULT_LOCAL_EMBEDDING_MODEL } from "./schema/magic-context";
@@ -111,6 +118,42 @@ function loadWithUserAndProjectConfig(
     }
 }
 
+describe("loadPluginConfig — Fusiform overlay reload", () => {
+    it("does not invalidate a same-path overlay during routine config reads", () => {
+        const overlayDir = mkdtempSync(join(tmpdir(), "mc-config-overlay-"));
+        const overlayPath = join(overlayDir, "window-overlay.json");
+        const configText = JSON.stringify({ models: { window_overlay_path: overlayPath } });
+        const writeOverlay = (modelId: string) =>
+            writeFileSync(
+                overlayPath,
+                JSON.stringify({
+                    schema: "fusiform-window-overlay/v1",
+                    generated_at: "2026-09-01T00:00:00Z",
+                    minted_provider_ids: [],
+                    cells: [{ provider_id: "hunt-provider", model_id: modelId, facts: {} }],
+                }),
+            );
+
+        try {
+            writeOverlay("before-rewrite");
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            writeOverlay("after-rewrite");
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            reloadWindowOverlay(overlayPath);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("after-rewrite");
+        } finally {
+            setWindowOverlayPath(undefined);
+            rmSync(overlayDir, { recursive: true, force: true });
+        }
+    });
+});
+
 describe("loadPluginConfig — preload user-config isolation", () => {
     it("resolves schema-default embedding config for a fixture with no config (#388)", () => {
         const projectDir = mkdtempSync(join(tmpdir(), "mc-config-preload-fixture-"));
@@ -121,6 +164,7 @@ describe("loadPluginConfig — preload user-config isolation", () => {
             expect(loadPluginConfig(projectDir).embedding).toEqual({
                 provider: "local",
                 model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                local_runtime: "auto",
             });
         } finally {
             rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
@@ -693,7 +737,8 @@ describe("loadPluginConfig — legacy agent enabled migration", () => {
 
 describe("loadPluginConfig — variable expansion scope", () => {
     it("keeps {env:} and {file:} expansion enabled for user config", () => {
-        const secretFile = join(mkdtempSync(join(tmpdir(), "mc-config-secret-")), "secret.txt");
+        const { dir: secretDir, cleanup } = createTestTempDir("mc-config-secret-");
+        const secretFile = join(secretDir, "secret.txt");
         writeFileSync(secretFile, "file-secret", "utf-8");
 
         try {
@@ -715,12 +760,13 @@ describe("loadPluginConfig — variable expansion scope", () => {
             }
             expect(result.configWarnings).toBeUndefined();
         } finally {
-            rmSync(secretFile, { force: true });
+            cleanup();
         }
     });
 
     it("leaves {env:} and {file:} tokens literal in project config and warns", () => {
-        const secretFile = join(mkdtempSync(join(tmpdir(), "mc-config-secret-")), "secret.txt");
+        const { dir: secretDir, cleanup } = createTestTempDir("mc-config-secret-");
+        const secretFile = join(secretDir, "secret.txt");
         writeFileSync(secretFile, "project-file-secret", "utf-8");
 
         try {
@@ -743,7 +789,7 @@ describe("loadPluginConfig — variable expansion scope", () => {
             expect(warnings).toContain("security reasons");
             expect(warnings).toContain("embedding.endpoint/provider");
         } finally {
-            rmSync(secretFile, { force: true });
+            cleanup();
         }
     });
 

package/src/config/latch-permanence-guard.test.ts

@@ -27,6 +27,11 @@ const KNOWN_SLOTS: Record<string, KnownSlot> = {
         classification: "VERDICT",
         reason: "Correct: a missing or unloadable native binding needs an install repair, which this process cannot observe.",
     },
+    "packages/plugin/src/features/magic-context/memory/embedding-local.ts:localEmbeddingProcessFailure":
+        {
+            classification: "DIAGNOSTIC",
+            reason: "Most-recent local runtime diagnostic: successful initialization and test reset both clear it; the separate runtime-mode slot owns the process verdict.",
+        },
     "packages/plugin/src/features/magic-context/memory/embedding-synapse.ts:sharedClientPromise": {
         classification: "VERDICT",
         reason: "DEFECT: a rejected connection promise remains shared after the daemon recovers.",

package/src/config/schema/magic-context.test.ts

@@ -30,6 +30,7 @@ describe("MagicContextConfigSchema", () => {
                 embedding: {
                     provider: "local",
                     model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                    local_runtime: "auto",
                 },
                 memory: {
                     enabled: true,
@@ -654,17 +655,35 @@ describe("MagicContextConfigSchema", () => {
             ).toThrow();
         });
 
+        it("defaults local embedding runtime to auto and accepts explicit overrides", () => {
+            expect(
+                MagicContextConfigSchema.parse({ embedding: { provider: "local" } }).embedding,
+            ).toMatchObject({ local_runtime: "auto" });
+            expect(
+                MagicContextConfigSchema.parse({
+                    embedding: { provider: "local", local_runtime: "wasm" },
+                }).embedding,
+            ).toMatchObject({ local_runtime: "wasm" });
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    embedding: { provider: "local", local_runtime: "unsafe" },
+                }).success,
+            ).toBe(false);
+        });
+
         it("accepts a configured local embedding dtype", () => {
             const result = MagicContextConfigSchema.parse({
                 embedding: {
                     provider: "local",
                     model: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+                    local_runtime: "auto",
                     local_dtype: "q8",
                 },
             });
             expect(result.embedding).toEqual({
                 provider: "local",
                 model: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+                local_runtime: "auto",
                 local_dtype: "q8",
             });
         });
@@ -676,6 +695,7 @@ describe("MagicContextConfigSchema", () => {
             expect(result.embedding).toEqual({
                 provider: "local",
                 model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                local_runtime: "auto",
             });
             expect("local_dtype" in result.embedding).toBe(false);
         });

package/src/config/schema/magic-context.ts

@@ -619,6 +619,12 @@ const BaseEmbeddingConfigSchema = z
             .describe(
                 "Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.",
             ),
+        local_runtime: z
+            .enum(["auto", "native", "wasm"])
+            .default("auto")
+            .describe(
+                "Local provider only: ONNX runtime selection. 'auto' uses native under Node and uses WASM under Bun versions before 1.4.0, where Bun's NAPI teardown race can panic on quit; native is restored automatically on Bun 1.4.0+. Set 'native' only to prefer speed while accepting that pre-1.4.0 Bun crash risk, or 'wasm' to avoid loading the native addon.",
+            ),
         local_dtype: z
             .enum([
                 "auto",
@@ -685,6 +691,7 @@ export const EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data)
         return {
             provider: "local" as const,
             model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+            local_runtime: data.local_runtime,
             ...(data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}),
             // local_dtype is spread CONDITIONALLY: omitting it when unset keeps
             // the identity byte-identical for the common no-dtype config, so
@@ -1161,6 +1168,7 @@ export const MagicContextConfigSchema = z
         embedding: EmbeddingConfigSchema.default({
             provider: "local",
             model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+            local_runtime: "auto",
         }).describe("Embedding provider configuration"),
         subc: z
             .object({

package/src/shared/conflict-detector.test.ts

@@ -1,10 +1,11 @@
 /// <reference types="bun-types" />
 
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+
 import { detectConflicts, resolveCompactionForBoot } from "./conflict-detector";
+import { cleanupTestTempDir, createTestTempDir } from "./test-temp-dir";
 
 /**
  * Regression tests for plugin-conflict detection. The previous substring-
@@ -13,13 +14,14 @@ import { detectConflicts, resolveCompactionForBoot } from "./conflict-detector";
  * a false-positive conflict warning. See issue #43.
  */
 describe("detectConflicts", () => {
+    let root: string;
     let projectDir: string;
     let userConfigDir: string;
     let homeDir: string;
     let originalEnv: Record<string, string | undefined>;
 
     beforeEach(() => {
-        const root = mkdtempSync(join(tmpdir(), "mc-conflict-"));
+        root = createTestTempDir("mc-conflict-").dir;
         projectDir = join(root, "project");
         mkdirSync(projectDir, { recursive: true });
         userConfigDir = join(root, "user-config", "opencode");
@@ -50,22 +52,7 @@ describe("detectConflicts", () => {
             if (v === undefined) delete process.env[k];
             else process.env[k] = v;
         }
-        // Test directories live under tmpdir(); cleanup is best-effort.
-        try {
-            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
-        try {
-            rmSync(userConfigDir, {
-                recursive: true,
-                force: true,
-                maxRetries: 10,
-                retryDelay: 100,
-            });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
+        cleanupTestTempDir(root);
     });
 
     function writeProjectConfig(plugins: Array<string | [string, unknown]>): void {

package/src/shared/conflict-fixer.test.ts

@@ -1,12 +1,13 @@
 /// <reference types="bun-types" />
 
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse as parseJsonc } from "comment-json";
+
 import { detectConflicts } from "./conflict-detector";
 import { fixConflicts } from "./conflict-fixer";
+import { cleanupTestTempDir, createTestTempDir } from "./test-temp-dir";
 
 const noOmoConflicts = {
     omoPreemptiveCompaction: false,
@@ -22,7 +23,7 @@ describe("fixConflicts", () => {
     let originalEnv: Record<string, string | undefined>;
 
     beforeEach(() => {
-        root = mkdtempSync(join(tmpdir(), "mc-conflict-fixer-"));
+        root = createTestTempDir("mc-conflict-fixer-").dir;
         projectDir = join(root, "project");
         userConfigDir = join(root, "user-config", "opencode");
         homeDir = join(root, "home");
@@ -44,11 +45,7 @@ describe("fixConflicts", () => {
             if (value === undefined) delete process.env[key];
             else process.env[key] = value;
         }
-        try {
-            rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
+        cleanupTestTempDir(root);
     });
 
     it("preserves JSONC comments and tuple plugin entries while removing canonical DCP", () => {

package/src/shared/index.ts

@@ -4,3 +4,4 @@ export * from "./normalize-sdk-response";
 export * from "./prompt-surface";
 export * from "./prompt-surface-runtime";
 export * from "./resolve-fallbacks";
+export * from "./summarize-child-stderr";

package/src/shared/logger.test.ts

@@ -18,49 +18,121 @@ type LoggerScenarioResult = {
     };
 };
 
+type RotationScenarioResult = {
+    firstCurrent: string;
+    firstPredecessorFirstByte: number;
+    current: string;
+    predecessorFirstByte: number;
+    predecessorSize: number;
+    currentSize: number;
+    currentMode: number;
+    predecessorMode: number;
+    files: string[];
+};
+
+type HotPathScenarioResult = {
+    statCalls: number;
+};
+
 const loggerScenario = `
-import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs";
 import * as path from "node:path";
+import { mock } from "bun:test";
 
 const root = process.env.LOGGER_SCENARIO_ROOT;
 const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
-if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+const scenario = process.env.LOGGER_SCENARIO;
+if (!root || !loggerModuleUrl || !scenario) {
+    throw new Error("logger scenario environment is incomplete");
+}
 
-const logger = await import(loggerModuleUrl);
 const logPath = path.join(root, "nested", "magic-context.log");
 process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
-logger.log("first");
-logger.log(
-    "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
-    { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
-);
-logger.flushLogger();
-const healthyDiagnostics = logger.getLoggerDiagnostics();
-
-const logDirectory = path.dirname(logPath);
-if (process.env.LOGGER_SCENARIO === "recovery") {
-    const { rmSync } = await import("node:fs");
-    rmSync(logDirectory, { recursive: true, force: true });
-    logger.log("second");
-    logger.flushLogger();
+let statCalls = 0;
+if (scenario === "hot-path") {
+    mock.module("node:fs", () => ({
+        ...fs,
+        statSync: (...args) => {
+            statCalls++;
+            return fs.statSync(...args);
+        },
+    }));
 }
 
-// A directory used as the file target makes append fail deterministically on every platform.
-const failedPath = path.join(root, "unwritable-log-target");
-const { mkdirSync } = await import("node:fs");
-mkdirSync(failedPath, { recursive: true });
-process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
-logger.log("failed write");
-logger.flushLogger();
-const failedDiagnostics = logger.getLoggerDiagnostics();
-
-const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
-console.log(JSON.stringify({
-    exists: existsSync(logPath),
-    content,
-    healthyDiagnostics,
-    failedDiagnostics,
-}));
+const logger = await import(loggerModuleUrl);
+
+if (scenario === "rotation") {
+    const maxLogBytes = 32 * 1024 * 1024;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "o"));
+    fs.chmodSync(logPath, 0o600);
+    fs.writeFileSync(logPath + ".1", "prior predecessor");
+
+    logger.log("after first rotation");
+    logger.flushLogger();
+    const firstCurrent = fs.readFileSync(logPath, "utf8");
+    const firstPredecessorFirstByte = fs.readFileSync(logPath + ".1")[0];
+
+    // Switch paths once so the logger rechecks the primary path after this
+    // external replacement, as a different plugin process would require.
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "n"));
+    process.env.MAGIC_CONTEXT_LOG_PATH = path.join(root, "alternate.log");
+    logger.log("alternate path");
+    logger.flushLogger();
+    process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+    logger.log("after second rotation");
+    logger.flushLogger();
+
+    const predecessorPath = logPath + ".1";
+    console.log(JSON.stringify({
+        firstCurrent,
+        firstPredecessorFirstByte,
+        current: fs.readFileSync(logPath, "utf8"),
+        predecessorFirstByte: fs.readFileSync(predecessorPath)[0],
+        predecessorSize: fs.statSync(predecessorPath).size,
+        currentSize: fs.statSync(logPath).size,
+        currentMode: fs.statSync(logPath).mode & 0o777,
+        predecessorMode: fs.statSync(predecessorPath).mode & 0o777,
+        files: fs.readdirSync(path.dirname(logPath)).filter((name) => name.startsWith("magic-context.log")).sort(),
+    }));
+} else if (scenario === "hot-path") {
+    for (let index = 0; index < 20; index++) {
+        logger.log("hot-path-" + index);
+        logger.flushLogger();
+    }
+    console.log(JSON.stringify({ statCalls }));
+} else {
+    logger.log("first");
+    logger.log(
+        "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
+        { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
+    );
+    logger.flushLogger();
+    const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+    const logDirectory = path.dirname(logPath);
+    if (scenario === "recovery") {
+        fs.rmSync(logDirectory, { recursive: true, force: true });
+        logger.log("second");
+        logger.flushLogger();
+    }
+
+    // A directory used as the file target makes append fail deterministically on every platform.
+    const failedPath = path.join(root, "unwritable-log-target");
+    fs.mkdirSync(failedPath, { recursive: true });
+    process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+    logger.log("failed write");
+    logger.flushLogger();
+    const failedDiagnostics = logger.getLoggerDiagnostics();
+
+    const content = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
+    console.log(JSON.stringify({
+        exists: fs.existsSync(logPath),
+        content,
+        healthyDiagnostics,
+        failedDiagnostics,
+    }));
+}
 `;
 
 const scenarioRoots: string[] = [];
@@ -71,9 +143,9 @@ afterEach(() => {
     }
 });
 
-async function runLoggerScenario(
-    scenario: "recovery" | "diagnostics",
-): Promise<LoggerScenarioResult> {
+async function runLoggerScenario<T>(
+    scenario: "recovery" | "diagnostics" | "rotation" | "hot-path",
+): Promise<T> {
     const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
     scenarioRoots.push(root);
     const child = Bun.spawn({
@@ -95,19 +167,19 @@ async function runLoggerScenario(
         new Response(child.stderr).text(),
     ]);
     expect(exitCode, stderr).toBe(0);
-    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+    return JSON.parse(stdout.trim()) as T;
 }
 
 describe("logger", () => {
     test("recreates a log directory removed while the process is running", async () => {
-        const result = await runLoggerScenario("recovery");
+        const result = await runLoggerScenario<LoggerScenarioResult>("recovery");
 
         expect(result.exists).toBe(true);
         expect(result.content).toContain("second");
     });
 
     test("redacts secrets while preserving numeric diagnostics", async () => {
-        const result = await runLoggerScenario("diagnostics");
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
 
         expect(result.content).toContain("tokens.input=45000");
         expect(result.content).toContain('"totalInputTokens":132000');
@@ -117,8 +189,31 @@ describe("logger", () => {
         expect(result.content).not.toContain("abcdefghijklmnop");
     });
 
+    test("rotates at the 32 MiB bound with one private predecessor", async () => {
+        const result = await runLoggerScenario<RotationScenarioResult>("rotation");
+        const maxLogBytes = 32 * 1024 * 1024;
+
+        expect(result.firstCurrent).toContain("after first rotation");
+        expect(result.firstPredecessorFirstByte).toBe("o".charCodeAt(0));
+        expect(result.current).toContain("after second rotation");
+        expect(result.predecessorFirstByte).toBe("n".charCodeAt(0));
+        expect(result.predecessorSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.currentSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.files).toEqual(["magic-context.log", "magic-context.log.1"]);
+        if (process.platform !== "win32") {
+            expect(result.currentMode).toBe(0o600);
+            expect(result.predecessorMode).toBe(0o600);
+        }
+    });
+
+    test("uses cached size between periodic rotation checks", async () => {
+        const result = await runLoggerScenario<HotPathScenarioResult>("hot-path");
+
+        expect(result.statCalls).toBeLessThanOrEqual(1);
+    });
+
     test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
-        const result = await runLoggerScenario("diagnostics");
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
 
         expect(result.healthyDiagnostics).toEqual({
             swallowedWriteCount: 0,