pi-harness-runtime 0.5.0 → 0.6.3-beta.13

package/packages/skill-registry/test/registry.test.ts

@@ -0,0 +1,364 @@
+/**
+ * Skill Registry Tests (RFC-0052)
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	createSkillRegistry,
+	type InMemorySkillRegistry,
+	DEFAULT_SKILLS,
+	matchTrigger,
+	findBestMatch,
+	findAllMatches,
+	createKeywordTrigger,
+	createIntentTrigger,
+	createPatternTrigger,
+} from "../src/index.js";
+import type { Skill, SkillContext } from "../src/types.js";
+
+describe("SkillRegistry", () => {
+	let registry: InMemorySkillRegistry;
+
+	beforeEach(() => {
+		registry = createSkillRegistry(true);
+	});
+
+	describe("initialization", () => {
+		it("should load default skills", () => {
+			const skills = registry.list();
+			expect(skills.length).toBeGreaterThan(0);
+		});
+
+		it("should have introspection skill", () => {
+			const skill = registry.get("skill-registry-introspect");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Introspect Skill Registry");
+		});
+	});
+
+	describe("register and unregister", () => {
+		it("should register a new skill", () => {
+			const newSkill: Skill = {
+				id: "test-skill",
+				name: "Test Skill",
+				description: "A test skill",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["test"]),
+				handler: async () => ({ success: true, output: "test" }),
+				metadata: { tags: ["test"] },
+			};
+
+			registry.register(newSkill);
+
+			const skill = registry.get("test-skill");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Test Skill");
+		});
+
+		it("should not register deprecated skills", () => {
+			const deprecatedSkill: Skill = {
+				id: "deprecated-skill",
+				name: "Deprecated",
+				description: "Should not be registered",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["deprecated"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [], deprecated: true },
+			};
+
+			registry.register(deprecatedSkill);
+
+			const skill = registry.get("deprecated-skill");
+			expect(skill).toBeUndefined();
+		});
+
+		it("should unregister a skill", () => {
+			registry.unregister("skill-registry-introspect");
+
+			const skill = registry.get("skill-registry-introspect");
+			expect(skill).toBeUndefined();
+		});
+
+		it("should track events", () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const newSkill: Skill = {
+				id: "event-test",
+				name: "Event Test",
+				description: "Test event",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["event"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			registry.register(newSkill);
+
+			expect(events).toContainEqual({
+				type: "skill.registered",
+				skillId: "event-test",
+				name: "Event Test",
+			});
+		});
+	});
+
+	describe("find", () => {
+		it("should find skills by trigger type", () => {
+			// "list" appears in all trigger phrases: "list skills", "show skills", "what skills"
+			const skills = registry.find({ type: "keyword", value: "list" });
+			expect(skills.length).toBeGreaterThan(0);
+		});
+
+		it("should return empty for no match", () => {
+			const skills = registry.find({
+				type: "keyword",
+				value: "xyznonexistent",
+			});
+			expect(skills).toHaveLength(0);
+		});
+	});
+
+	describe("invoke", () => {
+		it("should invoke a skill", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			const result = await registry.invoke(
+				"skill-registry-introspect",
+				context,
+			);
+			expect(result.success).toBe(true);
+			expect(result.output).toContain("Registered Skills");
+		});
+
+		it("should return error for unknown skill", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invoke("unknown-skill", context);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("not found");
+		});
+
+		it("should track invoke events", async () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			await registry.invoke("skill-registry-introspect", context);
+
+			const invokeEvents = events.filter((e) => e.type === "skill.invoked");
+			expect(invokeEvents.length).toBe(1);
+			expect(invokeEvents[0].skillId).toBe("skill-registry-introspect");
+			expect(invokeEvents[0].success).toBe(true);
+		});
+
+		it("should handle handler errors", async () => {
+			const errorSkill: Skill = {
+				id: "error-skill",
+				name: "Error Skill",
+				description: "Throws error",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["error"]),
+				handler: async () => {
+					throw new Error("Test error");
+				},
+				metadata: { tags: [] },
+			};
+
+			registry.register(errorSkill);
+
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invoke("error-skill", context);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Test error");
+
+			const errorEvents = events.filter((e) => e.type === "skill.error");
+			expect(errorEvents.length).toBe(1);
+		});
+	});
+
+	describe("invokeBestMatch", () => {
+		it("should find and invoke best match", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			// "list" appears in all trigger phrases
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "list" },
+				context,
+			);
+
+			expect(result.success).toBe(true);
+		});
+
+		it("should return error when no match", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "xyznonexistent" },
+				context,
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("No matching skill");
+		});
+	});
+});
+
+describe("Matching Functions", () => {
+	describe("matchTrigger", () => {
+		it("should match keyword trigger", () => {
+			const skill = {
+				id: "test",
+				name: "Test",
+				description: "",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["help", "assist"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			expect(matchTrigger(skill, "Can you help me?")).toBeGreaterThan(0);
+			expect(matchTrigger(skill, "I need assistance")).toBeGreaterThan(0);
+			expect(matchTrigger(skill, "Nothing relevant")).toBe(0);
+		});
+
+		it("should match pattern trigger", () => {
+			const skill = {
+				id: "test",
+				name: "Test",
+				description: "",
+				version: "1.0.0",
+				trigger: createPatternTrigger("fix\\s+\\w+"),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			expect(matchTrigger(skill, "fix bug")).toBe(1);
+			expect(matchTrigger(skill, "fix error")).toBe(1);
+			expect(matchTrigger(skill, "not relevant")).toBe(0);
+		});
+	});
+
+	describe("findBestMatch", () => {
+		it("should return highest scoring match", () => {
+			const skills = [
+				{
+					id: "low",
+					name: "Low",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+				{
+					id: "high",
+					name: "High",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test", "skill", "run"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const match = findBestMatch(skills, "run test skill");
+			// Both have score 1.0 (all keywords match), so either could be returned
+			expect(["high", "low"]).toContain(match?.id);
+		});
+
+		it("should respect min confidence", () => {
+			const skills = [
+				{
+					id: "low",
+					name: "Low",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const match = findBestMatch(skills, "xyz", 0.5);
+			expect(match).toBeUndefined();
+		});
+	});
+
+	describe("findAllMatches", () => {
+		it("should return all matches above threshold", () => {
+			const skills = [
+				{
+					id: "one",
+					name: "One",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["help"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+				{
+					id: "two",
+					name: "Two",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["help", "me"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const matches = findAllMatches(skills, "help me");
+			expect(matches.length).toBe(2);
+		});
+	});
+});
+
+describe("Trigger Creators", () => {
+	it("should create keyword trigger", () => {
+		const trigger = createKeywordTrigger(["one", "two"]);
+		expect(trigger.type).toBe("keyword");
+		expect(trigger.value).toEqual(["one", "two"]);
+	});
+
+	it("should create intent trigger", () => {
+		const trigger = createIntentTrigger(["intent1"]);
+		expect(trigger.type).toBe("intent");
+		expect(trigger.value).toEqual(["intent1"]);
+	});
+
+	it("should create pattern trigger", () => {
+		const trigger = createPatternTrigger("test\\d+");
+		expect(trigger.type).toBe("pattern");
+		expect(trigger.value).toBe("test\\d+");
+	});
+});

package/packages/skill-registry/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "ES2022",
+      "DOM"
+    ]
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "test"
+  ]
+}

package/packages/task-compiler/dist/command-policy.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Task Compiler - Command Policy
+ *
+ * Applies project rules and standing policy to generate
+ * permittedCommands and prohibitedCommands per task.
+ */
+import { type CompiledTask, type ProjectProfile } from "./types.js";
+/**
+ * Apply command policy to each task based on project rules and task type.
+ *
+ * Rules:
+ * - PROHIBITED_BY_DEFAULT commands are always forbidden unless overridden
+ * - Project rules can add more permitted/prohibited commands
+ * - Task type determines which project commands are relevant
+ * - build/migrate/commit require explicit permission
+ */
+export declare function applyCommandPolicy(tasks: CompiledTask[], project: ProjectProfile): CompiledTask[];
+//# sourceMappingURL=command-policy.d.ts.map

package/packages/task-compiler/dist/command-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-policy.d.ts","sourceRoot":"","sources":["../src/command-policy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACN,KAAK,YAAY,EAEjB,KAAK,cAAc,EACnB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,YAAY,EAAE,EACrB,OAAO,EAAE,cAAc,GACrB,YAAY,EAAE,CA8GhB"}

package/packages/task-compiler/dist/command-policy.js

@@ -0,0 +1,164 @@
+/**
+ * Task Compiler - Command Policy
+ *
+ * Applies project rules and standing policy to generate
+ * permittedCommands and prohibitedCommands per task.
+ */
+import { PROHIBITED_BY_DEFAULT, } from "./types.js";
+/**
+ * Apply command policy to each task based on project rules and task type.
+ *
+ * Rules:
+ * - PROHIBITED_BY_DEFAULT commands are always forbidden unless overridden
+ * - Project rules can add more permitted/prohibited commands
+ * - Task type determines which project commands are relevant
+ * - build/migrate/commit require explicit permission
+ */
+export function applyCommandPolicy(tasks, project) {
+    const projectCommands = extractProjectCommands(project);
+    return tasks.map((task) => {
+        const prohibited = [...PROHIBITED_BY_DEFAULT];
+        const permitted = [];
+        // Add project-specific prohibited commands
+        const ruleProhibited = projectCommands.prohibited;
+        for (const cmd of ruleProhibited) {
+            if (!prohibited.includes(cmd)) {
+                prohibited.push(cmd);
+            }
+        }
+        // Add permitted commands based on task type and project commands
+        switch (task.type) {
+            case "implementation": {
+                // Implementers can run any non-prohibited project command
+                for (const cmd of projectCommands.permitted) {
+                    if (!prohibited.some((p) => cmd.startsWith(p) || p.startsWith(cmd))) {
+                        permitted.push(cmd);
+                    }
+                }
+                // Allow test commands for implementation
+                permitted.push("bun test", "npm test", "pnpm test", "yarn test");
+                permitted.push("python -m pytest");
+                break;
+            }
+            case "test": {
+                // Test tasks can run test commands
+                for (const cmd of projectCommands.test) {
+                    if (!prohibited.includes(cmd)) {
+                        permitted.push(cmd);
+                    }
+                }
+                permitted.push("bun test", "npm test", "pnpm test", "yarn test");
+                permitted.push("python -m pytest", "python -m unittest");
+                break;
+            }
+            case "e2e_test": {
+                // E2E tasks can run e2e/playwright commands
+                for (const cmd of projectCommands.e2e) {
+                    if (!prohibited.includes(cmd)) {
+                        permitted.push(cmd);
+                    }
+                }
+                permitted.push("npx playwright test");
+                permitted.push("cypress run");
+                break;
+            }
+            case "review": {
+                // Review tasks can run lint/typecheck commands
+                for (const cmd of projectCommands.lint) {
+                    if (!prohibited.includes(cmd)) {
+                        permitted.push(cmd);
+                    }
+                }
+                permitted.push("npx tsc --noEmit");
+                permitted.push("npx eslint");
+                permitted.push("npx biome check");
+                break;
+            }
+            case "repair": {
+                // Repair tasks can run build/test but NOT commit
+                for (const cmd of projectCommands.permitted) {
+                    if (!prohibited.some((p) => cmd.startsWith(p))) {
+                        permitted.push(cmd);
+                    }
+                }
+                permitted.push("bun test", "npm test");
+                // Explicitly keep destructive ops away from repair without approval
+                prohibited.push("rm -rf", "DROP DATABASE", "TRUNCATE");
+                break;
+            }
+            case "analysis":
+            case "design":
+            case "documentation": {
+                // Read-only/analysis tasks get minimal command access
+                permitted.push("npx tsc --noEmit");
+                permitted.push("git status");
+                permitted.push("git diff");
+                break;
+            }
+        }
+        // Explicitly prohibit dangerous commands that must always be blocked
+        const alwaysProhibited = [
+            "rm -rf /**",
+            "DROP DATABASE",
+            "TRUNCATE TABLE",
+            "bench migrate --force",
+        ];
+        for (const cmd of alwaysProhibited) {
+            if (!prohibited.includes(cmd)) {
+                prohibited.push(cmd);
+            }
+        }
+        return {
+            ...task,
+            permittedCommands: [...new Set(permitted)],
+            prohibitedCommands: [...new Set(prohibited)],
+        };
+    });
+}
+function extractProjectCommands(project) {
+    const result = {
+        permitted: [],
+        prohibited: [],
+        test: [],
+        e2e: [],
+        lint: [],
+    };
+    // Extract from project commands
+    if (project.commands) {
+        for (const [name, cmd] of Object.entries(project.commands)) {
+            if (typeof cmd !== "string")
+                continue;
+            const fullCmd = cmd.trim();
+            if (/^test|^spec/i.test(name)) {
+                result.test.push(fullCmd);
+            }
+            else if (/^lint|^check|^type/i.test(name)) {
+                result.lint.push(fullCmd);
+            }
+            else {
+                result.permitted.push(fullCmd);
+            }
+        }
+    }
+    // Extract from project rules
+    if (project.rules) {
+        for (const rule of project.rules) {
+            if (rule.permittedCommands) {
+                for (const cmd of rule.permittedCommands) {
+                    if (!result.permitted.includes(cmd)) {
+                        result.permitted.push(cmd);
+                    }
+                }
+            }
+            if (rule.prohibitedCommands) {
+                for (const cmd of rule.prohibitedCommands) {
+                    if (!result.prohibited.includes(cmd)) {
+                        result.prohibited.push(cmd);
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=command-policy.js.map

package/packages/task-compiler/dist/command-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-policy.js","sourceRoot":"","sources":["../src/command-policy.ts"],"names":[],"mappings":"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"}

package/packages/task-compiler/dist/compiler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Task Compiler - Main Entry Point
+ *
+ * Compiles a compiled requirement + project profile into an executable task DAG.
+ *
+ * Algorithm:
+ * 1. Decompose requirement into candidate tasks
+ * 2. Assign file scope and ownership
+ * 3. Assign verification outputs
+ * 4. Apply command policy
+ * 5. Build DAG with topological sort
+ * 6. Validate: cycles, overlap, verification
+ * 7. Assign provider hints
+ */
+import type { TaskCompileInput, TaskCompilerConfig, TaskGraph } from "./types.js";
+/**
+ * Compile a requirement + project profile into an executable task graph.
+ *
+ * This is the main public API for the task compiler.
+ */
+export declare function compileTasks(input: TaskCompileInput, config?: Partial<TaskCompilerConfig>): Promise<TaskGraph>;
+//# sourceMappingURL=compiler.d.ts.map

package/packages/task-compiler/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAMH,OAAO,KAAK,EACX,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,EACT,MAAM,YAAY,CAAC;AAgBpB;;;;GAIG;AACH,wBAAsB,YAAY,CACjC,KAAK,EAAE,gBAAgB,EACvB,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAClC,OAAO,CAAC,SAAS,CAAC,CAkEpB"}

package/packages/task-compiler/dist/compiler.js

@@ -0,0 +1,66 @@
+/**
+ * Task Compiler - Main Entry Point
+ *
+ * Compiles a compiled requirement + project profile into an executable task DAG.
+ *
+ * Algorithm:
+ * 1. Decompose requirement into candidate tasks
+ * 2. Assign file scope and ownership
+ * 3. Assign verification outputs
+ * 4. Apply command policy
+ * 5. Build DAG with topological sort
+ * 6. Validate: cycles, overlap, verification
+ * 7. Assign provider hints
+ */
+import { applyCommandPolicy } from "./command-policy.js";
+import { decomposeRequirement } from "./decompose.js";
+import { assignFileScope } from "./file-scope.js";
+import { buildGraph } from "./graph.js";
+import { DEFAULT_TASK_COMPILER_CONFIG, PROVIDER_HINTS, TaskCompilerError, TaskCompilerErrorCode, } from "./types.js";
+import { assertEveryCriterionAssigned, assertEveryTaskHasVerification, assertNoCycles, assertNoEmptyObjectives, assertNoExclusiveFileOverlap, } from "./validate.js";
+import { assignVerification } from "./verification.js";
+/**
+ * Compile a requirement + project profile into an executable task graph.
+ *
+ * This is the main public API for the task compiler.
+ */
+export async function compileTasks(input, config) {
+    const fullConfig = {
+        ...DEFAULT_TASK_COMPILER_CONFIG,
+        ...config,
+    };
+    // Clock used for reproducible timestamps (available for future use)
+    fullConfig.clock;
+    const jobId = input.jobId;
+    // ─── Step 1: Decompose requirement into candidates ─────────────────────────
+    const candidates = decomposeRequirement(input);
+    if (candidates.length === 0) {
+        throw new TaskCompilerError(TaskCompilerErrorCode.EMPTY_OBJECTIVE, `Requirement "${input.requirement.id}" produced no tasks after decomposition.`, { requirementId: input.requirement.id });
+    }
+    // ─── Step 2: Assign file scope and ownership ─────────────────────────────
+    const tasksWithScope = assignFileScope(candidates, input.project);
+    // ─── Step 3: Assign verification outputs ────────────────────────────────
+    const tasksWithVerification = assignVerification(tasksWithScope, input.requirement);
+    // ─── Step 4: Apply command policy ───────────────────────────────────
+    const tasksWithPolicy = applyCommandPolicy(tasksWithVerification, input.project);
+    // ─── Step 5: Assign jobId, provider hints, and finalize ───────────────
+    const finalizedTasks = tasksWithPolicy.map((task) => ({
+        ...task,
+        jobId,
+        preferredProvider: PROVIDER_HINTS[task.type]?.[0],
+    }));
+    // ─── Step 6: Build graph ─────────────────────────────────────────────
+    const graph = buildGraph(finalizedTasks);
+    // ─── Step 7: Validate ────────────────────────────────────────────────
+    assertNoEmptyObjectives(graph);
+    assertNoCycles(graph);
+    assertNoExclusiveFileOverlap(graph);
+    assertEveryTaskHasVerification(graph);
+    // Every acceptance criterion must be assigned to at least one task
+    const acIds = input.requirement.acceptanceCriteria.map((c) => c.id);
+    if (acIds.length > 0) {
+        assertEveryCriterionAssigned(graph, acIds);
+    }
+    return graph;
+}
+//# sourceMappingURL=compiler.js.map

package/packages/task-compiler/dist/compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMxC,OAAO,EACN,4BAA4B,EAC5B,cAAc,EACd,iBAAiB,EACjB,qBAAqB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,4BAA4B,EAC5B,8BAA8B,EAC9B,cAAc,EACd,uBAAuB,EACvB,4BAA4B,GAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CACjC,KAAuB,EACvB,MAAoC;IAEpC,MAAM,UAAU,GAAuB;QACtC,GAAG,4BAA4B;QAC/B,GAAG,MAAM;KACT,CAAC;IAEF,oEAAoE;IACpE,UAAU,CAAC,KAAK,CAAC;IACjB,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;IAE1B,8EAA8E;IAE9E,MAAM,UAAU,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAE/C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,iBAAiB,CAC1B,qBAAqB,CAAC,eAAe,EACrC,gBAAgB,KAAK,CAAC,WAAW,CAAC,EAAE,0CAA0C,EAC9E,EAAE,aAAa,EAAE,KAAK,CAAC,WAAW,CAAC,EAAE,EAAE,CACvC,CAAC;IACH,CAAC;IAED,4EAA4E;IAE5E,MAAM,cAAc,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAElE,2EAA2E;IAE3E,MAAM,qBAAqB,GAAG,kBAAkB,CAC/C,cAAc,EACd,KAAK,CAAC,WAAW,CACjB,CAAC;IAEF,uEAAuE;IAEvE,MAAM,eAAe,GAAG,kBAAkB,CACzC,qBAAqB,EACrB,KAAK,CAAC,OAAO,CACb,CAAC;IAEF,yEAAyE;IAEzE,MAAM,cAAc,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QACrD,GAAG,IAAI;QACP,KAAK;QACL,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;KACjD,CAAC,CAAC,CAAC;IAEJ,wEAAwE;IAExE,MAAM,KAAK,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;IAEzC,wEAAwE;IAExE,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC/B,cAAc,CAAC,KAAK,CAAC,CAAC;IACtB,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,8BAA8B,CAAC,KAAK,CAAC,CAAC;IAEtC,mEAAmE;IACnE,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACpE,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,4BAA4B,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}