pi-harness-runtime 0.9.7 → 0.9.11

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

@@ -0,0 +1,113 @@
+/**
+ * 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

@@ -0,0 +1,204 @@
+/**
+ * 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

@@ -0,0 +1,231 @@
+/**
+ * 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.
+ */
+
+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",
+		expirationDate: 1700000000,
+		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

@@ -0,0 +1,27 @@
+/**
+ * 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.
+});

package/packages/cookie-sanitizer/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/packages/cost-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/cost-optimizer",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Cost Optimizer for pi-harness-runtime — budget tracking, forecasting, and model selection optimization",
   "type": "module",
   "main": "./dist/index.js",

package/packages/django-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/django-plugin",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Django framework analysis — models, management commands, settings",
   "type": "module",
   "main": "./dist/index.js",

package/packages/doc-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/doc-generator",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Auto-Doc Generator — generate documentation from source code (RFC-0014)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/evaluation-engine",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Evaluation engine for pi-harness runtime (RFC-0057)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/evaluation-runner",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "type": "module",
   "description": "Framework-agnostic evaluation framework for AI outputs (RFC-0020)",
   "main": "dist/index.js",

package/packages/experience-replay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/experience-replay",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Experience replay for debugging and reproducibility (RFC-0059)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/feedback-collector/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/feedback-collector",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "type": "module",
   "description": "Collect and aggregate human/automated feedback (RFC-0021)",
   "main": "dist/index.js",

package/packages/framework-detector/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/framework-detector",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Framework detection system for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/framework-plugin-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/framework-plugin-sdk",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Framework plugin SDK for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/frappe-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/frappe-plugin",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Frappe/ERPNext framework analysis — DocTypes, hooks, bench sites, site config",
   "type": "module",
   "main": "./dist/index.js",

package/packages/generic-web-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/generic-web-plugin",
-  "version": "0.9.6",
+  "version": "0.9.11",
   "description": "Generic web framework analysis — REST/GraphQL endpoints, OpenAPI, auth",
   "type": "module",
   "main": "./dist/index.js",