pi-lens 3.2.0 → 3.3.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [3.3.0] - 2026-04-02
+
+### Removed
+- **`--lens-bus`**: Removed the experimental event bus system (Phase 1). The sequential dispatcher has richer features (delta mode, per-runner latency, baseline tracking) that the bus system never had.
+- **`--lens-bus-debug`**: Removed alongside `--lens-bus`.
+- **`--lens-effect`**: Removed the Effect-TS concurrent runner execution system (Phase 2). The sequential `dispatchForFile` is the authoritative implementation — it has delta mode, async `when()` handling, and latency tracking that the effect system lacked.
+
+### Changed
+- **LSP client**: `waitForDiagnostics` in `clients/lsp/client.ts` now uses a local `EventEmitter` scoped to the client instance instead of the global bus for internal diagnostic signalling.
+
+---
+
 ## [3.2.0] - 2026-04-02
 
 ### Fixed

package/README.md

@@ -31,8 +31,8 @@ pi --no-autoformat
 # Full LSP mode (31 language servers)
 pi --lens-lsp
 
-# Fastest mode (LSP + concurrent execution) (Experimental)
-pi --lens-lsp --lens-effect
+# LSP mode (recommended for large projects)
+pi --lens-lsp
 ```
 
 ## Install
@@ -136,7 +136,6 @@ Enable full Language Server Protocol support with `--lens-lsp`:
 **Usage:**
 ```bash
 pi --lens-lsp                    # Enable LSP
-pi --lens-lsp --lens-effect      # LSP + concurrent execution
 ```
 
 ### `pi` vs `pi --lens-lsp`
@@ -162,7 +161,6 @@ See [docs/LSP_CONFIG.md](docs/LSP_CONFIG.md) for configuration options.
 | Mode | Flag | Description |
 |------|------|-------------|
 | **Sequential** | (default) | Runners execute one at a time |
-| **Concurrent** | `--lens-effect` | All runners in parallel via Effect-TS (Experimental) |
 
 ---
 
@@ -177,8 +175,6 @@ Every file write/edit triggers multiple analysis phases:
 4. **Runners execute** by priority (lower = earlier). See [Runners](#runners) section for full list.
 5. **Test runner detection** (post-write) — Detects Jest/Vitest/Pytest and runs relevant tests
 
-**With `--lens-effect`:** Dispatch runners execute concurrently via Effect-TS. Test runner remains sequential (step 5).
-
 **Delta mode behavior:**
 - **First write:** All issues tracked and stored in baseline
 - **Subsequent edits:** Only **NEW** issues shown (pre-existing issues filtered out)
@@ -480,7 +476,7 @@ pi-lens works out of the box for TypeScript/JavaScript. For full language suppor
 |------|---------|--------------|
 | **Standard** (default) | `pi` | Auto-formatting, TS/Python type-checking, sequential execution |
 | **Full LSP** | `pi --lens-lsp` | Real LSP servers (31 languages), sequential execution |
-| **Fastest** | `pi --lens-lsp --lens-effect` | Real LSP + concurrent execution (all runners in parallel) |
+| **Fastest** | `pi --lens-lsp` | Real LSP + full runner suite |
 
 
 ### Flag Reference
@@ -488,7 +484,6 @@ pi-lens works out of the box for TypeScript/JavaScript. For full language suppor
 | Flag | Description |
 |------|-------------|
 | `--lens-lsp` | Use real Language Server Protocol servers instead of built-in type-checking |
-| `--lens-effect` | Run all runners **concurrently** (faster) instead of sequentially (Experimental) |
 | `--lens-verbose` | Enable detailed console logging |
 | `--no-autoformat` | Disable automatic formatting (formatting is **enabled by default**) |
 | `--no-autofix` | Disable all auto-fixing (Biome safe fixes + Ruff autofix **enabled by default**). Unsafe fixes (e.g. removing unused vars) are never applied automatically — use `/lens-booboo` with explicit confirmation. |
@@ -507,7 +502,7 @@ pi-lens works out of the box for TypeScript/JavaScript. For full language suppor
 ```bash
 pi                               # Default: auto-format, auto-fix, built-in type-checking
 pi --lens-lsp                    # LSP type-checking (31 languages)
-pi --lens-lsp --lens-effect      # LSP + concurrent execution (fastest)
+pi --lens-lsp                    # LSP mode (recommended)
 ```
 
 ---
@@ -705,7 +700,6 @@ See [CHANGELOG.md](CHANGELOG.md) for full history.
 ### Latest Highlights
 
 - **LSP Support:** 31 Language Server Protocol clients (4 core auto-installed, others via npx or manual)
-- **Concurrent Execution:** Effect-TS-based parallel runner execution with `--lens-effect`
 - **NAPI Runner:** 100x faster TypeScript/JavaScript structural analysis (~9ms vs ~1200ms) — currently disabled in realtime due to stability
 - **Slop Detection:** 33+ TypeScript and 40+ Python patterns for AI-generated code quality issues
 

package/clients/__tests__/file-time.test.js

@@ -0,0 +1,216 @@
+/**
+ * FileTime Tracking Tests
+ *
+ * Tests the safety mechanism that prevents race conditions
+ * between auto-formatting and agent edits.
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { FileTime, FileTimeError, createFileTime, clearAllSessions } from "../file-time.js";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEST_DIR = path.join(__dirname, "..", "..", "test-filetime");
+describe("FileTime", () => {
+    let fileTime;
+    const sessionID = "test-session";
+    beforeEach(() => {
+        clearAllSessions();
+        fileTime = new FileTime(sessionID);
+        // Ensure test directory exists
+        if (!fs.existsSync(TEST_DIR)) {
+            fs.mkdirSync(TEST_DIR, { recursive: true });
+        }
+    });
+    describe("read()", () => {
+        it("should record file stamp with mtime/ctime/size", () => {
+            const testFile = path.join(TEST_DIR, "test1.txt");
+            fs.writeFileSync(testFile, "hello");
+            const stamp = fileTime.read(testFile);
+            expect(stamp.readAt).toBeInstanceOf(Date);
+            expect(stamp.mtime).toBeDefined();
+            expect(stamp.ctime).toBeDefined();
+            expect(stamp.size).toBe(5);
+        });
+        it("should handle non-existent files gracefully", () => {
+            const testFile = path.join(TEST_DIR, "nonexistent.txt");
+            const stamp = fileTime.read(testFile);
+            expect(stamp.readAt).toBeInstanceOf(Date);
+            expect(stamp.mtime).toBeUndefined();
+            expect(stamp.ctime).toBeUndefined();
+            expect(stamp.size).toBeUndefined();
+        });
+        it("should track multiple files per session", () => {
+            const file1 = path.join(TEST_DIR, "file1.txt");
+            const file2 = path.join(TEST_DIR, "file2.txt");
+            fs.writeFileSync(file1, "content1");
+            fs.writeFileSync(file2, "content2");
+            fileTime.read(file1);
+            fileTime.read(file2);
+            expect(fileTime.get(file1)).toBeDefined();
+            expect(fileTime.get(file2)).toBeDefined();
+        });
+    });
+    describe("get()", () => {
+        it("should return undefined for unread files", () => {
+            const testFile = path.join(TEST_DIR, "unread.txt");
+            const stamp = fileTime.get(testFile);
+            expect(stamp).toBeUndefined();
+        });
+        it("should return recorded stamp for read files", () => {
+            const testFile = path.join(TEST_DIR, "test2.txt");
+            fs.writeFileSync(testFile, "content");
+            const recorded = fileTime.read(testFile);
+            const retrieved = fileTime.get(testFile);
+            expect(retrieved?.mtime).toBe(recorded.mtime);
+            expect(retrieved?.ctime).toBe(recorded.ctime);
+            expect(retrieved?.size).toBe(recorded.size);
+        });
+    });
+    describe("assert()", () => {
+        it("should throw FileTimeError for unread files", () => {
+            const testFile = path.join(TEST_DIR, "never-read.txt");
+            fs.writeFileSync(testFile, "content");
+            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
+            expect(() => fileTime.assert(testFile)).toThrow(/must read file/);
+        });
+        it("should not throw for unchanged files", () => {
+            const testFile = path.join(TEST_DIR, "unchanged.txt");
+            fs.writeFileSync(testFile, "content");
+            fileTime.read(testFile);
+            expect(() => fileTime.assert(testFile)).not.toThrow();
+        });
+        it("should throw FileTimeError when file modified externally", () => {
+            const testFile = path.join(TEST_DIR, "modified.txt");
+            fs.writeFileSync(testFile, "original");
+            fileTime.read(testFile);
+            // Simulate external modification
+            fs.writeFileSync(testFile, "modified content");
+            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
+            expect(() => fileTime.assert(testFile)).toThrow(/modified since it was last read/);
+        });
+        it("should detect size changes", () => {
+            const testFile = path.join(TEST_DIR, "size-change.txt");
+            fs.writeFileSync(testFile, "original content");
+            fileTime.read(testFile);
+            // Truncate file (size change, mtime change)
+            fs.writeFileSync(testFile, "x");
+            expect(() => fileTime.assert(testFile)).toThrow(FileTimeError);
+        });
+    });
+    describe("hasChanged()", () => {
+        it("should return true for unread files", () => {
+            const testFile = path.join(TEST_DIR, "unread-check.txt");
+            fs.writeFileSync(testFile, "content");
+            expect(fileTime.hasChanged(testFile)).toBe(true);
+        });
+        it("should return false for unchanged files", () => {
+            const testFile = path.join(TEST_DIR, "unchanged-check.txt");
+            fs.writeFileSync(testFile, "content");
+            fileTime.read(testFile);
+            expect(fileTime.hasChanged(testFile)).toBe(false);
+        });
+        it("should return true when file modified", () => {
+            const testFile = path.join(TEST_DIR, "changed-check.txt");
+            fs.writeFileSync(testFile, "original");
+            fileTime.read(testFile);
+            fs.writeFileSync(testFile, "changed");
+            expect(fileTime.hasChanged(testFile)).toBe(true);
+        });
+    });
+    describe("withLock()", () => {
+        it("should execute function exclusively", async () => {
+            const testFile = path.join(TEST_DIR, "locked.txt");
+            const executionOrder = [];
+            const fn1 = async () => {
+                executionOrder.push("start1");
+                await new Promise(r => setTimeout(r, 50));
+                executionOrder.push("end1");
+                return "result1";
+            };
+            const fn2 = async () => {
+                executionOrder.push("start2");
+                await new Promise(r => setTimeout(r, 50));
+                executionOrder.push("end2");
+                return "result2";
+            };
+            // Start both, but they should execute sequentially
+            const promise1 = fileTime.withLock(testFile, fn1);
+            const promise2 = fileTime.withLock(testFile, fn2);
+            await Promise.all([promise1, promise2]);
+            // Should be sequential, not interleaved
+            expect(executionOrder).toEqual(["start1", "end1", "start2", "end2"]);
+        });
+        it("should return function result", async () => {
+            const testFile = path.join(TEST_DIR, "lock-result.txt");
+            const result = await fileTime.withLock(testFile, async () => {
+                return "success";
+            });
+            expect(result).toBe("success");
+        });
+    });
+    describe("clear()", () => {
+        it("should clear all tracked files for session", () => {
+            const file1 = path.join(TEST_DIR, "clear1.txt");
+            const file2 = path.join(TEST_DIR, "clear2.txt");
+            fs.writeFileSync(file1, "a");
+            fs.writeFileSync(file2, "b");
+            fileTime.read(file1);
+            fileTime.read(file2);
+            fileTime.clear();
+            expect(fileTime.get(file1)).toBeUndefined();
+            expect(fileTime.get(file2)).toBeUndefined();
+        });
+    });
+    describe("cross-session isolation", () => {
+        it("should isolate file tracking between sessions", () => {
+            const testFile = path.join(TEST_DIR, "isolated.txt");
+            fs.writeFileSync(testFile, "content");
+            const session1 = new FileTime("session1");
+            const session2 = new FileTime("session2");
+            session1.read(testFile);
+            // session2 should not see session1's reads
+            expect(() => session2.assert(testFile)).toThrow(FileTimeError);
+            expect(() => session2.assert(testFile)).toThrow(/must read file/);
+        });
+    });
+    describe("FileTimeError", () => {
+        it("should have correct error properties", () => {
+            const testFile = path.join(TEST_DIR, "error.txt");
+            fs.writeFileSync(testFile, "content");
+            try {
+                fileTime.assert(testFile);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(FileTimeError);
+                expect(error.name).toBe("FileTimeError");
+                expect(error.filePath).toBe(path.resolve(testFile));
+                expect(error.reason).toBe("not-read");
+            }
+        });
+    });
+});
+describe("createFileTime helper", () => {
+    it("should create FileTime instance with session ID", () => {
+        const ft = createFileTime("my-session");
+        expect(ft).toBeInstanceOf(FileTime);
+    });
+});
+describe("clearAllSessions helper", () => {
+    it("should clear all session tracking", () => {
+        const ft1 = createFileTime("session1");
+        const ft2 = createFileTime("session2");
+        const testFile = path.join(TEST_DIR, "clearall.txt");
+        fs.writeFileSync(testFile, "x");
+        ft1.read(testFile);
+        ft2.read(testFile);
+        clearAllSessions();
+        // After clearing, both should throw "not read"
+        const ft1New = createFileTime("session1");
+        const ft2New = createFileTime("session2");
+        expect(() => ft1New.assert(testFile)).toThrow(/must read file/);
+        expect(() => ft2New.assert(testFile)).toThrow(/must read file/);
+    });
+});

package/clients/__tests__/format-service.test.js

@@ -0,0 +1,245 @@
+/**
+ * Format Service Tests
+ *
+ * Tests concurrent formatter execution via Effect-TS
+ * and FileTime integration for safety.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { FileTimeError } from "../file-time.js";
+import { FormatService, getFormatService, resetFormatService, } from "../format-service.js";
+import { clearAllSessions } from "../file-time.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEST_DIR = path.join(__dirname, "..", "..", "test-format-service");
+describe("FormatService", () => {
+    let formatService;
+    const sessionID = "test-format-session";
+    beforeEach(() => {
+        resetFormatService();
+        clearAllSessions(); // Clear FileTime global state for test isolation
+        formatService = new FormatService(sessionID, true);
+        if (fs.existsSync(TEST_DIR)) {
+            fs.rmSync(TEST_DIR, { recursive: true });
+        }
+        fs.mkdirSync(TEST_DIR, { recursive: true });
+    });
+    afterEach(() => {
+        resetFormatService();
+        clearAllSessions(); // Clear FileTime global state for test isolation
+        if (fs.existsSync(TEST_DIR)) {
+            fs.rmSync(TEST_DIR, { recursive: true });
+        }
+    });
+    describe("formatFile()", () => {
+        it("should skip formatting when disabled", async () => {
+            const disabledService = new FormatService(sessionID, false);
+            const testFile = path.join(TEST_DIR, "disabled.txt");
+            fs.writeFileSync(testFile, "content");
+            const result = await disabledService.formatFile(testFile);
+            expect(result.formatters).toEqual([]);
+            expect(result.anyChanged).toBe(false);
+            expect(result.allSucceeded).toBe(true);
+        });
+        it("should skip formatting with skip option", async () => {
+            const testFile = path.join(TEST_DIR, "skipped.txt");
+            fs.writeFileSync(testFile, "content");
+            const result = await formatService.formatFile(testFile, { skip: true });
+            expect(result.formatters).toEqual([]);
+            expect(result.anyChanged).toBe(false);
+            expect(result.allSucceeded).toBe(true);
+        });
+        it("should skip when file modified externally", async () => {
+            const testFile = path.join(TEST_DIR, "external.txt");
+            fs.writeFileSync(testFile, "original");
+            // Record read
+            formatService.recordRead(testFile);
+            // Modify externally
+            fs.writeFileSync(testFile, "modified");
+            const result = await formatService.formatFile(testFile);
+            expect(result.formatters).toEqual([]);
+            expect(result.anyChanged).toBe(false);
+            expect(result.allSucceeded).toBe(false);
+        });
+        it("should format TypeScript file with biome config", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), '{"formatter": {}}');
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x=1;");
+            // Record read so format service knows initial state
+            formatService.recordRead(tsFile);
+            const result = await formatService.formatFile(tsFile);
+            expect(result.filePath).toBe(tsFile);
+            expect(result.formatters.some((f) => f.name === "biome")).toBe(true);
+        });
+        it("should format Python file with ruff config", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "pyproject.toml"), "[tool.ruff]\nline-length = 100");
+            const pyFile = path.join(TEST_DIR, "test.py");
+            fs.writeFileSync(pyFile, "x=1");
+            // Record read so format service knows initial state
+            formatService.recordRead(pyFile);
+            const result = await formatService.formatFile(pyFile);
+            expect(result.filePath).toBe(pyFile);
+            expect(result.formatters.some((f) => f.name === "ruff")).toBe(true);
+        });
+        it("should run multiple formatters for same file", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify({ devDependencies: { prettier: "^3.0.0" } }));
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x = 1;");
+            formatService.recordRead(tsFile);
+            const result = await formatService.formatFile(tsFile);
+            const names = result.formatters.map((f) => f.name);
+            expect(names).toContain("biome");
+        });
+        it("should return empty result for unsupported file", async () => {
+            const txtFile = path.join(TEST_DIR, "test.txt");
+            fs.writeFileSync(txtFile, "content");
+            formatService.recordRead(txtFile);
+            const result = await formatService.formatFile(txtFile);
+            expect(result.formatters).toEqual([]);
+            expect(result.anyChanged).toBe(false);
+            expect(result.allSucceeded).toBe(true);
+        });
+        it("should record FileTime after formatting", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x = 1;");
+            formatService.recordRead(tsFile);
+            await formatService.formatFile(tsFile);
+            expect(() => formatService.assertUnchanged(tsFile)).not.toThrow();
+        });
+        it("should report success/failure for each formatter", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x = 1;");
+            formatService.recordRead(tsFile);
+            const result = await formatService.formatFile(tsFile);
+            for (const formatter of result.formatters) {
+                expect(formatter).toHaveProperty("name");
+                expect(formatter).toHaveProperty("success");
+                expect(formatter).toHaveProperty("changed");
+                expect(typeof formatter.success).toBe("boolean");
+                expect(typeof formatter.changed).toBe("boolean");
+            }
+        });
+        it("should re-read file content after formatting", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x = 1;");
+            formatService.recordRead(tsFile);
+            const _result = await formatService.formatFile(tsFile);
+            const after = fs.readFileSync(tsFile, "utf-8");
+            expect(after).toBeDefined();
+        });
+    });
+    describe("assertUnchanged()", () => {
+        it("should not throw for unchanged files", async () => {
+            const testFile = path.join(TEST_DIR, "unchanged.txt");
+            fs.writeFileSync(testFile, "content");
+            formatService.recordRead(testFile);
+            expect(() => formatService.assertUnchanged(testFile)).not.toThrow();
+        });
+        it("should throw FileTimeError when file modified", async () => {
+            const testFile = path.join(TEST_DIR, "modified.txt");
+            fs.writeFileSync(testFile, "original");
+            formatService.recordRead(testFile);
+            fs.writeFileSync(testFile, "changed");
+            expect(() => formatService.assertUnchanged(testFile)).toThrow(FileTimeError);
+        });
+    });
+    describe("hasChanged()", () => {
+        it("should return false for unchanged files", async () => {
+            const testFile = path.join(TEST_DIR, "unchanged-check.txt");
+            fs.writeFileSync(testFile, "content");
+            formatService.recordRead(testFile);
+            expect(formatService.hasChanged(testFile)).toBe(false);
+        });
+        it("should return true when file modified", async () => {
+            const testFile = path.join(TEST_DIR, "changed-check.txt");
+            fs.writeFileSync(testFile, "original");
+            formatService.recordRead(testFile);
+            // Small delay to ensure different mtime (Windows has ~16ms resolution)
+            await new Promise((r) => setTimeout(r, 50));
+            fs.writeFileSync(testFile, "modified");
+            expect(formatService.hasChanged(testFile)).toBe(true);
+        });
+        it("should return true for unread files", async () => {
+            const testFile = path.join(TEST_DIR, "never-read.txt");
+            fs.writeFileSync(testFile, "content");
+            expect(formatService.hasChanged(testFile)).toBe(true);
+        });
+    });
+    describe("recordRead()", () => {
+        it("should record file read for tracking", async () => {
+            const testFile = path.join(TEST_DIR, "tracked.txt");
+            fs.writeFileSync(testFile, "content");
+            formatService.recordRead(testFile);
+            expect(formatService.hasChanged(testFile)).toBe(false);
+        });
+    });
+    describe("clearCache()", () => {
+        it("should clear formatter detection cache", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const tsFile = path.join(TEST_DIR, "test.ts");
+            fs.writeFileSync(tsFile, "const x = 1;");
+            formatService.recordRead(tsFile);
+            await formatService.formatFile(tsFile);
+            formatService.clearCache();
+            await formatService.formatFile(tsFile);
+        });
+    });
+    describe("Concurrency", () => {
+        it("should handle multiple files concurrently", async () => {
+            fs.writeFileSync(path.join(TEST_DIR, "biome.json"), "{}");
+            const files = [
+                path.join(TEST_DIR, "file1.ts"),
+                path.join(TEST_DIR, "file2.ts"),
+                path.join(TEST_DIR, "file3.ts"),
+            ];
+            for (const file of files) {
+                fs.writeFileSync(file, "const x = 1;");
+                formatService.recordRead(file);
+            }
+            const results = await Promise.all(files.map((f) => formatService.formatFile(f)));
+            expect(results).toHaveLength(3);
+            for (const result of results) {
+                expect(result.filePath).toBeDefined();
+                expect(result.formatters.length).toBeGreaterThan(0);
+            }
+        });
+    });
+});
+describe("getFormatService singleton", () => {
+    beforeEach(() => {
+        resetFormatService();
+    });
+    afterEach(() => {
+        resetFormatService();
+    });
+    it("should return singleton instance", () => {
+        const instance1 = getFormatService();
+        const instance2 = getFormatService();
+        expect(instance1).toBe(instance2);
+    });
+    it("should create new instance when session ID provided", () => {
+        const instance1 = getFormatService("session1");
+        const instance2 = getFormatService("session2");
+        expect(instance1).not.toBe(instance2);
+    });
+    it("should use cached instance regardless of enabled flag changes", () => {
+        const first = getFormatService("test", true);
+        const second = getFormatService("test", false);
+        expect(first).toBe(second);
+    });
+});
+describe("resetFormatService", () => {
+    it("should reset singleton instance", () => {
+        const instance1 = getFormatService();
+        resetFormatService();
+        const instance2 = getFormatService();
+        expect(instance1).not.toBe(instance2);
+    });
+});