@mainahq/core 1.0.3 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mainahq/core",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Maina core engines — Context, Prompt, and Verify for verification-first development",

package/src/ai/__tests__/delegation.test.ts

@@ -1,7 +1,8 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
 import {
 	type DelegationRequest,
 	formatDelegationRequest,
+	outputDelegationRequest,
 	parseDelegationRequest,
 } from "../delegation";
 
@@ -103,3 +104,56 @@ Some output after`;
 		expect(parsed?.prompt).toBe("hello");
 	});
 });
+
+describe("outputDelegationRequest", () => {
+	let stderrChunks: string[];
+	let stdoutChunks: string[];
+	let originalStderrWrite: typeof process.stderr.write;
+	let originalStdoutWrite: typeof process.stdout.write;
+
+	beforeEach(() => {
+		stderrChunks = [];
+		stdoutChunks = [];
+		originalStderrWrite = process.stderr.write;
+		originalStdoutWrite = process.stdout.write;
+
+		process.stderr.write = ((chunk: string | Uint8Array) => {
+			stderrChunks.push(
+				typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk),
+			);
+			return true;
+		}) as typeof process.stderr.write;
+
+		process.stdout.write = ((chunk: string | Uint8Array) => {
+			stdoutChunks.push(
+				typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk),
+			);
+			return true;
+		}) as typeof process.stdout.write;
+	});
+
+	afterEach(() => {
+		process.stderr.write = originalStderrWrite;
+		process.stdout.write = originalStdoutWrite;
+	});
+
+	it("writes to stderr, not stdout (prevents MCP protocol corruption)", () => {
+		const req: DelegationRequest = {
+			task: "review",
+			context: "test context",
+			prompt: "test prompt",
+			expectedFormat: "text",
+		};
+
+		outputDelegationRequest(req);
+
+		// Must write to stderr
+		expect(stderrChunks.length).toBeGreaterThan(0);
+		const stderrOutput = stderrChunks.join("");
+		expect(stderrOutput).toContain("---MAINA_AI_REQUEST---");
+		expect(stderrOutput).toContain("task: review");
+
+		// Must NOT write to stdout (stdout is reserved for JSON-RPC in MCP)
+		expect(stdoutChunks.length).toBe(0);
+	});
+});

package/src/ai/delegation.ts

@@ -102,10 +102,12 @@ export function parseDelegationRequest(text: string): DelegationRequest | null {
 }
 
 /**
- * Output a delegation request to stdout.
- * Used by tryAIGenerate when in host mode.
+ * Output a delegation request to stderr.
+ * Uses stderr so that MCP stdio transport (which uses stdout for JSON-RPC)
+ * is never corrupted by delegation text.
+ * In CLI mode, stderr is still visible in the terminal.
  */
 export function outputDelegationRequest(req: DelegationRequest): void {
 	const formatted = formatDelegationRequest(req);
-	process.stdout.write(`\n${formatted}\n`);
+	process.stderr.write(`\n${formatted}\n`);
 }

package/src/context/__tests__/budget.test.ts

@@ -42,12 +42,13 @@ describe("getBudgetRatio", () => {
 describe("assembleBudget", () => {
 	test("allocations sum correctly for default mode with default context window", () => {
 		const allocation = assembleBudget("default");
-		// working + episodic + semantic + retrieval + headroom === total
+		// working + episodic + semantic + retrieval + wiki + headroom === total
 		const layerSum =
 			allocation.working +
 			allocation.episodic +
 			allocation.semantic +
 			allocation.retrieval +
+			allocation.wiki +
 			allocation.headroom;
 		expect(layerSum).toBe(allocation.total);
 	});
@@ -75,7 +76,8 @@ describe("assembleBudget", () => {
 			allocation.working +
 			allocation.episodic +
 			allocation.semantic +
-			allocation.retrieval;
+			allocation.retrieval +
+			allocation.wiki;
 		expect(layerSum).toBe(budget);
 	});
 
@@ -83,15 +85,35 @@ describe("assembleBudget", () => {
 		const modelContext = 200_000;
 		const allocationDefault = assembleBudget("default", modelContext);
 		const allocationFocused = assembleBudget("focused", modelContext);
-		// working = ~25% of budget; for focused: budget = 0.4 * 200_000 = 80_000
-		// working = floor(80_000 * 0.25) = 20_000
+		// working = ~12% of budget; for focused: budget = 0.4 * 200_000 = 80_000
+		// working = floor(80_000 * 0.12) = 9_600
 		expect(allocationFocused.working).toBe(
-			Math.floor(Math.floor(modelContext * 0.4) * 0.25),
+			Math.floor(Math.floor(modelContext * 0.4) * 0.12),
 		);
 		expect(allocationDefault.working).toBe(
-			Math.floor(Math.floor(modelContext * 0.6) * 0.25),
+			Math.floor(Math.floor(modelContext * 0.6) * 0.12),
 		);
 	});
+
+	test("wiki allocation is ~12% of usable budget", () => {
+		const modelContext = 200_000;
+		const allocation = assembleBudget("default", modelContext);
+		const budget = Math.floor(modelContext * 0.6);
+		expect(allocation.wiki).toBe(Math.floor(budget * 0.12));
+	});
+
+	test("all 5 layers sum to budget for default mode", () => {
+		const modelContext = 200_000;
+		const allocation = assembleBudget("default", modelContext);
+		const budget = Math.floor(modelContext * 0.6);
+		const layerSum =
+			allocation.working +
+			allocation.episodic +
+			allocation.semantic +
+			allocation.retrieval +
+			allocation.wiki;
+		expect(layerSum).toBe(budget);
+	});
 });
 
 describe("truncateToFit", () => {
@@ -109,6 +131,7 @@ describe("truncateToFit", () => {
 		semantic: 200,
 		episodic: 300,
 		retrieval: 400,
+		wiki: 0,
 		headroom: 0,
 		total: 1000,
 		...overrides,

package/src/context/__tests__/engine.test.ts

@@ -156,6 +156,7 @@ describe("assembleContext", () => {
 		expect(typeof result.budget.episodic).toBe("number");
 		expect(typeof result.budget.semantic).toBe("number");
 		expect(typeof result.budget.retrieval).toBe("number");
+		expect(typeof result.budget.wiki).toBe("number");
 		expect(typeof result.budget.total).toBe("number");
 		expect(typeof result.budget.headroom).toBe("number");
 		expect(result.budget.total).toBeGreaterThan(0);

package/src/context/__tests__/selector.test.ts

@@ -3,28 +3,31 @@ import type { BudgetMode } from "../budget.ts";
 import { getBudgetMode, getContextNeeds, needsLayer } from "../selector.ts";
 
 describe("getContextNeeds", () => {
-	it("commit needs only working + conventions", () => {
+	it("commit needs only working + conventions + wiki", () => {
 		const needs = getContextNeeds("commit");
 		expect(needs.working).toBe(true);
 		expect(needs.episodic).toBe(false);
 		expect(needs.semantic).toEqual(["conventions"]);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
-	it("context command needs all 4 layers", () => {
+	it("context command needs all 5 layers", () => {
 		const needs = getContextNeeds("context");
 		expect(needs.working).toBe(true);
 		expect(needs.episodic).toBe(true);
 		expect(needs.semantic).toBe(true);
 		expect(needs.retrieval).toBe(true);
+		expect(needs.wiki).toBe(true);
 	});
 
-	it("verify needs working + recent-reviews + adrs + conventions", () => {
+	it("verify needs working + recent-reviews + adrs + conventions + wiki", () => {
 		const needs = getContextNeeds("verify");
 		expect(needs.working).toBe(true);
 		expect(needs.episodic).toEqual(["recent-reviews"]);
 		expect(needs.semantic).toEqual(["adrs", "conventions"]);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("review returns correct context needs", () => {
@@ -33,6 +36,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toEqual(["past-reviews"]);
 		expect(needs.semantic).toEqual(["adrs"]);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("plan returns correct context needs", () => {
@@ -41,6 +45,7 @@ describe("getContextNeeds", () => {
 		expect(needs.semantic).toEqual(["adrs", "conventions"]);
 		expect(needs.episodic).toBe(false);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("explain returns correct context needs", () => {
@@ -49,6 +54,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toBe(false);
 		expect(needs.semantic).toBe(true);
 		expect(needs.retrieval).toBe(true);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("design returns correct context needs", () => {
@@ -57,6 +63,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toBe(false);
 		expect(needs.semantic).toEqual(["adrs"]);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("ticket returns correct context needs", () => {
@@ -65,6 +72,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toBe(false);
 		expect(needs.semantic).toEqual(["modules"]);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(false);
 	});
 
 	it("analyze returns correct context needs", () => {
@@ -73,6 +81,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toBe(true);
 		expect(needs.semantic).toBe(true);
 		expect(needs.retrieval).toBe(false);
+		expect(needs.wiki).toBe(true);
 	});
 
 	it("pr returns correct context needs", () => {
@@ -81,6 +90,7 @@ describe("getContextNeeds", () => {
 		expect(needs.episodic).toEqual(["past-reviews"]);
 		expect(needs.semantic).toBe(true);
 		expect(needs.retrieval).toBe(true);
+		expect(needs.wiki).toBe(true);
 	});
 });
 
@@ -129,6 +139,16 @@ describe("needsLayer", () => {
 		const needs = getContextNeeds("commit");
 		expect(needsLayer(needs, "retrieval")).toBe(false);
 	});
+
+	it("correctly identifies when wiki layer is needed", () => {
+		const needs = getContextNeeds("commit");
+		expect(needsLayer(needs, "wiki")).toBe(true);
+	});
+
+	it("correctly identifies when wiki layer is not needed", () => {
+		const needs = getContextNeeds("ticket");
+		expect(needsLayer(needs, "wiki")).toBe(false);
+	});
 });
 
 describe("getBudgetMode", () => {

package/src/context/__tests__/wiki.test.ts

@@ -0,0 +1,349 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { calculateTokens } from "../budget";
+import { assembleWikiText, loadWikiContext } from "../wiki";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTempDir(): string {
+	const dir = join(
+		tmpdir(),
+		`maina-wiki-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function writeWikiFile(
+	wikiDir: string,
+	relPath: string,
+	content: string,
+): void {
+	const fullPath = join(wikiDir, relPath);
+	const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(fullPath, content, "utf8");
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("loadWikiContext", () => {
+	let wikiDir: string;
+
+	beforeEach(() => {
+		wikiDir = makeTempDir();
+	});
+
+	afterEach(() => {
+		try {
+			rmSync(wikiDir, { recursive: true, force: true });
+		} catch {
+			// ignore cleanup errors
+		}
+	});
+
+	it("returns null when wiki directory does not exist", () => {
+		const result = loadWikiContext({
+			wikiDir: join(tmpdir(), "nonexistent-wiki-dir-xyz"),
+		});
+		expect(result).toBeNull();
+	});
+
+	it("returns null when wiki directory is empty", () => {
+		// wikiDir exists but has no files
+		const result = loadWikiContext({ wikiDir });
+		expect(result).toBeNull();
+	});
+
+	it("loads index.md when wiki exists", () => {
+		writeWikiFile(wikiDir, "index.md", "# Wiki Index\nOverview of articles.");
+
+		const result = loadWikiContext({ wikiDir });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("Wiki Index");
+		expect(result?.text).toContain("Overview of articles");
+	});
+
+	it("loads decision articles for review command", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001: Use TypeScript\nWe chose TypeScript for type safety.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"features/feature-auth.md",
+			"# Auth Feature\nAuthentication implementation details.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "review" });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("ADR-001");
+		// review loads decisions and modules, not features
+		expect(result?.text).not.toContain("Auth Feature");
+	});
+
+	it("loads feature articles for commit command", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"features/feature-wiki.md",
+			"# Wiki Feature\nWiki context layer details.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001: TypeScript\nDecision content.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "commit" });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("Wiki Feature");
+		// commit loads features and architecture, not decisions
+		expect(result?.text).not.toContain("ADR-001");
+	});
+
+	it("loads all article types for explain command (exploration mode)", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001\nDecision content.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"features/feature-auth.md",
+			"# Auth Feature\nAuth details.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"modules/context-engine.md",
+			"# Context Engine\nEngine docs.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"architecture/overview.md",
+			"# Architecture Overview\nSystem design.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "explain" });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("ADR-001");
+		expect(result?.text).toContain("Auth Feature");
+		expect(result?.text).toContain("Context Engine");
+		expect(result?.text).toContain("Architecture Overview");
+	});
+
+	it("loads decision articles for design command (conflict detection)", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001\nDecision content.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"features/feature-auth.md",
+			"# Auth Feature\nShould not be loaded.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "design" });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("ADR-001");
+		expect(result?.text).not.toContain("Auth Feature");
+	});
+
+	it("respects token budget (returns content within reasonable bounds)", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		// Create several articles
+		for (let i = 0; i < 10; i++) {
+			writeWikiFile(
+				wikiDir,
+				`decisions/adr-${String(i).padStart(3, "0")}.md`,
+				`# ADR-${i}\n${"Content line. ".repeat(100)}`,
+			);
+		}
+
+		const result = loadWikiContext({ wikiDir, command: "review" });
+		expect(result).not.toBeNull();
+		expect(result?.tokens).toBeGreaterThan(0);
+		// Tokens should match calculateTokens of the text
+		expect(result?.tokens).toBe(calculateTokens(result?.text ?? ""));
+	});
+
+	it("returns valid LayerContent with correct name and priority", () => {
+		writeWikiFile(wikiDir, "index.md", "# Wiki Index");
+
+		const result = loadWikiContext({ wikiDir });
+		expect(result).not.toBeNull();
+		expect(result?.name).toBe("wiki");
+		expect(result?.priority).toBe(4);
+		expect(typeof result?.text).toBe("string");
+		expect(typeof result?.tokens).toBe("number");
+	});
+
+	it("handles empty wiki directory gracefully", () => {
+		// Create a subdirectory but no files
+		mkdirSync(join(wikiDir, "decisions"), { recursive: true });
+
+		const result = loadWikiContext({ wikiDir });
+		// Directory has an entry (subdirectory) but no actual content
+		expect(result).toBeNull();
+	});
+
+	it("boosts articles relevant to working files", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"modules/context-engine.md",
+			"# Context Engine\nRelevant to working files.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"modules/git-ops.md",
+			"# Git Operations\nNot relevant to working files.",
+		);
+
+		const result = loadWikiContext({
+			wikiDir,
+			workingFiles: ["packages/core/src/context/engine.ts"],
+			command: "review",
+		});
+		expect(result).not.toBeNull();
+		// Both should be loaded since both are modules and command is review
+		expect(result?.text).toContain("Context Engine");
+	});
+
+	it("returns null when wiki dir has only empty subdirectories", () => {
+		mkdirSync(join(wikiDir, "decisions"), { recursive: true });
+		mkdirSync(join(wikiDir, "modules"), { recursive: true });
+
+		const result = loadWikiContext({ wikiDir });
+		expect(result).toBeNull();
+	});
+
+	it("includes index content in output even without other articles", () => {
+		writeWikiFile(wikiDir, "index.md", "# Project Wiki\nThis is the index.");
+
+		const result = loadWikiContext({ wikiDir });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("## Wiki Knowledge (Layer 5)");
+		expect(result?.text).toContain("### Index");
+		expect(result?.text).toContain("Project Wiki");
+	});
+
+	it("formats articles with wiki/ path prefix", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001: Use Bun\nBun is faster.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "review" });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("wiki/decisions/adr-001.md");
+	});
+
+	it("loads all articles when no command is specified (default)", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# Decision\nDecision content.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"features/feature.md",
+			"# Feature\nFeature content.",
+		);
+
+		const result = loadWikiContext({ wikiDir });
+		expect(result).not.toBeNull();
+		expect(result?.text).toContain("Decision");
+		expect(result?.text).toContain("Feature");
+	});
+
+	it("records loaded articles to signals file for RL tracking", () => {
+		writeWikiFile(wikiDir, "index.md", "# Index");
+		writeWikiFile(
+			wikiDir,
+			"decisions/adr-001.md",
+			"# ADR-001\nDecision content.",
+		);
+		writeWikiFile(
+			wikiDir,
+			"modules/context-engine.md",
+			"# Context Engine\nEngine docs.",
+		);
+
+		const result = loadWikiContext({ wikiDir, command: "review" });
+		expect(result).not.toBeNull();
+
+		// Check that the signals file was created
+		const signalsPath = join(wikiDir, ".signals.json");
+		expect(existsSync(signalsPath)).toBe(true);
+
+		const raw = readFileSync(signalsPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		expect(parsed.loadSignals).toBeDefined();
+		expect(parsed.loadSignals.length).toBeGreaterThan(0);
+		expect(parsed.loadSignals[0].command).toBe("review");
+		expect(Array.isArray(parsed.loadSignals[0].articles)).toBe(true);
+	});
+});
+
+describe("assembleWikiText", () => {
+	it("formats with correct headers", () => {
+		const text = assembleWikiText("# Index content", [
+			{
+				path: "decisions/adr-001.md",
+				title: "ADR-001",
+				content: "Decision content.",
+				category: "decision",
+				score: 0.9,
+			},
+		]);
+
+		expect(text).toContain("## Wiki Knowledge (Layer 5)");
+		expect(text).toContain("### Index");
+		expect(text).toContain("# Index content");
+		expect(text).toContain("### Relevant Articles");
+		expect(text).toContain("#### ADR-001 (wiki/decisions/adr-001.md)");
+		expect(text).toContain("Decision content.");
+		expect(text).toContain("---");
+	});
+
+	it("handles empty index", () => {
+		const text = assembleWikiText("", [
+			{
+				path: "decisions/adr-001.md",
+				title: "ADR-001",
+				content: "Content.",
+				category: "decision",
+				score: 0.9,
+			},
+		]);
+
+		expect(text).toContain("## Wiki Knowledge (Layer 5)");
+		expect(text).not.toContain("### Index");
+		expect(text).toContain("### Relevant Articles");
+	});
+
+	it("handles empty articles", () => {
+		const text = assembleWikiText("# Index", []);
+
+		expect(text).toContain("## Wiki Knowledge (Layer 5)");
+		expect(text).toContain("### Index");
+		expect(text).not.toContain("### Relevant Articles");
+	});
+});

package/src/context/budget.ts

@@ -5,6 +5,7 @@ export interface BudgetAllocation {
 	episodic: number;
 	semantic: number;
 	retrieval: number;
+	wiki: number;
 	total: number;
 	headroom: number; // reserved for AI reasoning
 }
@@ -45,10 +46,11 @@ export function getBudgetRatio(mode: BudgetMode): number {
  * Calculates per-layer token allocations for a given mode and model context window.
  *
  * Layer proportions within the usable budget:
- *   working:   ~25%
- *   semantic:  ~33%
- *   episodic:  ~25%
- *   retrieval: ~17%  (remainder after the above three)
+ *   working:   ~12%
+ *   episodic:  ~12%
+ *   semantic:  ~16%
+ *   retrieval: ~8%  (remainder after the above four)
+ *   wiki:      ~12%
  */
 export function assembleBudget(
 	mode: BudgetMode,
@@ -58,17 +60,19 @@ export function assembleBudget(
 	const budget = Math.floor(modelContextWindow * ratio);
 	const headroom = modelContextWindow - budget;
 
-	const working = Math.floor(budget * 0.25);
-	const semantic = Math.floor(budget * 0.33);
-	const episodic = Math.floor(budget * 0.25);
+	const working = Math.floor(budget * 0.12);
+	const episodic = Math.floor(budget * 0.12);
+	const semantic = Math.floor(budget * 0.16);
+	const wiki = Math.floor(budget * 0.12);
 	// retrieval gets the exact remainder so all layer tokens sum to budget
-	const retrieval = budget - working - semantic - episodic;
+	const retrieval = budget - working - episodic - semantic - wiki;
 
 	return {
 		working,
 		semantic,
 		episodic,
 		retrieval,
+		wiki,
 		headroom,
 		total: modelContextWindow,
 	};