@akiojin/unity-mcp-server 2.41.8 → 2.42.1

package/README.md

@@ -307,12 +307,102 @@ Add to your `claude_desktop_config.json`:
   - `includeTestResults` (bool, default `false`): attaches the latest exported `.unity/test-results/*.json` summary to the response when a test run has completed.
   - `includeFileContent` (bool, default `false`): when combined with `includeTestResults`, also returns the JSON file contents as a string so agents can parse the detailed per-test data without reading the file directly.
 
+## Architecture
+
+### Native Dependencies
+
+Unity MCP Server uses platform-specific native binaries for performance-critical operations:
+
+| Component | Purpose | Distribution | Size per platform |
+|-----------|---------|--------------|-------------------|
+| **better-sqlite3** | Code index database | Bundled in npm package | ~3-5 MB |
+| **csharp-lsp** | C# symbol analysis | Downloaded on first use | ~80 MB |
+
+#### Why better-sqlite3 over JavaScript-based SQLite?
+
+We chose **better-sqlite3** (native C binding) instead of JavaScript-based alternatives like **sql.js** for the following reasons:
+
+| Aspect | better-sqlite3 (native) | sql.js (WASM/JS) |
+|--------|------------------------|------------------|
+| **Performance** | 10-100x faster for bulk operations | Slower due to WASM overhead |
+| **Memory** | Efficient native memory management | Higher memory usage, GC pressure |
+| **Synchronous API** | Native sync operations, ideal for MCP | Async-only, adds complexity |
+| **Startup time** | Instant module load | ~100-500ms WASM initialization |
+| **Database size** | Handles large indexes efficiently | Performance degrades with size |
+
+The code index database may contain tens of thousands of symbols from Unity projects. Native SQLite provides the performance characteristics needed for responsive symbol searches and incremental updates.
+
+**Trade-off**: Requires platform-specific binaries (bundled for all supported platforms), while sql.js would work everywhere but with unacceptable performance for our use case.
+
+#### Why Different Distribution Methods?
+
+**better-sqlite3 (bundled)**:
+
+- Small size (~3-5 MB per platform)
+- Prevents MCP server initialization timeout during `npm install` compilation
+- Code index features disabled with clear error message if native binding fails
+
+**csharp-lsp (downloaded)**:
+
+- Large size (~80 MB per platform, ~480 MB for all 6 platforms)
+- Too large to bundle in npm package (would increase package size 100x)
+- Downloaded from GitHub Release on first use of script editing tools
+
+#### Supported Platforms
+
+| Platform | better-sqlite3 | csharp-lsp |
+|----------|---------------|------------|
+| Linux x64 | ✅ Bundled | ✅ Downloaded (~79 MB) |
+| Linux arm64 | ✅ Bundled | ✅ Downloaded (~86 MB) |
+| macOS x64 | ✅ Bundled | ✅ Downloaded (~80 MB) |
+| macOS arm64 (Apple Silicon) | ✅ Bundled | ✅ Downloaded (~86 MB) |
+| Windows x64 | ✅ Bundled | ✅ Downloaded (~80 MB) |
+| Windows arm64 | ✅ Bundled | ✅ Downloaded (~85 MB) |
+
+#### Fallback Behavior
+
+- **better-sqlite3**: No fallback; code index features disabled with clear error if native binding unavailable
+- **csharp-lsp**: No fallback; script editing features require the native binary
+
+#### Storage Locations
+
+- **better-sqlite3**: `<package>/prebuilt/better-sqlite3/<platform>/`
+- **csharp-lsp**: `~/.unity/tools/csharp-lsp/<rid>/`
+- **Code index database**: `<workspace>/.unity/cache/code-index/code-index.db`
+
 ## Requirements
 
 - **Unity**: 2020.3 LTS or newer (Unity 6 supported)
 - **Node.js**: 18.0.0 or newer
 - **MCP Client**: Claude Desktop, Cursor, or compatible client
 
+## Performance Benchmark
+
+Response time comparison between Code Index tools and standard Claude Code tools (with DB index built, `watch: true` enabled):
+
+| Operation | unity-mcp-server | Time | Standard Tool | Time | Result |
+|-----------|------------------|------|---------------|------|--------|
+| File Read | `script_read` | **instant** | `Read` | **instant** | EQUAL |
+| Symbol List | `script_symbols_get` | **instant** | N/A | N/A | PASS |
+| Symbol Find | `script_symbol_find` | **instant** | `Grep` | **instant** | EQUAL |
+| Text Search | `script_search` | **instant** | `Grep` | **instant** | EQUAL |
+| Reference Find | `script_refs_find` | **instant** | `Grep` | **instant** | EQUAL |
+| Index Status | `code_index_status` | **instant** | N/A | N/A | PASS |
+
+**Note**: Performance above requires DB index to be built. Run `code_index_build` before first use.
+
+### Worker Thread Implementation
+
+Since v2.41.x, background index builds run in Worker Threads, so MCP tools are never blocked even with `watch: true`:
+
+| Scenario | Before Worker Thread | After Worker Thread |
+|----------|---------------------|---------------------|
+| `system_ping` | **60+ seconds block** | **instant** |
+| `code_index_status` | **60+ seconds block** | **instant** |
+| Any MCP tool | timeout during build | **instant** |
+
+See [`docs/benchmark.md`](../docs/benchmark.md) for detailed benchmark results.
+
 ## Troubleshooting
 
 ### Connection Issues
@@ -338,23 +428,16 @@ If you encounter errors related to `better-sqlite3` during installation or start
 
 **Symptom**: Installation fails with `node-gyp` errors, or startup shows "Could not locate the bindings file."
 
-**Cause**: The package includes prebuilt native binaries for supported platforms (Linux/macOS/Windows × x64/arm64 × Node 18/20/22). If your platform isn't supported or the prebuilt fails to load, the system falls back to WASM.
-
-**Solution 1 - Use WASM fallback (recommended for unsupported platforms)**:
-
-```bash
-# Skip native build and use sql.js WASM fallback
-UNITY_MCP_SKIP_NATIVE_BUILD=1 npm install @akiojin/unity-mcp-server
-```
+**Cause**: The package includes prebuilt native binaries for supported platforms (Linux/macOS/Windows × x64/arm64 × Node 18/20/22). If your platform isn't supported or the prebuilt fails to load, code index features will be disabled.
 
-**Solution 2 - Force native rebuild**:
+**Solution - Force native rebuild**:
 
 ```bash
 # Force rebuild from source (requires build tools)
 UNITY_MCP_FORCE_NATIVE=1 npm install @akiojin/unity-mcp-server
 ```
 
-**Note**: WASM fallback is fully functional but may have slightly slower performance for large codebases. Code index features work normally in either mode.
+**Note**: If native binding is unavailable, code index features (`code_index_build`, `code_index_status`, `script_symbol_find`, etc.) will return clear error messages indicating the feature is disabled. Other MCP server features continue to work normally.
 
 ### MCP Client Shows "Capabilities: none"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "2.41.8",
+  "version": "2.42.1",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",
@@ -20,8 +20,8 @@
     "test:watch": "node --watch --test tests/unit/**/*.test.js",
     "test:watch:all": "node --watch --test tests/**/*.test.js",
     "test:performance": "node --test tests/performance/*.test.js",
-    "test:ci": "CI=true NODE_ENV=test node --test tests/unit/core/codeIndex.test.js tests/unit/core/codeIndexDb.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js tests/unit/scripts/ensure-better-sqlite3.test.js",
-    "test:ci:coverage": "c8 --reporter=lcov --reporter=text node --test tests/unit/core/codeIndex.test.js tests/unit/core/codeIndexDb.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js",
+    "test:ci": "CI=true NODE_ENV=test node --test tests/unit/core/codeIndex.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js tests/unit/scripts/ensure-better-sqlite3.test.js",
+    "test:ci:coverage": "c8 --reporter=lcov --reporter=text node --test tests/unit/core/codeIndex.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js tests/unit/handlers/script/CodeIndexStatusToolHandler.test.js",
     "test:ci:all": "c8 --reporter=lcov node --test tests/unit/**/*.test.js",
     "simulate:code-index": "node scripts/simulate-code-index-status.mjs",
     "test:verbose": "VERBOSE_TEST=true node --test tests/**/*.test.js",
@@ -30,7 +30,7 @@
     "prebuilt:manifest": "node scripts/generate-prebuilt-manifest.mjs",
     "prepublishOnly": "npm run test:ci && npm run prebuilt:manifest",
     "postinstall": "node scripts/ensure-better-sqlite3.mjs && chmod +x bin/unity-mcp-server || true",
-    "test:ci:unity": "timeout 60 node --test tests/unit/core/codeIndex.test.js tests/unit/core/codeIndexDb.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js || exit 0",
+    "test:ci:unity": "timeout 60 node --test tests/unit/core/codeIndex.test.js tests/unit/core/config.test.js tests/unit/core/indexWatcher.test.js tests/unit/core/projectInfo.test.js tests/unit/core/server.test.js || exit 0",
     "test:unity": "node tests/run-unity-integration.mjs",
     "test:nounity": "npm run test:integration",
     "test:ci:integration": "CI=true NODE_ENV=test node --test tests/integration/code-index-background.test.js"
@@ -50,10 +50,9 @@
   "author": "Akio Jinsenji <akio-jinsenji@cloud-creative-studios.com>",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^0.6.1",
+    "@modelcontextprotocol/sdk": "^1.24.0",
     "better-sqlite3": "^9.4.3",
-    "find-up": "^6.3.0",
-    "sql.js": "^1.13.0"
+    "find-up": "^6.3.0"
   },
   "engines": {
     "node": ">=18 <23"

package/scripts/ensure-better-sqlite3.mjs

@@ -66,7 +66,7 @@ export function ensureBetterSqlite3(options = {}) {
     bindingPath = DEFAULT_BINDING_PATH,
     prebuiltRoot = DEFAULT_PREBUILT_ROOT,
     pkgRoot = PKG_ROOT,
-    skipNative = process.env.UNITY_MCP_SKIP_NATIVE_BUILD !== '0',
+    skipNative = process.env.UNITY_MCP_SKIP_NATIVE_BUILD === '1',
     forceNative = process.env.UNITY_MCP_FORCE_NATIVE === '1',
     skipLegacyFlag = Boolean(process.env.SKIP_SQLITE_REBUILD),
     log = console.log,

package/src/core/codeIndex.js

@@ -2,7 +2,6 @@ import fs from 'fs';
 import path from 'path';
 import { ProjectInfoProvider } from './projectInfo.js';
 import { logger } from './config.js';
-import { createSqliteFallback } from './sqliteFallback.js';
 
 // Shared driver availability state across CodeIndex instances
 const driverStatus = {
@@ -11,17 +10,23 @@ const driverStatus = {
   logged: false
 };
 
+// Shared DB connections (singleton pattern for concurrent access)
+const sharedConnections = {
+  writeDb: null,
+  readDb: null,
+  dbPath: null,
+  schemaInitialized: false
+};
+
 export class CodeIndex {
   constructor(unityConnection) {
     this.unityConnection = unityConnection;
     this.projectInfo = new ProjectInfoProvider(unityConnection);
-    this.db = null;
+    this.db = null; // legacy reference, points to writeDb
     this.dbPath = null;
     this.disabled = false; // set true if better-sqlite3 is unavailable
     this.disableReason = null;
     this._Database = null;
-    this._openFallback = null;
-    this._persistFallback = null;
   }
 
   async _ensureDriver() {
@@ -39,21 +44,13 @@ export class CodeIndex {
       driverStatus.error = null;
       return true;
     } catch (e) {
-      // Try wasm fallback (sql.js) before giving up
-      try {
-        this._openFallback = createSqliteFallback;
-        driverStatus.available = true;
-        driverStatus.error = null;
-        logger?.info?.('[index] falling back to sql.js (WASM) for code index');
-        return true;
-      } catch (fallbackError) {
-        this.disabled = true;
-        this.disableReason = `better-sqlite3 unavailable: ${e?.message || e}. Fallback failed: ${fallbackError?.message || fallbackError}`;
-        driverStatus.available = false;
-        driverStatus.error = this.disableReason;
-        this._logDisable(this.disableReason);
-        return false;
-      }
+      // No fallback - fail fast with clear error
+      this.disabled = true;
+      this.disableReason = `better-sqlite3 native binding unavailable: ${e?.message || e}. Code index features are disabled.`;
+      driverStatus.available = false;
+      driverStatus.error = this.disableReason;
+      this._logDisable(this.disableReason);
+      return false;
     }
   }
 
@@ -66,12 +63,23 @@ export class CodeIndex {
     fs.mkdirSync(dir, { recursive: true });
     const dbPath = path.join(dir, 'code-index.db');
     this.dbPath = dbPath;
+
+    // Use shared connections for all CodeIndex instances
+    if (sharedConnections.writeDb && sharedConnections.dbPath === dbPath) {
+      this.db = sharedConnections.writeDb;
+      return this.db;
+    }
+
     try {
       if (this._Database) {
-        this.db = new this._Database(dbPath);
-      } else if (this._openFallback) {
-        this.db = await this._openFallback(dbPath);
-        this._persistFallback = this.db.persist;
+        // Create write connection (default)
+        sharedConnections.writeDb = new this._Database(dbPath);
+        sharedConnections.dbPath = dbPath;
+        this.db = sharedConnections.writeDb;
+
+        // Create separate read-only connection for concurrent reads
+        // readonly: true allows reads even while write transaction is active
+        sharedConnections.readDb = new this._Database(dbPath, { readonly: true });
       } else {
         throw new Error('No database driver available');
       }
@@ -87,6 +95,14 @@ export class CodeIndex {
     return this.db;
   }
 
+  /**
+   * Get read-only DB connection for queries (non-blocking during writes)
+   * Falls back to write connection if read connection unavailable
+   */
+  _getReadDb() {
+    return sharedConnections.readDb || this.db;
+  }
+
   _logDisable(reason) {
     if (driverStatus.logged) return;
     driverStatus.logged = true;
@@ -100,6 +116,7 @@ export class CodeIndex {
     const db = this.db;
     db.exec(`
       PRAGMA journal_mode=WAL;
+      PRAGMA busy_timeout=5000;
       CREATE TABLE IF NOT EXISTS meta (
         key TEXT PRIMARY KEY,
         value TEXT
@@ -122,13 +139,14 @@ export class CodeIndex {
       CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);
       CREATE INDEX IF NOT EXISTS idx_symbols_path ON symbols(path);
     `);
-    if (this._persistFallback) this._persistFallback();
   }
 
   async isReady() {
     const db = await this.open();
     if (!db) return false;
-    const row = db.prepare('SELECT COUNT(*) AS c FROM symbols').get();
+    // Use read-only connection for non-blocking check
+    const readDb = this._getReadDb();
+    const row = readDb.prepare('SELECT COUNT(*) AS c FROM symbols').get();
     return (row?.c || 0) > 0;
   }
 
@@ -158,7 +176,6 @@ export class CodeIndex {
       );
     });
     tx(symbols || []);
-    await this._flushFallback();
     return { total: symbols?.length || 0 };
   }
 
@@ -166,7 +183,9 @@ export class CodeIndex {
   async getFiles() {
     const db = await this.open();
     if (!db) return new Map();
-    const rows = db.prepare('SELECT path, sig FROM files').all();
+    // Use read-only connection for non-blocking read
+    const readDb = this._getReadDb();
+    const rows = readDb.prepare('SELECT path, sig FROM files').all();
     const map = new Map();
     for (const r of rows) map.set(String(r.path), String(r.sig || ''));
     return map;
@@ -180,7 +199,6 @@ export class CodeIndex {
       sig || '',
       new Date().toISOString()
     );
-    await this._flushFallback();
   }
 
   async removeFile(pathStr) {
@@ -191,7 +209,6 @@ export class CodeIndex {
       db.prepare('DELETE FROM files WHERE path = ?').run(p);
     });
     tx(pathStr);
-    await this._flushFallback();
   }
 
   async replaceSymbolsForPath(pathStr, rows) {
@@ -218,12 +235,13 @@ export class CodeIndex {
       );
     });
     tx(pathStr, rows || []);
-    await this._flushFallback();
   }
 
   async querySymbols({ name, kind, scope = 'all', exact = false }) {
     const db = await this.open();
     if (!db) return [];
+    // Use read-only connection for non-blocking query
+    const readDb = this._getReadDb();
     let sql = 'SELECT path,name,kind,container,namespace,line,column FROM symbols WHERE 1=1';
     const params = {};
     if (name) {
@@ -239,7 +257,7 @@ export class CodeIndex {
       sql += ' AND kind = @kind';
       params.kind = kind;
     }
-    const rows = db.prepare(sql).all(params);
+    const rows = readDb.prepare(sql).all(params);
     // Apply path-based scope filter in JS (simpler than CASE in SQL)
     const filtered = rows.filter(r => {
       const p = String(r.path || '').replace(/\\\\/g, '/');
@@ -263,19 +281,13 @@ export class CodeIndex {
   async getStats() {
     const db = await this.open();
     if (!db) return { total: 0, lastIndexedAt: null };
-    const total = db.prepare('SELECT COUNT(*) AS c FROM symbols').get().c || 0;
+    // Use read-only connection for non-blocking stats
+    const readDb = this._getReadDb();
+    const total = readDb.prepare('SELECT COUNT(*) AS c FROM symbols').get().c || 0;
     const last =
-      db.prepare("SELECT value AS v FROM meta WHERE key = 'lastIndexedAt'").get()?.v || null;
+      readDb.prepare("SELECT value AS v FROM meta WHERE key = 'lastIndexedAt'").get()?.v || null;
     return { total, lastIndexedAt: last };
   }
-
-  async _flushFallback() {
-    if (typeof this._persistFallback === 'function') {
-      try {
-        await this._persistFallback();
-      } catch {}
-    }
-  }
 }
 
 // Test-only helper to reset cached driver status between runs
@@ -283,4 +295,19 @@ export function __resetCodeIndexDriverStatusForTest() {
   driverStatus.available = null;
   driverStatus.error = null;
   driverStatus.logged = false;
+  // Also reset shared connections
+  if (sharedConnections.writeDb) {
+    try {
+      sharedConnections.writeDb.close();
+    } catch {}
+  }
+  if (sharedConnections.readDb) {
+    try {
+      sharedConnections.readDb.close();
+    } catch {}
+  }
+  sharedConnections.writeDb = null;
+  sharedConnections.readDb = null;
+  sharedConnections.dbPath = null;
+  sharedConnections.schemaInitialized = false;
 }

package/src/core/indexBuildWorkerPool.js

@@ -0,0 +1,186 @@
+import { Worker } from 'worker_threads';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from './config.js';
+import { JobManager } from './jobManager.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Worker Thread pool for non-blocking code index builds.
+ *
+ * This class manages Worker Threads that execute index builds in a separate
+ * thread, preventing the main Node.js event loop from being blocked by
+ * better-sqlite3's synchronous database operations.
+ *
+ * Requirements:
+ * - FR-056: Execute index build in Worker Thread
+ * - FR-057: Maintain <1s ping response during builds
+ * - FR-058: Propagate Worker Thread errors to main thread
+ * - FR-059: Async progress notification from Worker Thread
+ */
+export class IndexBuildWorkerPool {
+  constructor() {
+    this.worker = null;
+    this.jobManager = JobManager.getInstance();
+    this.progressCallbacks = [];
+    this.currentBuildId = null;
+  }
+
+  /**
+   * Subscribe to progress updates from Worker Thread
+   * @param {Function} callback - Called with progress object {processed, total, rate}
+   */
+  onProgress(callback) {
+    this.progressCallbacks.push(callback);
+  }
+
+  /**
+   * Execute index build in Worker Thread
+   * @param {Object} options - Build options
+   * @param {string} options.projectRoot - Unity project root path
+   * @param {string} options.dbPath - Database file path
+   * @param {number} [options.concurrency=1] - Worker concurrency (kept low to avoid blocking)
+   * @param {number} [options.throttleMs=0] - Delay between files for testing
+   * @returns {Promise<Object>} Build result
+   */
+  async executeBuild(options) {
+    if (this.worker) {
+      throw new Error('Build already in progress');
+    }
+
+    return new Promise((resolve, reject) => {
+      const workerPath = path.join(__dirname, 'workers', 'indexBuildWorker.js');
+
+      try {
+        this.worker = new Worker(workerPath, {
+          workerData: {
+            ...options,
+            concurrency: options.concurrency || 1
+          }
+        });
+
+        this.worker.on('message', message => {
+          if (message.type === 'progress') {
+            // Notify progress callbacks
+            this.progressCallbacks.forEach(cb => {
+              try {
+                cb(message.data);
+              } catch (e) {
+                logger.warn(`[worker-pool] Progress callback error: ${e.message}`);
+              }
+            });
+
+            // Update JobManager if job is tracked
+            if (this.currentBuildId) {
+              const job = this.jobManager.get(this.currentBuildId);
+              if (job) {
+                job.progress = message.data;
+              }
+            }
+          } else if (message.type === 'complete') {
+            this._cleanup();
+            resolve(message.data);
+          } else if (message.type === 'error') {
+            this._cleanup();
+            reject(new Error(message.error));
+          } else if (message.type === 'log') {
+            // Forward logs from worker
+            const level = message.level || 'info';
+            if (logger[level]) {
+              logger[level](message.message);
+            }
+          }
+        });
+
+        this.worker.on('error', error => {
+          logger.error(`[worker-pool] Worker error: ${error.message}`);
+          this._cleanup();
+          reject(error);
+        });
+
+        this.worker.on('exit', code => {
+          if (code !== 0 && this.worker) {
+            logger.warn(`[worker-pool] Worker exited with code ${code}`);
+            this._cleanup();
+            reject(new Error(`Worker exited with code ${code}`));
+          }
+        });
+      } catch (error) {
+        this._cleanup();
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Execute build with JobManager integration
+   * @param {string} jobId - Job ID for tracking
+   * @param {Object} options - Build options
+   * @returns {Promise<Object>} Build result
+   */
+  async executeBuildWithJob(jobId, options) {
+    this.currentBuildId = jobId;
+
+    try {
+      const result = await this.executeBuild(options);
+      this.currentBuildId = null;
+      return result;
+    } catch (error) {
+      this.currentBuildId = null;
+      throw error;
+    }
+  }
+
+  /**
+   * Terminate the worker thread
+   */
+  terminate() {
+    if (this.worker) {
+      this.worker.terminate();
+      this._cleanup();
+    }
+  }
+
+  /**
+   * Check if a build is currently running
+   * @returns {boolean}
+   */
+  isRunning() {
+    return this.worker !== null;
+  }
+
+  /**
+   * Clean up worker reference
+   * @private
+   */
+  _cleanup() {
+    this.worker = null;
+    this.currentBuildId = null;
+  }
+}
+
+// Singleton instance for shared use
+let instance = null;
+
+/**
+ * Get singleton instance of IndexBuildWorkerPool
+ * @returns {IndexBuildWorkerPool}
+ */
+export function getWorkerPool() {
+  if (!instance) {
+    instance = new IndexBuildWorkerPool();
+  }
+  return instance;
+}
+
+/**
+ * Reset singleton (for testing)
+ */
+export function __resetWorkerPoolForTest() {
+  if (instance) {
+    instance.terminate();
+    instance = null;
+  }
+}