pluresdb 1.0.1 → 1.3.1

package/{src → legacy}/node-wrapper.ts

@@ -3,7 +3,7 @@
  * This module provides a Node.js-compatible API for VSCode extensions
  */
 
-import { spawn, ChildProcess } from "node:child_process";
+import { ChildProcess, spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import * as path from "node:path";
 import * as fs from "node:fs";
@@ -66,17 +66,21 @@ export class PluresNode extends EventEmitter {
         if (fs.existsSync(denoPath) || this.isCommandAvailable(denoPath)) {
           return denoPath;
         }
-      } catch (error) {
+      } catch {
         // Continue to next path
       }
     }
 
-    throw new Error("Deno not found. Please install Deno from https://deno.land/");
+    throw new Error(
+      "Deno not found. Please install Deno from https://deno.land/",
+    );
   }
 
   private isCommandAvailable(command: string): boolean {
     try {
-      require("child_process").execSync(`"${command}" --version`, { stdio: "ignore" });
+      require("child_process").execSync(`"${command}" --version`, {
+        stdio: "ignore",
+      });
       return true;
     } catch {
       return false;
@@ -169,7 +173,7 @@ export class PluresNode extends EventEmitter {
         if (response.ok) {
           return;
         }
-      } catch (error) {
+      } catch {
         // Server not ready yet
       }
 
@@ -243,7 +247,9 @@ export class PluresNode extends EventEmitter {
   }
 
   async get(key: string): Promise<any> {
-    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`);
+    const response = await fetch(
+      `${this.apiUrl}/api/data/${encodeURIComponent(key)}`,
+    );
 
     if (!response.ok) {
       if (response.status === 404) {
@@ -256,9 +262,12 @@ export class PluresNode extends EventEmitter {
   }
 
   async delete(key: string): Promise<void> {
-    const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`, {
-      method: "DELETE",
-    });
+    const response = await fetch(
+      `${this.apiUrl}/api/data/${encodeURIComponent(key)}`,
+      {
+        method: "DELETE",
+      },
+    );
 
     if (!response.ok) {
       throw new Error(`Delete failed: ${response.statusText}`);

package/{src → legacy}/sqlite-compat.ts

@@ -96,7 +96,10 @@ export class Database {
     }
   }
 
-  async run(sql: string, params: any[] = []): Promise<{ lastID: number; changes: number }> {
+  async run(
+    sql: string,
+    params: any[] = [],
+  ): Promise<{ lastID: number; changes: number }> {
     if (!this.isOpen) {
       throw new Error("Database is not open");
     }
@@ -137,7 +140,11 @@ export class Database {
     }
   }
 
-  async each(sql: string, params: any[] = [], callback: (row: any) => void): Promise<number> {
+  async each(
+    sql: string,
+    params: any[] = [],
+    callback: (row: any) => void,
+  ): Promise<number> {
     if (!this.isOpen) {
       throw new Error("Database is not open");
     }
@@ -190,7 +197,9 @@ export class Database {
     return statements.map((statement) => ({ sql: statement }));
   }
 
-  private async executeStatement(statement: { sql: string; params?: any[] }): Promise<any> {
+  private async executeStatement(
+    statement: { sql: string; params?: any[] },
+  ): Promise<any> {
     const sql = statement.sql.toLowerCase().trim();
 
     if (sql.startsWith("create table")) {
@@ -203,7 +212,10 @@ export class Database {
       return await this.update(statement.sql, statement.params || []);
     } else if (sql.startsWith("delete")) {
       return await this.delete(statement.sql, statement.params || []);
-    } else if (sql.startsWith("begin") || sql.startsWith("commit") || sql.startsWith("rollback")) {
+    } else if (
+      sql.startsWith("begin") || sql.startsWith("commit") ||
+      sql.startsWith("rollback")
+    ) {
       // Transaction commands - handled by transaction method
       return { changes: 0 };
     } else {
@@ -223,7 +235,9 @@ export class Database {
 
   private async createTable(sql: string): Promise<void> {
     // Extract table name and columns from CREATE TABLE statement
-    const tableMatch = sql.match(/CREATE TABLE\s+(?:IF NOT EXISTS\s+)?(\w+)\s*\(([^)]+)\)/i);
+    const tableMatch = sql.match(
+      /CREATE TABLE\s+(?:IF NOT EXISTS\s+)?(\w+)\s*\(([^)]+)\)/i,
+    );
     if (!tableMatch) {
       throw new Error(`Invalid CREATE TABLE statement: ${sql}`);
     }
@@ -265,7 +279,10 @@ export class Database {
     }
   }
 
-  private async insert(sql: string, params: any[]): Promise<{ lastID: number; changes: number }> {
+  private async insert(
+    sql: string,
+    params: any[],
+  ): Promise<{ lastID: number; changes: number }> {
     const insertMatch = sql.match(
       /INSERT\s+(?:INTO\s+)?(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i,
     );
@@ -295,7 +312,9 @@ export class Database {
     });
 
     // Generate unique ID
-    const id = `${tableName}:${Date.now()}:${Math.random().toString(36).substr(2, 9)}`;
+    const id = `${tableName}:${Date.now()}:${
+      Math.random().toString(36).substr(2, 9)
+    }`;
     row.id = id;
     row.created_at = new Date().toISOString();
 
@@ -309,8 +328,13 @@ export class Database {
     return { lastID: 0, changes: 1 };
   }
 
-  private async update(sql: string, params: any[]): Promise<{ changes: number }> {
-    const updateMatch = sql.match(/UPDATE\s+(\w+)\s+SET\s+([^WHERE]+)(?:\s+WHERE\s+(.+))?/i);
+  private async update(
+    sql: string,
+    params: any[],
+  ): Promise<{ changes: number }> {
+    const updateMatch = sql.match(
+      /UPDATE\s+(\w+)\s+SET\s+([^WHERE]+)(?:\s+WHERE\s+(.+))?/i,
+    );
     if (!updateMatch) {
       throw new Error(`Invalid UPDATE statement: ${sql}`);
     }
@@ -342,13 +366,21 @@ export class Database {
       if (whereClause) {
         // Simple WHERE clause evaluation (basic implementation)
         if (this.evaluateWhereClause(row, whereClause, params)) {
-          const updatedRow = { ...row, ...updates, updated_at: new Date().toISOString() };
+          const updatedRow = {
+            ...row,
+            ...updates,
+            updated_at: new Date().toISOString(),
+          };
           await this.plures.put(getRowId(row), updatedRow);
           changes++;
         }
       } else {
         // Update all rows
-        const updatedRow = { ...row, ...updates, updated_at: new Date().toISOString() };
+        const updatedRow = {
+          ...row,
+          ...updates,
+          updated_at: new Date().toISOString(),
+        };
         await this.plures.put(getRowId(row), updatedRow);
         changes++;
       }
@@ -361,7 +393,10 @@ export class Database {
     return { changes };
   }
 
-  private async delete(sql: string, params: any[]): Promise<{ changes: number }> {
+  private async delete(
+    sql: string,
+    params: any[],
+  ): Promise<{ changes: number }> {
     const deleteMatch = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?/i);
     if (!deleteMatch) {
       throw new Error(`Invalid DELETE statement: ${sql}`);
@@ -415,7 +450,9 @@ export class Database {
 
     // Apply WHERE clause
     if (whereClause) {
-      results = results.filter((row) => this.evaluateWhereClause(row, whereClause, params));
+      results = results.filter((row) =>
+        this.evaluateWhereClause(row, whereClause, params)
+      );
     }
 
     // Apply ORDER BY
@@ -449,7 +486,11 @@ export class Database {
     return results;
   }
 
-  private evaluateWhereClause(row: RowRecord, whereClause: string, params: any[]): boolean {
+  private evaluateWhereClause(
+    row: RowRecord,
+    whereClause: string,
+    params: any[],
+  ): boolean {
     // Simple WHERE clause evaluation
     // This is a basic implementation - in production, you'd want a proper SQL parser
 
@@ -504,7 +545,10 @@ function compareValues(a: unknown, b: unknown, desc = false): number {
     if (typeof value === "string") {
       return value;
     }
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    if (
+      typeof value === "number" || typeof value === "boolean" ||
+      typeof value === "bigint"
+    ) {
       return value.toString();
     }
     try {
@@ -545,7 +589,10 @@ export class PreparedStatement {
     return await this.db.all(this.sql, params);
   }
 
-  async each(params: any[] = [], callback: (row: any) => void): Promise<number> {
+  async each(
+    params: any[] = [],
+    callback: (row: any) => void,
+  ): Promise<number> {
     return await this.db.each(this.sql, params, callback);
   }
 

package/{src → legacy}/sqlite3-compat.ts

@@ -27,7 +27,7 @@ export class Database extends PluresDBDatabase {
     }
   }
 
-  configure(option: string, value: any): void {
+  configure(_option: string, _value: any): void {
     // No-op for compatibility
   }
 
@@ -35,7 +35,7 @@ export class Database extends PluresDBDatabase {
     // No-op for compatibility
   }
 
-  loadExtension(path: string, callback?: (err: Error | null) => void): void {
+  loadExtension(_path: string, callback?: (err: Error | null) => void): void {
     if (callback) {
       callback(new Error("Extensions not supported in PluresDB"), null);
     }

package/{src → legacy}/storage/kv-storage.ts

@@ -56,7 +56,9 @@ export class KvStorage {
 
   async *listNodeHistory(id: string): AsyncIterable<NodeRecord> {
     const kv = this.ensureKv();
-    for await (const entry of kv.list<NodeRecord>({ prefix: ["history", id] })) {
+    for await (
+      const entry of kv.list<NodeRecord>({ prefix: ["history", id] })
+    ) {
       if (entry.value) yield entry.value;
     }
   }

package/{src → legacy}/tests/core.test.ts

@@ -24,7 +24,11 @@ Deno.test("put and get returns stored data", async () => {
 });
 
 Deno.test(
-  { name: "subscription receives updates", sanitizeOps: false, sanitizeResources: false },
+  {
+    name: "subscription receives updates",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
   async () => {
     const db = new GunDB();
     try {
@@ -36,13 +40,15 @@ Deno.test(
       const updated = new Promise((resolve) =>
         db.on(
           "user:bob",
-          (n) => n && (n.data as Record<string, unknown>).age === 42 && resolve(true),
-        ),
+          (n) =>
+            n && (n.data as Record<string, unknown>).age === 42 &&
+            resolve(true),
+        )
       );
       await db.put("user:bob", { name: "Bob", age: 41 });
       await db.put("user:bob", { name: "Bob", age: 42 });
       const timeout = new Promise((_, rej) =>
-        setTimeout(() => rej(new Error("timeout: subscription")), 2000),
+        setTimeout(() => rej(new Error("timeout: subscription")), 2000)
       );
       await Promise.race([updated, timeout]);
     } finally {
@@ -72,7 +78,11 @@ Deno.test("vector search returns relevant notes", async () => {
 });
 
 Deno.test(
-  { name: "delete emits subscription with null", sanitizeOps: false, sanitizeResources: false },
+  {
+    name: "delete emits subscription with null",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
   async () => {
     const db = new GunDB();
     try {
@@ -83,11 +93,11 @@ Deno.test(
       await db.ready(kvPath);
       await db.put("user:carol", { name: "Carol" });
       const deleted = new Promise((resolve) =>
-        db.on("user:carol", (n) => n === null && resolve(true)),
+        db.on("user:carol", (n) => n === null && resolve(true))
       );
       await db.delete("user:carol");
       const timeout = new Promise((_, rej) =>
-        setTimeout(() => rej(new Error("timeout: delete")), 2000),
+        setTimeout(() => rej(new Error("timeout: delete")), 2000)
       );
       await Promise.race([deleted, timeout]);
     } finally {
@@ -121,7 +131,7 @@ Deno.test(
       await dbA.put("mesh:one", { text: "hello from A" });
 
       const receivedSnapshot = new Promise((resolve) =>
-        dbB.on("mesh:one", (n) => n && resolve(true)),
+        dbB.on("mesh:one", (n) => n && resolve(true))
       );
       dbB.connect(serverUrl);
       await receivedSnapshot;
@@ -129,8 +139,10 @@ Deno.test(
       const receivedOnA = new Promise((resolve) =>
         dbA.on(
           "mesh:fromB",
-          (n) => n && (n.data as Record<string, unknown>).who === "B" && resolve(true),
-        ),
+          (n) =>
+            n && (n.data as Record<string, unknown>).who === "B" &&
+            resolve(true),
+        )
       );
       await dbB.put("mesh:fromB", { who: "B", text: "hi A" });
       await receivedOnA;
@@ -204,7 +216,12 @@ Deno.test("CRDT merge: equal timestamps deterministic merge", () => {
   const merged = mergeNodes(local, incoming);
   assertEquals(merged.id, "n1");
   assertEquals(merged.timestamp, t);
-  assertEquals(merged.data, { a: 1, shared: 2, b: 2, nested: { x: 1, y: 2, z: 3 } });
+  assertEquals(merged.data, {
+    a: 1,
+    shared: 2,
+    b: 2,
+    nested: { x: 1, y: 2, z: 3 },
+  });
   assertEquals(merged.type, "TypeA");
   assertEquals(merged.vector, [0.1, 0.2]);
   assertEquals(merged.vectorClock.peerA, 2);
@@ -237,7 +254,11 @@ Deno.test("CRDT merge: LWW on differing timestamps", () => {
 });
 
 Deno.test(
-  { name: "off stops receiving events", sanitizeOps: false, sanitizeResources: false },
+  {
+    name: "off stops receiving events",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
   async () => {
     const db = new GunDB();
     try {
@@ -265,7 +286,10 @@ Deno.test(
 Deno.test("type system helpers: setType + instancesOf", async () => {
   const db = new GunDB();
   try {
-    const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
     await db.ready(kvPath);
     await db.put("t:1", { name: "Alice" });
     await db.setType("t:1", "Person");

package/{src → legacy}/tests/fixtures/test-data.json

@@ -33,7 +33,12 @@
       "profile": {
         "bio": "Product manager with a focus on developer tools",
         "location": "Seattle, WA",
-        "interests": ["Product", "Strategy", "Developer Experience", "Leadership"]
+        "interests": [
+          "Product",
+          "Strategy",
+          "Developer Experience",
+          "Leadership"
+        ]
       }
     }
   ],

package/{src → legacy}/tests/integration/api-server.test.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
 import { GunDB } from "../../core/database.ts";
-import { startApiServer, type ApiServerHandle } from "../../http/api-server.ts";
+import { type ApiServerHandle, startApiServer } from "../../http/api-server.ts";
 
 function randomPort(): number {
   return 18000 + Math.floor(Math.random() * 10000);
@@ -88,8 +88,8 @@ Deno.test("API Server - Vector Search Endpoint", async () => {
       }),
     });
 
-  assertEquals(searchResponse.status, 200);
-  const results = await searchResponse.json();
+    assertEquals(searchResponse.status, 200);
+    const results = await searchResponse.json();
     assertExists(results);
     assertEquals(Array.isArray(results), true);
   } finally {
@@ -119,7 +119,10 @@ Deno.test("API Server - WebSocket Connection", async () => {
     const ws = new WebSocket(wsUrl);
 
     const connectionPromise = new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("Connection timeout")), 5000);
+      const timer = setTimeout(
+        () => reject(new Error("Connection timeout")),
+        5000,
+      );
       ws.onopen = () => {
         clearTimeout(timer);
         resolve(true);
@@ -221,10 +224,109 @@ Deno.test("API Server - CORS Headers", async () => {
       },
     });
 
-  assertEquals(optionsResponse.status, 200);
-  assertExists(optionsResponse.headers.get("Access-Control-Allow-Origin"));
-  assertExists(optionsResponse.headers.get("Access-Control-Allow-Methods"));
-  await optionsResponse.body?.cancel();
+    assertEquals(optionsResponse.status, 200);
+    assertExists(optionsResponse.headers.get("Access-Control-Allow-Origin"));
+    assertExists(optionsResponse.headers.get("Access-Control-Allow-Methods"));
+    await optionsResponse.body?.cancel();
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});
+
+Deno.test("API Server - P2P API Endpoints", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const baseUrl = `http://localhost:${apiPort}`;
+
+    // Test createIdentity endpoint
+    const identityResponse = await fetch(`${baseUrl}/api/identity`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "John Doe", email: "john@example.com" }),
+    });
+    assertEquals(identityResponse.status, 200);
+    const identity = await identityResponse.json();
+    assertExists(identity.id);
+    assertExists(identity.publicKey);
+    assertEquals(identity.name, "John Doe");
+    assertEquals(identity.email, "john@example.com");
+
+    // Test searchPeers endpoint
+    const peersResponse = await fetch(`${baseUrl}/api/peers/search?q=developer`);
+    assertEquals(peersResponse.status, 200);
+    const peers = await peersResponse.json();
+    assertEquals(Array.isArray(peers), true);
+
+    // Test shareNode endpoint
+    const shareResponse = await fetch(`${baseUrl}/api/share`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        nodeId: "node:123",
+        targetPeerId: "peer:456",
+        accessLevel: "read-only",
+      }),
+    });
+    assertEquals(shareResponse.status, 200);
+    const shareData = await shareResponse.json();
+    assertExists(shareData.sharedNodeId);
+    assertEquals(shareData.nodeId, "node:123");
+    assertEquals(shareData.targetPeerId, "peer:456");
+    assertEquals(shareData.accessLevel, "read-only");
+
+    // Test acceptSharedNode endpoint
+    const acceptResponse = await fetch(`${baseUrl}/api/share/accept`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sharedNodeId: "shared:789" }),
+    });
+    assertEquals(acceptResponse.status, 200);
+    const acceptData = await acceptResponse.json();
+    assertEquals(acceptData.success, true);
+    assertEquals(acceptData.sharedNodeId, "shared:789");
+
+    // Test addDevice endpoint
+    const deviceResponse = await fetch(`${baseUrl}/api/devices`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "My Laptop", type: "laptop" }),
+    });
+    assertEquals(deviceResponse.status, 200);
+    const device = await deviceResponse.json();
+    assertExists(device.id);
+    assertEquals(device.name, "My Laptop");
+    assertEquals(device.type, "laptop");
+    assertEquals(device.status, "online");
+
+    // Test syncWithDevice endpoint
+    const syncResponse = await fetch(`${baseUrl}/api/devices/sync`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ deviceId: "device:123" }),
+    });
+    assertEquals(syncResponse.status, 200);
+    const syncData = await syncResponse.json();
+    assertEquals(syncData.success, true);
+    assertEquals(syncData.deviceId, "device:123");
+
+    // Test GET devices list
+    const devicesListResponse = await fetch(`${baseUrl}/api/devices`);
+    assertEquals(devicesListResponse.status, 200);
+    const devicesList = await devicesListResponse.json();
+    assertEquals(Array.isArray(devicesList), true);
   } finally {
     api?.close();
     await db.close();

package/{src → legacy}/tests/integration/mesh-network.test.ts

@@ -84,7 +84,10 @@ meshTest("Mesh Network - Basic Connection and Sync", async () => {
     });
 
     dbB.connect(serverUrl);
-    await withTimeout(receivedData as Promise<unknown>, "Timed out waiting for initial mesh sync");
+    await withTimeout(
+      receivedData as Promise<unknown>,
+      "Timed out waiting for initial mesh sync",
+    );
 
     // Verify data was received
     const syncedData = await dbB.get("mesh:test");
@@ -280,7 +283,10 @@ meshTest("Mesh Network - Connection Error Handling", async () => {
   const db = new GunDB();
 
   try {
-    const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
     await db.ready(kvPath);
 
     // Try to connect to non-existent server

package/{src → legacy}/tests/logic.test.ts

@@ -4,14 +4,18 @@ import type { Rule } from "../logic/rules.ts";
 Deno.test("rule engine classification: Person.age >= 18 -> adult = true", async () => {
   const db = new GunDB();
   try {
-    const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
     await db.ready(kvPath);
 
     const rule: Rule = {
       name: "adultClassifier",
       whenType: "Person",
       predicate: (node) =>
-        typeof (node.data as any).age === "number" && (node.data as any).age >= 18,
+        typeof (node.data as any).age === "number" &&
+        (node.data as any).age >= 18,
       action: async (ctx, node) => {
         const data = { ...(node.data as Record<string, unknown>), adult: true };
         await ctx.db.put(node.id, data);

package/{src → legacy}/tests/performance/load.test.ts

@@ -118,8 +118,10 @@ Deno.test("Performance - Vector Search Operations", async () => {
     const count = 500;
     for (let i = 0; i < count; i++) {
       await db.put(`doc:${i}`, {
-        text: `Document ${i} about machine learning and artificial intelligence`,
-        content: `This is document number ${i} containing information about AI and ML algorithms`,
+        text:
+          `Document ${i} about machine learning and artificial intelligence`,
+        content:
+          `This is document number ${i} containing information about AI and ML algorithms`,
       });
     }
 

package/{src → legacy}/tests/security/input-validation.test.ts

@@ -1,5 +1,9 @@
 // @ts-nocheck
-import { assertEquals, assertExists, assertRejects } from "jsr:@std/assert@1.0.14";
+import {
+  assertEquals,
+  assertExists,
+  assertRejects,
+} from "jsr:@std/assert@1.0.14";
 import { GunDB } from "../../core/database.ts";
 
 Deno.test("Security - SQL Injection Prevention", async () => {

package/{src → legacy}/tests/unit/core.test.ts

@@ -1,5 +1,9 @@
 // @ts-nocheck
-import { assertEquals, assertExists, assertRejects } from "jsr:@std/assert@1.0.14";
+import {
+  assertEquals,
+  assertExists,
+  assertRejects,
+} from "jsr:@std/assert@1.0.14";
 import { GunDB } from "../../core/database.ts";
 import { mergeNodes } from "../../core/crdt.ts";
 import type { NodeRecord } from "../../types/index.ts";
@@ -104,7 +108,9 @@ Deno.test("Core Database - Vector Search", async () => {
     await db.ready(kvPath);
 
     // Add documents with text content
-    await db.put("doc:1", { text: "Machine learning and artificial intelligence" });
+    await db.put("doc:1", {
+      text: "Machine learning and artificial intelligence",
+    });
     await db.put("doc:2", { text: "Cooking recipes and food preparation" });
     await db.put("doc:3", { text: "Deep learning neural networks" });
 
@@ -184,7 +190,11 @@ Deno.test("Core Database - Error Handling", async () => {
   const db = new GunDB();
 
   // Test operations before ready
-  await assertRejects(() => db.put("test", { value: 1 }), Error, "Database not ready");
+  await assertRejects(
+    () => db.put("test", { value: 1 }),
+    Error,
+    "Database not ready",
+  );
 
   await assertRejects(() => db.get("test"), Error, "Database not ready");
 

package/{src → legacy}/tests/unit/subscriptions.test.ts

@@ -100,7 +100,7 @@ Deno.test("Subscriptions - Multiple Subscribers", async () => {
   }
 });
 
-Deno.test("Subscriptions - Error Handling", async () => {
+Deno.test("Subscriptions - Error Handling", () => {
   const db = new GunDB();
 
   // Test subscription before ready