pi-harness-runtime 1.1.440 → 1.1.441

package/packages/cookie-sanitizer/test/infer.test.ts

@@ -1,110 +0,0 @@
-/**
- * Provider inference tests.
- *
- * Three inference passes:
- *   1. filename hint
- *   2. dominant domain (>= 80%)
- *   3. null
- *
- * The `hint` parameter overrides all of the above.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	inferProvider,
-	inferProviderFromFilename,
-	inferProviderFromCookies,
-	knownProviders,
-} from "../src/infer-provider.js";
-import type { CanonicalCookie } from "../src/types.js";
-
-function cookie(domain: string, name = "n"): CanonicalCookie {
-	return {
-		name,
-		value: "v",
-		domain,
-		path: "/",
-		secure: false,
-		httpOnly: false,
-	};
-}
-
-describe("inferProviderFromFilename", () => {
-	it("matches known providers by name fragment", () => {
-		expect(inferProviderFromFilename("minimax-cookies.txt")).toBe("minimax");
-		expect(inferProviderFromFilename("anthropic-session.json")).toBe(
-			"anthropic",
-		);
-		expect(inferProviderFromFilename("openai-tokens.json")).toBe("openai");
-		expect(inferProviderFromFilename("glm-export.json")).toBe("glm");
-	});
-
-	it("returns null for unknown names", () => {
-		expect(inferProviderFromFilename("random-export.json")).toBe(null);
-		expect(inferProviderFromFilename("")).toBe(null);
-	});
-});
-
-describe("inferProviderFromCookies", () => {
-	it("returns provider when ≥ 80% of cookies match one domain", () => {
-		const cookies = [
-			cookie(".minimax.io"),
-			cookie("platform.minimax.io"),
-			cookie(".minimax.io"),
-			cookie(".minimax.io"),
-			cookie(".other.com", "x"),
-		];
-		// 4/5 = 80% → matches minimax
-		expect(inferProviderFromCookies(cookies)).toBe("minimax");
-	});
-
-	it("returns null when no single provider dominates", () => {
-		const cookies = [
-			cookie(".minimax.io", "a"),
-			cookie(".anthropic.com", "b"),
-			cookie(".openai.com", "c"),
-		];
-		expect(inferProviderFromCookies(cookies)).toBe(null);
-	});
-
-	it("returns null for empty input", () => {
-		expect(inferProviderFromCookies([])).toBe(null);
-	});
-});
-
-describe("inferProvider (combined)", () => {
-	it("explicit hint wins over everything", () => {
-		const cookies = [cookie(".minimax.io")];
-		expect(inferProvider("anthropic.json", cookies, "openai")).toBe("openai");
-	});
-
-	it("filename hint wins over domain inference", () => {
-		const cookies = [cookie(".openai.com")];
-		expect(inferProvider("minimax-2026.json", cookies)).toBe("minimax");
-	});
-
-	it("falls through to domain inference when no filename match", () => {
-		const cookies = [
-			cookie(".anthropic.com"),
-			cookie(".anthropic.com"),
-			cookie(".anthropic.com"),
-			cookie(".anthropic.com"),
-		];
-		expect(inferProvider("random.txt", cookies)).toBe("anthropic");
-	});
-
-	it("returns null when nothing matches", () => {
-		expect(inferProvider("random.txt", [cookie(".other.com")])).toBe(null);
-	});
-});
-
-describe("knownProviders", () => {
-	it("returns at least the bundled providers", () => {
-		const providers = knownProviders();
-		expect(providers).toContain("minimax");
-		expect(providers).toContain("anthropic");
-		expect(providers).toContain("openai");
-		expect(providers).toContain("glm");
-		expect(providers).toContain("openrouter");
-	});
-});

package/packages/cookie-sanitizer/test/normalize.test.ts

@@ -1,113 +0,0 @@
-/**
- * Normalization tests — dedupe, expire, domain-match, tag.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	normalize,
-	domainMatchesProvider,
-	isExpired,
-} from "../src/normalize.js";
-import type { CanonicalCookie } from "../src/types.js";
-
-const NOW = 1_700_000_000;
-
-function cookie(over: Partial<CanonicalCookie> = {}): CanonicalCookie {
-	return {
-		name: "n1",
-		value: "v1",
-		domain: ".minimax.io",
-		path: "/",
-		secure: false,
-		httpOnly: false,
-		...over,
-	};
-}
-
-describe("domainMatchesProvider", () => {
-	it("matches minimax subdomains", () => {
-		expect(domainMatchesProvider(".minimax.io", "minimax")).toBe(true);
-		expect(domainMatchesProvider("platform.minimax.io", "minimax")).toBe(true);
-	});
-
-	it("rejects unrelated domains", () => {
-		expect(domainMatchesProvider(".example.com", "minimax")).toBe(false);
-	});
-
-	it("accepts all domains for unknown provider (let downstream reject)", () => {
-		expect(domainMatchesProvider(".anything.tld", "weird-provider")).toBe(true);
-	});
-});
-
-describe("isExpired", () => {
-	it("returns false for session cookies", () => {
-		expect(isExpired(cookie({ expires: undefined }), NOW)).toBe(false);
-		expect(isExpired(cookie({ expires: 0 }), NOW)).toBe(false);
-	});
-
-	it("returns true for past timestamps", () => {
-		expect(isExpired(cookie({ expires: NOW - 1 }), NOW)).toBe(true);
-	});
-
-	it("returns false for future timestamps", () => {
-		expect(isExpired(cookie({ expires: NOW + 1 }), NOW)).toBe(false);
-	});
-});
-
-describe("normalize", () => {
-	it("dedupes by (domain, name); last wins", () => {
-		const input: CanonicalCookie[] = [
-			cookie({ name: "n", value: "v1" }),
-			cookie({ name: "n", value: "v2" }),
-		];
-		const out = normalize(input, "minimax", NOW);
-		expect(out).toHaveLength(1);
-		expect(out[0]?.value).toBe("v2");
-	});
-
-	it("drops empty name/value", () => {
-		const input: CanonicalCookie[] = [
-			cookie({ name: "" }),
-			cookie({ value: "" }),
-			cookie({ name: "ok", value: "v" }),
-		];
-		const out = normalize(input, "minimax", NOW);
-		expect(out).toHaveLength(1);
-		expect(out[0]?.name).toBe("ok");
-	});
-
-	it("drops expired cookies", () => {
-		const input: CanonicalCookie[] = [
-			cookie({ expires: NOW - 100 }),
-			cookie({ expires: NOW + 100 }),
-		];
-		const out = normalize(input, "minimax", NOW);
-		expect(out).toHaveLength(1);
-		expect(out[0]?.expires).toBe(NOW + 100);
-	});
-
-	it("drops cookies whose domain doesn't match provider", () => {
-		const input: CanonicalCookie[] = [
-			cookie({ domain: ".minimax.io" }),
-			cookie({ domain: ".other.com", name: "other" }),
-		];
-		const out = normalize(input, "minimax", NOW);
-		expect(out).toHaveLength(1);
-		expect(out[0]?.domain).toBe(".minimax.io");
-	});
-
-	it("tags each surviving cookie with the provider", () => {
-		const input: CanonicalCookie[] = [
-			cookie({ name: "n1" }),
-			cookie({ name: "n2" }),
-		];
-		const out = normalize(input, "minimax", NOW);
-		for (const c of out) {
-			expect(c.provider).toBe("minimax");
-		}
-	});
-
-	it("returns empty array on empty input", () => {
-		expect(normalize([], "minimax", NOW)).toEqual([]);
-	});
-});

package/packages/cookie-sanitizer/test/parse.test.ts

@@ -1,204 +0,0 @@
-/**
- * Parser tests — Netscape + EditThisCookie JSON.
- *
- * Critical: never put real cookie VALUES in test fixtures. We use
- * obvious test values like "test-value" or short synthetic strings
- * to keep secrets hygiene.
- */
-
-import { describe, it, expect } from "bun:test";
-import { parseNetscape, serializeNetscape } from "../src/parse-netscape.js";
-import { parseEditThisCookieJson } from "../src/parse-json.js";
-import type { CanonicalCookie } from "../src/types.js";
-
-describe("parseNetscape", () => {
-	it("parses a standard 7-column row", () => {
-		const text = [
-			"# Netscape HTTP Cookie File",
-			"# https://curl.haxx.se/rfc/cookie_spec.html",
-			"# This is a generated file! Do not edit.",
-			"",
-			"#HttpOnly_.minimax.io\tTRUE\t/\tTRUE\t0\ttest_token\ttest-value",
-			".minimax.io\tFALSE\t/\tFALSE\t0\ttest_id\ttest-id-value",
-		].join("\n");
-		const cookies = parseNetscape(text);
-		expect(cookies).toHaveLength(2);
-		expect(cookies[0]?.name).toBe("test_token");
-		expect(cookies[0]?.value).toBe("test-value");
-		expect(cookies[0]?.httpOnly).toBe(true);
-		expect(cookies[0]?.secure).toBe(true);
-		expect(cookies[1]?.name).toBe("test_id");
-		expect(cookies[1]?.httpOnly).toBe(false);
-		expect(cookies[1]?.secure).toBe(false);
-	});
-
-	it("skips malformed rows (< 7 cols)", () => {
-		const text = [
-			"# Netscape HTTP Cookie File",
-			".minimax.io\tTRUE\t/\tTRUE", // only 4 cols
-			".minimax.io\tTRUE\t/\tTRUE\t0\tname\tvalue", // OK
-		].join("\n");
-		const cookies = parseNetscape(text);
-		expect(cookies).toHaveLength(1);
-		expect(cookies[0]?.name).toBe("name");
-	});
-
-	it("skips blank lines and comment-only lines", () => {
-		const text = [
-			"",
-			"# comment",
-			"#HttpOnly_.minimax.io\tTRUE\t/\tTRUE\t0\tn1\tv1",
-			"",
-		].join("\n");
-		const cookies = parseNetscape(text);
-		expect(cookies).toHaveLength(1);
-		expect(cookies[0]?.name).toBe("n1");
-	});
-
-	it("returns empty array for empty input", () => {
-		expect(parseNetscape("")).toEqual([]);
-		expect(parseNetscape("not a real file")).toEqual([]);
-	});
-
-	it("treats expires=0 as session cookie (undefined)", () => {
-		const text = ".minimax.io\tFALSE\t/\tFALSE\t0\tn1\tv1";
-		const cookies = parseNetscape(text);
-		expect(cookies[0]?.expires).toBeUndefined();
-	});
-
-	it("preserves non-zero expires as a number", () => {
-		const text = ".minimax.io\tFALSE\t/\tFALSE\t1700000000\tn1\tv1";
-		const cookies = parseNetscape(text);
-		expect(cookies[0]?.expires).toBe(1700000000);
-	});
-});
-
-describe("serializeNetscape", () => {
-	it("round-trips a single cookie", () => {
-		const cookies: CanonicalCookie[] = [
-			{
-				name: "n1",
-				value: "v1",
-				domain: ".minimax.io",
-				path: "/",
-				secure: true,
-				httpOnly: true,
-				expires: 0,
-			},
-		];
-		const out = serializeNetscape(cookies);
-		const back = parseNetscape(out);
-		expect(back).toHaveLength(1);
-		expect(back[0]?.name).toBe("n1");
-		expect(back[0]?.value).toBe("v1");
-		expect(back[0]?.httpOnly).toBe(true);
-	});
-
-	it("emits the canonical header on every output", () => {
-		const out = serializeNetscape([]);
-		expect(out).toContain("# Netscape HTTP Cookie File");
-	});
-
-	it("drops cookies with empty name or value", () => {
-		const cookies: CanonicalCookie[] = [
-			{
-				name: "",
-				value: "v",
-				domain: ".x.io",
-				path: "/",
-				secure: false,
-				httpOnly: false,
-			},
-			{
-				name: "n",
-				value: "",
-				domain: ".x.io",
-				path: "/",
-				secure: false,
-				httpOnly: false,
-			},
-			{
-				name: "ok",
-				value: "v",
-				domain: ".x.io",
-				path: "/",
-				secure: false,
-				httpOnly: false,
-			},
-		];
-		const out = serializeNetscape(cookies);
-		const back = parseNetscape(out);
-		expect(back).toHaveLength(1);
-		expect(back[0]?.name).toBe("ok");
-	});
-});
-
-describe("parseEditThisCookieJson", () => {
-	it("parses a Chrome devtools / EditThisCookie export array", () => {
-		const text = JSON.stringify([
-			{
-				domain: ".minimax.io",
-				expirationDate: 1700000000,
-				hostOnly: false,
-				httpOnly: true,
-				name: "test_token",
-				path: "/",
-				secure: true,
-				session: false,
-				value: "test-value",
-			},
-		]);
-		const cookies = parseEditThisCookieJson(text);
-		expect(cookies).toHaveLength(1);
-		expect(cookies[0]?.name).toBe("test_token");
-		expect(cookies[0]?.httpOnly).toBe(true);
-		expect(cookies[0]?.expires).toBe(1700000000);
-	});
-
-	it("parses a single object (not array)", () => {
-		const text = JSON.stringify({
-			domain: ".minimax.io",
-			expirationDate: 1700000000,
-			name: "n1",
-			value: "v1",
-			secure: true,
-			httpOnly: false,
-		});
-		const cookies = parseEditThisCookieJson(text);
-		expect(cookies).toHaveLength(1);
-		expect(cookies[0]?.name).toBe("n1");
-	});
-
-	it("treats millisecond timestamps as such (>1e12)", () => {
-		const ms = 1700000000000; // ms, not sec
-		const text = JSON.stringify([
-			{ name: "n", value: "v", expirationDate: ms },
-		]);
-		const cookies = parseEditThisCookieJson(text);
-		expect(cookies[0]?.expires).toBe(Math.floor(ms / 1000));
-	});
-
-	it("treats session=true as undefined expires", () => {
-		const text = JSON.stringify([
-			{ name: "n", value: "v", session: true, expirationDate: 9999 },
-		]);
-		const cookies = parseEditThisCookieJson(text);
-		expect(cookies[0]?.expires).toBeUndefined();
-	});
-
-	it("skips records with empty name or value", () => {
-		const text = JSON.stringify([
-			{ name: "", value: "v", domain: ".x.io" },
-			{ name: "n", value: "", domain: ".x.io" },
-			{ name: "ok", value: "v", domain: ".x.io" },
-		]);
-		const cookies = parseEditThisCookieJson(text);
-		expect(cookies).toHaveLength(1);
-		expect(cookies[0]?.name).toBe("ok");
-	});
-
-	it("returns [] on invalid JSON", () => {
-		expect(parseEditThisCookieJson("not json")).toEqual([]);
-		expect(parseEditThisCookieJson("")).toEqual([]);
-	});
-});

package/packages/cookie-sanitizer/test/sync.test.ts

@@ -1,237 +0,0 @@
-/// <reference types="bun-types" />
-/**
- * End-to-end sync tests.
- *
- * Build a synthetic drop folder in a tmp dir, call sync(), assert
- * the canonical cache was written correctly. No real cookie values
- * are used.
- *
- * A fixture that must survive the expiry filter uses an expiration in the
- * future; a fixed date would make the test fail when it passes.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import {
-	mkdtempSync,
-	mkdirSync,
-	writeFileSync,
-	rmSync,
-	existsSync,
-	readFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import {
-	sync,
-	hasAnyCookieSource,
-	inferCachePath,
-	DEFAULT_DROP_DIR,
-} from "../src/sync.js";
-import { parseNetscape } from "../src/parse-netscape.js";
-
-const NETSCAPE_FIXTURE = [
-	"# Netscape HTTP Cookie File",
-	"# Test fixture for sync.test.ts",
-	".minimax.io\tFALSE\t/\tFALSE\t0\ttest_id\ttest-value-id",
-	"#HttpOnly_.minimax.io\tFALSE\t/\tTRUE\t0\ttest_token\ttest-value-token",
-	"",
-].join("\n");
-
-const JSON_FIXTURE = JSON.stringify([
-	{
-		domain: ".minimax.io",
-		// A cookie that is still valid: an expiration in the past would be
-		// filtered out and the test would count a different number.
-		expirationDate: Math.floor(Date.now() / 1000) + 3600,
-		name: "test_json",
-		value: "test-value-json",
-		httpOnly: false,
-		secure: true,
-	},
-]);
-
-let TMP_ROOT: string;
-
-beforeEach(() => {
-	TMP_ROOT = mkdtempSync(join(tmpdir(), "cookie-sanitizer-test-"));
-});
-
-afterEach(() => {
-	if (TMP_ROOT) rmSync(TMP_ROOT, { force: true, recursive: true });
-});
-
-/** Per-test drop folder under TMP_ROOT. */
-function freshDropDir(): string {
-	const sub = join(TMP_ROOT, "drop");
-	rmSync(sub, { force: true, recursive: true });
-	mkdirSync(sub, { recursive: true });
-	return sub;
-}
-
-describe("sync()", () => {
-	it("writes a canonical cache from a Netscape drop file", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-
-		expect(result.provider).toBe("minimax");
-		expect(result.processedFiles).toContain("minimax.txt");
-		expect(result.skippedFiles).toEqual([]);
-		expect(result.wrote).toBe(true);
-		expect(result.totalCookies).toBe(2);
-		expect(result.cachePath).toBe(cache);
-		expect(existsSync(cache)).toBe(true);
-
-		const back = parseNetscape(readFileSync(cache, "utf8"));
-		expect(back).toHaveLength(2);
-		const names = back.map((c) => c.name).sort();
-		expect(names).toEqual(["test_id", "test_token"]);
-	});
-
-	it("writes a canonical cache from a JSON drop file", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.json"), JSON_FIXTURE);
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-
-		expect(result.provider).toBe("minimax");
-		expect(result.totalCookies).toBe(1);
-		expect(result.wrote).toBe(true);
-		const back = parseNetscape(readFileSync(cache, "utf8"));
-		expect(back[0]?.name).toBe("test_json");
-	});
-
-	it("merges multiple files (Netscape + JSON) and dedupes", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		writeFileSync(join(drop, "extra.json"), JSON_FIXTURE);
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-		expect(result.totalCookies).toBe(3);
-		expect(result.processedFiles.sort()).toEqual(["extra.json", "minimax.txt"]);
-	});
-
-	it("skips files with unknown format and reports them", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		writeFileSync(join(drop, "garbage.txt"), "this is not a cookie file");
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-		expect(result.wrote).toBe(true);
-		expect(result.totalCookies).toBe(2);
-		expect(
-			result.skippedFiles.find((f) => f.basename === "garbage.txt"),
-		).toBeTruthy();
-	});
-
-	it("skips editor temp files and dotfiles", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		writeFileSync(join(drop, ".hidden"), NETSCAPE_FIXTURE);
-		writeFileSync(join(drop, "minimax.swp"), NETSCAPE_FIXTURE);
-		writeFileSync(join(drop, "minimax~"), NETSCAPE_FIXTURE);
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-		expect(result.processedFiles).toEqual(["minimax.txt"]);
-	});
-
-	it("excludes the canonical cache file from input", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		// Pre-write the cache to simulate a previous run.
-		writeFileSync(cache, NETSCAPE_FIXTURE);
-
-		const result = sync({ dropDir: drop, cachePath: cache });
-		// The cache file itself was excluded from input; only minimax.txt was read.
-		expect(result.processedFiles).toEqual(["minimax.txt"]);
-	});
-
-	it("returns null provider when inference fails", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		// Name and domain that don't match any known provider.
-		writeFileSync(
-			join(drop, "random.txt"),
-			"# Netscape HTTP Cookie File\n.example.com\tFALSE\t/\tFALSE\t0\tn1\tv1\n",
-		);
-		const result = sync({ dropDir: drop, cachePath: cache });
-		expect(result.provider).toBe(null);
-		expect(result.wrote).toBe(false);
-		expect(result.errors.length).toBeGreaterThan(0);
-	});
-
-	it("dryRun=true does not write the cache", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		const result = sync({ dropDir: drop, cachePath: cache, dryRun: true });
-		expect(result.wrote).toBe(false);
-		expect(result.totalCookies).toBe(2);
-		expect(existsSync(cache)).toBe(false);
-	});
-
-	it("empty drop folder returns an empty result with no errors", () => {
-		const drop = freshDropDir();
-		const result = sync({ dropDir: drop, cachePath: join(drop, "out.txt") });
-		expect(result.processedFiles).toEqual([]);
-		expect(result.totalCookies).toBe(0);
-		expect(result.wrote).toBe(false);
-	});
-
-	it("filters out expired cookies", () => {
-		const drop = freshDropDir();
-		const cache = join(drop, "out.txt");
-		const past = 1; // 1970-01-01
-		const text = [
-			"# Netscape HTTP Cookie File",
-			`.minimax.io\tFALSE\t/\tFALSE\t${past}\texpired\texpired-value`,
-			".minimax.io\tFALSE\t/\tFALSE\t0\talive\talive-value",
-		].join("\n");
-		writeFileSync(join(drop, "minimax.txt"), text);
-		const result = sync({ dropDir: drop, cachePath: cache });
-		expect(result.totalCookies).toBe(1);
-		const back = parseNetscape(readFileSync(cache, "utf8"));
-		expect(back[0]?.name).toBe("alive");
-	});
-});
-
-describe("hasAnyCookieSource", () => {
-	it("returns false for empty folder", () => {
-		const drop = freshDropDir();
-		expect(hasAnyCookieSource(drop)).toBe(false);
-	});
-	it("returns true when files exist", () => {
-		const drop = freshDropDir();
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		expect(hasAnyCookieSource(drop)).toBe(true);
-	});
-});
-
-describe("inferCachePath", () => {
-	it("returns null for empty folder", () => {
-		const drop = freshDropDir();
-		expect(inferCachePath(drop)).toBe(null);
-	});
-	it("returns the canonical path for the dominant provider", () => {
-		const drop = freshDropDir();
-		writeFileSync(join(drop, "minimax.txt"), NETSCAPE_FIXTURE);
-		const cachePath = inferCachePath(drop);
-		expect(cachePath).toBe(
-			join(process.env.HOME ?? "/tmp", ".config", "minimax-cookies.txt"),
-		);
-	});
-});
-
-describe("DEFAULT_DROP_DIR", () => {
-	it("defaults to ~/.pi-harness-runtime/cookies/", () => {
-		const home = process.env.HOME ?? "/tmp";
-		expect(DEFAULT_DROP_DIR).toBe(join(home, ".pi-harness-runtime", "cookies"));
-	});
-});

package/packages/cookie-sanitizer/test/watcher.test.ts

@@ -1,27 +0,0 @@
-/**
- * Watcher tests — light-touch. chokidar needs a real fs environment,
- * so we exercise the debouncer + runSync trigger without depending
- * on the chokidar watcher itself (which is exercised in real use).
- */
-
-import { describe, it, expect } from "bun:test";
-import { createWatcher } from "../src/watcher.js";
-
-describe("CookieWatcher — configuration sanity", () => {
-	it("accepts a valid config and constructs without throwing", () => {
-		const w = createWatcher(
-			"/tmp/does-not-exist-folder",
-			{ dropDir: "/tmp/does-not-exist-folder" },
-			() => {},
-		);
-		expect(w).toBeDefined();
-		expect(typeof w.start).toBe("function");
-		expect(typeof w.stop).toBe("function");
-		expect(typeof w.triggerNow).toBe("function");
-	});
-
-	// Note: real chokidar-on-the-filesystem tests are exercised via
-	// the live runtime, not in this unit-test file. chokidar requires
-	// a real OS-level fs watcher and behaves differently across
-	// platforms; we rely on chokidar's own test suite for that.
-});