muonroi-cli 1.8.0 → 1.8.3

package/dist/src/ee/mistake-detector.test.js

@@ -1,221 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { _internals, MistakeDetector } from "./mistake-detector.js";
-describe("mistake-detector / tokenize + jaccard", () => {
-    it("tokenizes JSON tool input into normalized tokens", () => {
-        const tokens = _internals.tokenize({ file_path: "src/Foo.ts", lines: 42 });
-        expect(tokens.has("file_path")).toBe(true);
-        expect(tokens.has("src")).toBe(true);
-        expect(tokens.has("foo")).toBe(true);
-        expect(tokens.has("ts")).toBe(true);
-        expect(tokens.has("42")).toBe(true);
-    });
-    it("computes jaccard similarity correctly", () => {
-        const a = new Set(["a", "b", "c"]);
-        const b = new Set(["b", "c", "d"]);
-        expect(_internals.jaccardSimilarity(a, b)).toBeCloseTo(0.5, 3);
-    });
-    it("returns 1 when both sets are empty", () => {
-        expect(_internals.jaccardSimilarity(new Set(), new Set())).toBe(1);
-    });
-    it("returns 0 when one set is empty", () => {
-        expect(_internals.jaccardSimilarity(new Set(["a"]), new Set())).toBe(0);
-    });
-});
-describe("mistake-detector / path extraction", () => {
-    it("extracts file_path from Edit tool input", () => {
-        expect(_internals.extractFilePath("Edit", { file_path: "src/foo.ts" })).toBe("src/foo.ts");
-    });
-    it("extracts path from MCP edit_file tool input", () => {
-        expect(_internals.extractFilePath("mcp__filesystem__edit_file", { path: "src/foo.ts" })).toBe("src/foo.ts");
-    });
-    it("extracts path from lowercase write_file tool input", () => {
-        expect(_internals.extractFilePath("write_file", { path: "src/foo.ts", content: "x" })).toBe("src/foo.ts");
-    });
-    it("returns null for non-edit tools", () => {
-        expect(_internals.extractFilePath("Bash", { command: "ls" })).toBeNull();
-        expect(_internals.extractFilePath("Read", { file_path: "src/foo.ts" })).toBeNull();
-    });
-    it("normalizes Windows drive letters and backslashes", () => {
-        expect(_internals.extractFilePath("Edit", { file_path: "D:\\src\\Foo.ts" })).toBe("d:/src/Foo.ts");
-    });
-    it("returns null for missing/empty path", () => {
-        expect(_internals.extractFilePath("Edit", {})).toBeNull();
-        expect(_internals.extractFilePath("Edit", { file_path: "" })).toBeNull();
-    });
-});
-describe("mistake-detector / ring buffer", () => {
-    let det;
-    beforeEach(() => {
-        det = new MistakeDetector();
-    });
-    it("evicts oldest entry when ring exceeds 5", () => {
-        for (let i = 0; i < 7; i++) {
-            det.recordPreTool("Bash", { command: `echo ${i}` }, false);
-        }
-        const snap = det.snapshot();
-        expect(snap.ring.length).toBe(5);
-        const cmds = snap.ring.map((e) => e.toolInput.command);
-        expect(cmds).toEqual(["echo 2", "echo 3", "echo 4", "echo 5", "echo 6"]);
-    });
-    it("recordPostTool marks the latest matching unfinished entry", () => {
-        det.recordPreTool("Bash", { command: "ls" }, false);
-        det.recordPreTool("Bash", { command: "pwd" }, false);
-        det.recordPostTool("Bash", true);
-        const snap = det.snapshot();
-        expect(snap.ring[0].success).toBeUndefined();
-        expect(snap.ring[1].success).toBe(true);
-    });
-});
-describe("mistake-detector / retry-pattern", () => {
-    let det;
-    beforeEach(() => {
-        det = new MistakeDetector();
-    });
-    it("detects fail→success on similar args within lookback window", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, false);
-        det.recordPostTool("Edit", false);
-        det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, false);
-        det.recordPostTool("Edit", true);
-        const m = det.detectRetryPattern();
-        expect(m).not.toBeNull();
-        expect(m.kind).toBe("retry-pattern");
-        expect(m.toolName).toBe("Edit");
-        expect(m.evidence.similarity >= 0.7).toBe(true);
-    });
-    it("ignores when first attempt also succeeded (legitimate parallel calls)", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", true);
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", true);
-        expect(det.detectRetryPattern()).toBeNull();
-    });
-    it("ignores when current attempt failed", () => {
-        det.recordPreTool("Bash", { command: "npm test" }, false);
-        det.recordPostTool("Bash", false);
-        det.recordPreTool("Bash", { command: "npm test" }, false);
-        det.recordPostTool("Bash", false);
-        expect(det.detectRetryPattern()).toBeNull();
-    });
-    it("ignores when toolInputs are dissimilar", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", false);
-        det.recordPreTool("Edit", { file_path: "src/totally/different/bar.ts" }, false);
-        det.recordPostTool("Edit", true);
-        expect(det.detectRetryPattern()).toBeNull();
-    });
-    it("only looks back 3 turns", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", false);
-        for (let i = 0; i < 4; i++) {
-            det.recordPreTool("Bash", { command: `echo ${i}` }, false);
-            det.recordPostTool("Bash", true);
-        }
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", true);
-        expect(det.detectRetryPattern()).toBeNull();
-    });
-});
-describe("mistake-detector / file-revert", () => {
-    let det;
-    beforeEach(() => {
-        det = new MistakeDetector();
-    });
-    it("fires when current edit targets a prior-batch file that had warnings", () => {
-        // Prior batch: agent edits foo.ts with a warning surfaced.
-        det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, true);
-        det.recordPostTool("Edit", true);
-        // Turn boundary.
-        det.resetBatch();
-        // New turn: re-edit on same file → revert detected.
-        const events = det.detectFileRevert("Edit", { file_path: "src/foo.ts", old_string: "b", new_string: "c" });
-        expect(events.length).toBe(1);
-        expect(events[0].kind).toBe("user-veto");
-        expect(events[0].evidence.signal).toBe("file-revert");
-        expect(events[0].evidence.filePath).toBe("src/foo.ts");
-    });
-    it("emits one event per matching prior-batch entry on the same file", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        const events = det.detectFileRevert("Edit", { file_path: "src/foo.ts" });
-        expect(events.length).toBe(2);
-    });
-    it("skips when prior-batch entry on the same file had no warnings", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        expect(det.detectFileRevert("Edit", { file_path: "src/foo.ts" }).length).toBe(0);
-    });
-    it("skips when current edit is on a different file", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        expect(det.detectFileRevert("Edit", { file_path: "src/bar.ts" }).length).toBe(0);
-    });
-    it("matches across different edit tool variants on the same file", () => {
-        // Prior batch wrote with Write; current batch edits with mcp edit_file.
-        det.recordPreTool("Write", { file_path: "src/foo.ts", content: "x" }, true);
-        det.recordPostTool("Write", true);
-        det.resetBatch();
-        const events = det.detectFileRevert("mcp__filesystem__edit_file", { path: "src/foo.ts" });
-        expect(events.length).toBe(1);
-        expect(events[0].evidence.nextEditTool).toBe("mcp__filesystem__edit_file");
-    });
-    it("does not fire on the same-turn re-edit (only across turn boundary)", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-        det.recordPostTool("Edit", true);
-        // No resetBatch() — still same turn.
-        expect(det.detectFileRevert("Edit", { file_path: "src/foo.ts" }).length).toBe(0);
-    });
-    it("does not fire on non-edit tools (e.g. Read of the same file)", () => {
-        det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        expect(det.detectFileRevert("Read", { file_path: "src/foo.ts" }).length).toBe(0);
-    });
-});
-describe("mistake-detector / abort", () => {
-    let det;
-    beforeEach(() => {
-        det = new MistakeDetector();
-    });
-    it("emits one event per current-batch tool that had warnings", () => {
-        det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.recordPreTool("Edit", { file_path: "b.ts" }, true);
-        det.recordPostTool("Edit", true);
-        const events = det.detectAbort("user-pressed-esc");
-        expect(events.length).toBe(2);
-        expect(events.every((e) => e.kind === "user-veto")).toBe(true);
-        expect(events[0].evidence.signal).toBe("abort");
-        expect(events[0].evidence.reason).toBe("user-pressed-esc");
-    });
-    it("skips tools without warnings (avoid noise on unrelated abort)", () => {
-        det.recordPreTool("Bash", { command: "git status" }, false);
-        det.recordPostTool("Bash", true);
-        expect(det.detectAbort().length).toBe(0);
-    });
-    it("only fires for current batch — resetBatch clears", () => {
-        det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        expect(det.detectAbort().length).toBe(0);
-    });
-});
-describe("mistake-detector / resetBatch", () => {
-    it("captures prior batch and clears current", () => {
-        const det = new MistakeDetector();
-        det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-        det.recordPostTool("Edit", true);
-        det.resetBatch();
-        const snap = det.snapshot();
-        expect(snap.batch.length).toBe(0);
-        expect(snap.priorBatch.length).toBe(1);
-        expect(snap.priorBatch[0].toolName).toBe("Edit");
-        // Ring still preserved.
-        expect(snap.ring.length).toBe(1);
-    });
-});
-//# sourceMappingURL=mistake-detector.test.js.map

package/dist/src/ee/offline-queue.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ee/offline-queue.test.js

@@ -1,246 +0,0 @@
-/**
- * Unit + integration tests for offline-queue module.
- *
- * Tests cover all 10 behaviors:
- *  1. enqueue() creates queue directory lazily
- *  2. enqueue() writes correct JSON content
- *  3. enqueue() enforces 100-entry cap by deleting oldest
- *  4. getQueueDir() returns correct path
- *  5. drainQueue() replays entries in FIFO order
- *  6. drainQueue() stops on failure, leaves remaining entries
- *  7. drainQueue() handles non-existent queue directory
- *  8. drainQueue() discards corrupt JSON files
- *  9. Filename format matches /^\d+-[a-z0-9]{4}\.json$/
- * 10. drainQueue() is fire-and-forget (returns void)
- */
-import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { drainQueue, drainQueueAsync, enqueue, getQueueDir } from "./offline-queue.js";
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-let tmpDir;
-beforeEach(async () => {
-    // Create isolated temp directory for each test
-    const base = path.join(os.tmpdir(), "queue-test-");
-    // Use a unique timestamp+random suffix
-    const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-    tmpDir = base + suffix;
-    await mkdir(tmpDir, { recursive: true });
-});
-afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-/**
- * Helper: get the ee-offline-queue dir inside tmpDir.
- */
-function queueDir() {
-    return getQueueDir(tmpDir);
-}
-/**
- * Helper: write N pre-populated queue files with sequential timestamps.
- */
-async function populateQueue(count, startTs = 1000) {
-    const dir = queueDir();
-    await mkdir(dir, { recursive: true });
-    const filenames = [];
-    for (let i = 0; i < count; i++) {
-        const ts = startTs + i;
-        const filename = `${ts}-test.json`;
-        const entry = {
-            endpoint: "/api/feedback",
-            body: { i },
-            enqueuedAt: ts,
-        };
-        await writeFile(path.join(dir, filename), JSON.stringify(entry), "utf8");
-        filenames.push(filename);
-    }
-    return filenames;
-}
-// ─── Test 1: enqueue() creates queue directory lazily ─────────────────────────
-describe("enqueue()", () => {
-    it("creates the queue directory lazily on first call", async () => {
-        // Queue dir should NOT exist before enqueue
-        const dir = queueDir();
-        const files = await readdir(dir).catch(() => null);
-        expect(files).toBeNull(); // dir does not exist yet
-        // Call enqueue — should create dir
-        await enqueue({ endpoint: "/api/feedback", body: { test: 1 }, enqueuedAt: 1000 }, tmpDir);
-        // Dir should now exist
-        const filesAfter = await readdir(dir);
-        expect(Array.isArray(filesAfter)).toBe(true);
-    });
-    // ─── Test 9: Filename format ───────────────────────────────────────────────
-    it("creates exactly 1 file with correct filename pattern after one enqueue", async () => {
-        await enqueue({ endpoint: "/api/feedback", body: { test: 1 }, enqueuedAt: 1000 }, tmpDir);
-        const files = await readdir(queueDir());
-        expect(files).toHaveLength(1);
-        expect(files[0]).toMatch(/^\d+-[a-z0-9]{4}\.json$/);
-    });
-    // ─── Test 2: enqueue() writes correct JSON content ────────────────────────
-    it("writes correct JSON content matching the input entry", async () => {
-        const entry = {
-            endpoint: "/api/feedback",
-            body: { test: 1 },
-            enqueuedAt: 1000,
-        };
-        await enqueue(entry, tmpDir);
-        const dir = queueDir();
-        const files = await readdir(dir);
-        const raw = await import("node:fs/promises").then((fs) => fs.readFile(path.join(dir, files[0]), "utf8"));
-        const parsed = JSON.parse(raw);
-        expect(parsed).toEqual(entry);
-    });
-    // ─── Test 3: enqueue() enforces 100-entry cap ─────────────────────────────
-    it("enforces 100-entry cap: deletes oldest when queue is at capacity", async () => {
-        // Pre-populate with exactly 100 files
-        const existing = await populateQueue(100, 1000);
-        const oldestFile = existing[0]; // timestamp 1000-test.json
-        // Enqueue one more entry
-        await enqueue({
-            endpoint: "/api/feedback",
-            body: { new: true },
-            enqueuedAt: 99999,
-        }, tmpDir);
-        const files = await readdir(queueDir());
-        // Should still have exactly 100 files
-        expect(files).toHaveLength(100);
-        // Oldest file should be gone
-        expect(files).not.toContain(oldestFile);
-        // New file should exist (it has a fresh timestamp prefix via makeFilename())
-        const newFiles = files.filter((f) => !existing.includes(f));
-        expect(newFiles).toHaveLength(1);
-    });
-});
-// ─── Test 4: getQueueDir() returns correct path ───────────────────────────────
-describe("getQueueDir()", () => {
-    it("returns path under os.homedir() when no override given", () => {
-        const result = getQueueDir();
-        expect(result).toBe(path.join(os.homedir(), ".muonroi-cli", "ee-offline-queue"));
-    });
-    it("returns path under homeOverride when provided", () => {
-        const result = getQueueDir("/tmp/test");
-        expect(result).toBe(path.join("/tmp/test", ".muonroi-cli", "ee-offline-queue"));
-    });
-});
-// ─── Test 5: drainQueue() replays entries in FIFO order ───────────────────────
-describe("drainQueueAsync()", () => {
-    it("replays entries in FIFO order and deletes them after success", async () => {
-        // Pre-populate 3 entries with distinct timestamps
-        await populateQueue(3, 1000);
-        const stub = await startStubEEServer({ feedback: () => { } });
-        try {
-            await drainQueueAsync(fetch, { "Content-Type": "application/json" }, `http://127.0.0.1:${stub.port}`, tmpDir);
-            // 3 requests received in order
-            expect(stub.calls.feedback).toHaveLength(3);
-            expect(stub.calls.feedback[0].enqueuedAt ?? stub.calls.feedback[0].i).toBeDefined();
-            // FIFO: first enqueued (ts=1000) should come first
-            const receivedEnqueuedAts = stub.calls.feedback.map((b) => b.enqueuedAt ?? b.i);
-            expect(receivedEnqueuedAts[0]).toBeLessThan(receivedEnqueuedAts[1]);
-            expect(receivedEnqueuedAts[1]).toBeLessThan(receivedEnqueuedAts[2]);
-            // All files deleted after successful replay
-            const remainingFiles = await readdir(queueDir()).catch(() => []);
-            expect(remainingFiles).toHaveLength(0);
-        }
-        finally {
-            await stub.stop();
-        }
-    });
-    // ─── Test 6: drainQueue() stops on failure, leaves remaining ──────────────
-    it("stops on 2nd entry failure and leaves 2nd + 3rd entries on disk", async () => {
-        await populateQueue(3, 1000);
-        let _callCount = 0;
-        const stub = await startStubEEServer({
-            feedback: () => {
-                _callCount++;
-            },
-        });
-        // Override the server to return 500 on 2nd call
-        // We'll track calls and use a custom stub that serves 500 on 2nd request
-        await stub.stop();
-        // Build a minimal stub that returns 500 on 2nd POST to /api/feedback
-        const { createServer } = await import("node:http");
-        let reqCount = 0;
-        const customServer = createServer((req, res) => {
-            if (req.url === "/api/feedback" && req.method === "POST") {
-                reqCount++;
-                const chunks = [];
-                req.on("data", (c) => chunks.push(c));
-                req.on("end", () => {
-                    if (reqCount === 2) {
-                        res.writeHead(500);
-                        res.end("error");
-                    }
-                    else {
-                        res.writeHead(200);
-                        res.end("ok");
-                    }
-                });
-            }
-            else {
-                res.writeHead(404);
-                res.end();
-            }
-        });
-        await new Promise((resolve) => customServer.listen(0, "127.0.0.1", () => resolve()));
-        const addr = customServer.address();
-        const port = typeof addr === "object" && addr ? addr.port : 0;
-        try {
-            await drainQueueAsync(fetch, { "Content-Type": "application/json" }, `http://127.0.0.1:${port}`, tmpDir);
-            // 1st success, 2nd failure → should have made 2 requests total
-            expect(reqCount).toBe(2);
-            // 2nd and 3rd files remain on disk (1st was deleted on success)
-            const remainingFiles = await readdir(queueDir());
-            expect(remainingFiles).toHaveLength(2);
-        }
-        finally {
-            await new Promise((resolve) => customServer.close(() => resolve()));
-        }
-    });
-    // ─── Test 7: drainQueue() handles non-existent queue directory ────────────
-    it("returns cleanly when queue directory does not exist", async () => {
-        // No queue dir created — just call drainQueueAsync with a fresh tmpDir
-        await expect(drainQueueAsync(fetch, { "Content-Type": "application/json" }, "http://127.0.0.1:9999", tmpDir)).resolves.toBeUndefined();
-    });
-    // ─── Test 8: drainQueue() discards corrupt JSON files ─────────────────────
-    it("discards corrupt JSON files and replays valid entries after them", async () => {
-        const dir = queueDir();
-        await mkdir(dir, { recursive: true });
-        // Write corrupt file first (older timestamp)
-        const corruptFile = "1000-bad1.json";
-        await writeFile(path.join(dir, corruptFile), "NOT VALID JSON {{{{", "utf8");
-        // Write valid entry after (newer timestamp)
-        const validEntry = {
-            endpoint: "/api/feedback",
-            body: { valid: true },
-            enqueuedAt: 2000,
-        };
-        await writeFile(path.join(dir, "2000-good.json"), JSON.stringify(validEntry), "utf8");
-        const stub = await startStubEEServer({ feedback: () => { } });
-        try {
-            await drainQueueAsync(fetch, { "Content-Type": "application/json" }, `http://127.0.0.1:${stub.port}`, tmpDir);
-            // Corrupt file should be deleted
-            const remaining = await readdir(dir);
-            expect(remaining).not.toContain(corruptFile);
-            // Valid entry should have been replayed
-            expect(stub.calls.feedback).toHaveLength(1);
-            expect(stub.calls.feedback[0]).toEqual(validEntry.body);
-            // Valid file should be deleted after replay
-            expect(remaining).toHaveLength(0);
-        }
-        finally {
-            await stub.stop();
-        }
-    });
-});
-// ─── Test 10: drainQueue() is fire-and-forget ─────────────────────────────────
-describe("drainQueue() fire-and-forget wrapper", () => {
-    it("returns void (undefined), not a Promise", () => {
-        // Call drainQueue (the fire-and-forget wrapper) — should return undefined immediately
-        const result = drainQueue(fetch, { "Content-Type": "application/json" }, "http://127.0.0.1:9999", tmpDir);
-        // drainQueue() must return void (undefined), not a Promise
-        expect(result).toBeUndefined();
-    });
-});
-//# sourceMappingURL=offline-queue.test.js.map

package/dist/src/ee/phase-outcome.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ee/phase-outcome.test.js

@@ -1,94 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { _resetPhaseOutcomeState, fireAndForgetPhaseOutcome, firePhaseOutcome, } from "./phase-outcome.js";
-function makeStubFetch(handler) {
-    return (input, init) => {
-        const url = typeof input === "string" ? input : input.toString();
-        return Promise.resolve(handler(url, init ?? {}));
-    };
-}
-const samplePayload = {
-    sessionId: "sid-1",
-    phaseName: "implement",
-    outcome: "pass",
-    toolEventIds: [{ collection: "code", pointId: "p1" }],
-};
-describe("firePhaseOutcome", () => {
-    beforeEach(() => _resetPhaseOutcomeState());
-    afterEach(() => _resetPhaseOutcomeState());
-    it("posts to /api/phase-outcome with JSON body and returns parsed result", async () => {
-        let receivedUrl = "";
-        let receivedBody = "";
-        const stubFetch = makeStubFetch(async (url, init) => {
-            receivedUrl = url;
-            receivedBody = String(init.body ?? "");
-            return new Response(JSON.stringify({ ok: true, applied: 1, skipped: 0 }), {
-                status: 200,
-                headers: { "Content-Type": "application/json" },
-            });
-        });
-        const result = await firePhaseOutcome(samplePayload, {
-            baseUrl: "http://x:1",
-            fetchImpl: stubFetch,
-        });
-        expect(receivedUrl).toBe("http://x:1/api/phase-outcome");
-        expect(JSON.parse(receivedBody).sessionId).toBe("sid-1");
-        expect(result).toEqual({ ok: true, applied: 1, skipped: 0 });
-    });
-    it("returns null when server responds 404 (endpoint disabled)", async () => {
-        const stubFetch = makeStubFetch(async () => new Response("not found", { status: 404 }));
-        const result = await firePhaseOutcome(samplePayload, {
-            fetchImpl: stubFetch,
-        });
-        expect(result).toBeNull();
-    });
-    it("returns null and warns once on non-404 error", async () => {
-        const warnings = [];
-        const origWarn = console.warn;
-        console.warn = (msg) => warnings.push(msg);
-        try {
-            const stubFetch = makeStubFetch(async () => new Response("boom", { status: 500 }));
-            const r1 = await firePhaseOutcome(samplePayload, {
-                fetchImpl: stubFetch,
-            });
-            const r2 = await firePhaseOutcome(samplePayload, {
-                fetchImpl: stubFetch,
-            });
-            expect(r1).toBeNull();
-            expect(r2).toBeNull();
-            expect(warnings.length).toBe(1);
-        }
-        finally {
-            console.warn = origWarn;
-        }
-    });
-    it("returns null on network error", async () => {
-        const stubFetch = (() => Promise.reject(new Error("network down")));
-        const result = await firePhaseOutcome(samplePayload, {
-            fetchImpl: stubFetch,
-        });
-        expect(result).toBeNull();
-    });
-    it("includes Authorization header when authToken provided", async () => {
-        let authHeader = null;
-        const stubFetch = makeStubFetch(async (_url, init) => {
-            const headers = init.headers;
-            authHeader = headers.Authorization;
-            return new Response(JSON.stringify({ ok: true }), { status: 200 });
-        });
-        await firePhaseOutcome(samplePayload, {
-            fetchImpl: stubFetch,
-            authToken: "secret-token",
-        });
-        expect(authHeader).toBe("Bearer secret-token");
-    });
-});
-describe("fireAndForgetPhaseOutcome", () => {
-    beforeEach(() => _resetPhaseOutcomeState());
-    it("does not throw on rejection", () => {
-        const stubFetch = (() => Promise.reject(new Error("nope")));
-        expect(() => {
-            fireAndForgetPhaseOutcome(samplePayload, { fetchImpl: stubFetch });
-        }).not.toThrow();
-    });
-});
-//# sourceMappingURL=phase-outcome.test.js.map

package/dist/src/ee/phase-tracker.test.d.ts

@@ -1 +0,0 @@
-export {};