pluresdb 1.0.1 → 1.3.0

package/legacy/better-sqlite3-shared.ts

@@ -0,0 +1,157 @@
+import { QueryResult } from "./types/node-types";
+
+export function isPlainObject(
+  value: unknown,
+): value is Record<string, unknown> {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+export function normalizeParameterInput(args: unknown[]): unknown[] {
+  if (args.length === 0) {
+    return [];
+  }
+  if (args.length === 1) {
+    const first = args[0];
+    if (Array.isArray(first)) {
+      return first;
+    }
+    if (isPlainObject(first)) {
+      return [first];
+    }
+    return [first];
+  }
+  return args;
+}
+
+function expandDotNotation(
+  row: Record<string, unknown>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(row)) {
+    const parts = key.split(".");
+    let cursor: Record<string, unknown> = result;
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
+      if (index === parts.length - 1) {
+        cursor[part] = value;
+      } else {
+        const next = cursor[part];
+        if (!isPlainObject(next)) {
+          cursor[part] = {};
+        }
+        cursor = cursor[part] as Record<string, unknown>;
+      }
+    }
+  }
+  return result;
+}
+
+export function shapeRow(
+  row: unknown,
+  columns: string[] | undefined,
+  mode: { raw: boolean; pluck: boolean; expand: boolean },
+): unknown {
+  if (mode.raw) {
+    return row;
+  }
+
+  let normalized: unknown;
+
+  if (Array.isArray(row)) {
+    if (columns && columns.length > 0) {
+      const mapped: Record<string, unknown> = {};
+      columns.forEach((column, index) => {
+        mapped[column] = row[index];
+      });
+      normalized = mapped;
+    } else {
+      normalized = [...row];
+    }
+  } else if (isPlainObject(row)) {
+    normalized = { ...(row as Record<string, unknown>) };
+  } else {
+    normalized = row;
+  }
+
+  if (mode.pluck) {
+    if (Array.isArray(row)) {
+      return row[0];
+    }
+    if (isPlainObject(row)) {
+      const keys = Object.keys(row as Record<string, unknown>);
+      return keys.length > 0
+        ? (row as Record<string, unknown>)[keys[0]]
+        : undefined;
+    }
+    if (columns && columns.length > 0 && isPlainObject(normalized)) {
+      return (normalized as Record<string, unknown>)[columns[0]];
+    }
+    return normalized;
+  }
+
+  if (mode.expand && isPlainObject(normalized)) {
+    return expandDotNotation(normalized as Record<string, unknown>);
+  }
+
+  return normalized;
+}
+
+export function normalizeQueryResult(raw: unknown): QueryResult {
+  if (
+    raw && typeof raw === "object" && "rows" in (raw as Record<string, unknown>)
+  ) {
+    const result = raw as Partial<QueryResult> & Record<string, unknown>;
+    const columnsValue = Array.isArray(result.columns) ? result.columns : [];
+    const rowsValue = Array.isArray(result.rows) ? result.rows : [];
+    const changesValue = typeof result.changes === "number"
+      ? result.changes
+      : 0;
+    const lastInsertRowIdValue = typeof result.lastInsertRowId === "number"
+      ? result.lastInsertRowId
+      : typeof (result as Record<string, unknown>).lastInsertRowid === "number"
+      ? Number((result as Record<string, unknown>).lastInsertRowid)
+      : 0;
+
+    return {
+      rows: rowsValue,
+      columns: columnsValue,
+      changes: changesValue,
+      lastInsertRowId: lastInsertRowIdValue,
+    };
+  }
+
+  if (Array.isArray(raw)) {
+    return {
+      rows: raw,
+      columns: [],
+      changes: 0,
+      lastInsertRowId: 0,
+    };
+  }
+
+  if (raw === undefined || raw === null) {
+    return { rows: [], columns: [], changes: 0, lastInsertRowId: 0 };
+  }
+
+  return {
+    rows: [raw],
+    columns: [],
+    changes: 0,
+    lastInsertRowId: 0,
+  };
+}
+
+export function splitSqlStatements(sql: string): string[] {
+  return sql
+    .split(/;\s*(?=(?:[^"']|"[^"]*"|'[^']*')*$)/)
+    .map((statement) => statement.trim())
+    .filter((statement) => statement.length > 0);
+}
+
+export function sanitizeDataDirName(name: string): string {
+  return name.replace(/[\s\\/:]+/g, "_").replace(/_+/g, "_");
+}

package/legacy/better-sqlite3.ts

@@ -0,0 +1,4 @@
+import { BetterSQLite3Database, BetterSQLite3Statement } from "./node-index";
+
+export default BetterSQLite3Database;
+export { BetterSQLite3Database, BetterSQLite3Statement };

package/{src → legacy}/cli.ts

@@ -8,6 +8,7 @@
 import { PluresNode } from "./node-wrapper";
 import * as path from "path";
 import * as fs from "fs";
+import process from "node:process";
 
 // Parse command line arguments
 const args = process.argv.slice(2);
@@ -43,7 +44,9 @@ Examples:
 }
 
 if (command === "--version") {
-  const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
+  const packageJson = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"),
+  );
   console.log(packageJson.version);
   process.exit(0);
 }
@@ -103,7 +106,8 @@ async function main() {
       const config = {
         port: options.port ? parseInt(options.port) : 34567,
         host: options.host || "localhost",
-        dataDir: options["data-dir"] || path.join(require("os").homedir(), ".pluresdb"),
+        dataDir: options["data-dir"] ||
+          path.join(require("os").homedir(), ".pluresdb"),
         webPort: options["web-port"] ? parseInt(options["web-port"]) : 34568,
         logLevel: options["log-level"] || "info",
       };
@@ -219,13 +223,19 @@ async function main() {
       }
     }
   } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : String(error));
+    console.error(
+      "Error:",
+      error instanceof Error ? error.message : String(error),
+    );
     process.exit(1);
   }
 }
 
 // Run the main function
 main().catch((error) => {
-  console.error("Fatal error:", error instanceof Error ? error.message : String(error));
+  console.error(
+    "Fatal error:",
+    error instanceof Error ? error.message : String(error),
+  );
   process.exit(1);
 });

package/{src → legacy}/config.ts

@@ -27,7 +27,8 @@ export function getConfigPath(): string {
   try {
     const os = Deno.build.os;
     if (os === "windows") {
-      const appData = Deno.env.get("APPDATA") || Deno.env.get("LOCALAPPDATA") || ".";
+      const appData = Deno.env.get("APPDATA") || Deno.env.get("LOCALAPPDATA") ||
+        ".";
       return `${appData}\\${appName}\\config.json`;
     }
     const home = Deno.env.get("HOME") || ".";

package/{src → legacy}/core/crdt.ts

@@ -51,7 +51,10 @@ function deepMergeWithDeletes(
   return { data: out, state: outState };
 }
 
-export function mergeNodes(local: NodeRecord | null, incoming: NodeRecord): NodeRecord {
+export function mergeNodes(
+  local: NodeRecord | null,
+  incoming: NodeRecord,
+): NodeRecord {
   if (!local) return incoming;
   if (local.id !== incoming.id) {
     throw new Error("mergeNodes called with mismatched ids");

package/{src → legacy}/core/database.ts

@@ -1,9 +1,13 @@
 import { KvStorage } from "../storage/kv-storage.ts";
 import type { MeshMessage, NodeRecord } from "../types/index.ts";
 import { mergeNodes } from "./crdt.ts";
-import { connectToPeer, type MeshServer, startMeshServer } from "../network/websocket-server.ts";
+import {
+  connectToPeer,
+  type MeshServer,
+  startMeshServer,
+} from "../network/websocket-server.ts";
 import { debugLog } from "../util/debug.ts";
-import { RuleEngine, type Rule, type RuleContext } from "../logic/rules.ts";
+import { type Rule, type RuleContext, RuleEngine } from "../logic/rules.ts";
 import { BruteForceVectorIndex } from "../vector/index.ts";
 
 const FUNCTION_PLACEHOLDER = "[sanitized function]";
@@ -32,13 +36,21 @@ function sanitizeValue(value: unknown, seen: WeakSet<object>): unknown {
   return clean;
 }
 
-function sanitizeRecord(data: Record<string, unknown>): Record<string, unknown> {
-  const result = sanitizeValue(data, new WeakSet()) as Record<string, unknown> | string;
-  if (typeof result === "string" || result === undefined) return Object.create(null);
+function sanitizeRecord(
+  data: Record<string, unknown>,
+): Record<string, unknown> {
+  const result = sanitizeValue(data, new WeakSet()) as
+    | Record<string, unknown>
+    | string;
+  if (typeof result === "string" || result === undefined) {
+    return Object.create(null);
+  }
   return result;
 }
 
-function sanitizeForOutput(data: Record<string, unknown>): Record<string, unknown> {
+function sanitizeForOutput(
+  data: Record<string, unknown>,
+): Record<string, unknown> {
   const clean = sanitizeRecord(data);
   if (typeof clean["toString"] !== "string") {
     clean["toString"] = Object.prototype.toString.call(clean);
@@ -56,9 +68,13 @@ export interface DatabaseOptions {
 
 export class GunDB {
   private readonly storage: KvStorage;
-  private readonly listeners: Map<string, Set<(node: NodeRecord | null) => void>> = new Map();
-  private readonly anyListeners: Set<(event: { id: string; node: NodeRecord | null }) => void> =
-    new Set();
+  private readonly listeners: Map<
+    string,
+    Set<(node: NodeRecord | null) => void>
+  > = new Map();
+  private readonly anyListeners: Set<
+    (event: { id: string; node: NodeRecord | null }) => void
+  > = new Set();
   private readonly peerId: string;
   private meshServer: MeshServer | null = null;
   private readonly peerSockets: Set<WebSocket> = new Set();
@@ -129,8 +145,9 @@ export class GunDB {
       id,
       data: record,
       vector,
-      type:
-        typeof record.type === "string" ? (record.type as string) : (existing?.type ?? undefined),
+      type: typeof record.type === "string"
+        ? (record.type as string)
+        : (existing?.type ?? undefined),
       timestamp: now,
       state: newState,
       vectorClock: newClock,
@@ -140,19 +157,24 @@ export class GunDB {
     await this.storage.setNode(merged);
     debugLog("put() merged", { id, timestamp: merged.timestamp });
     this.emit(id, merged);
-    if (merged.vector && merged.vector.length > 0) this.vectorIndex.upsert(id, merged.vector);
-    else this.vectorIndex.remove(id);
+    if (merged.vector && merged.vector.length > 0) {
+      this.vectorIndex.upsert(id, merged.vector);
+    } else this.vectorIndex.remove(id);
     if (!suppressRules) {
       await this.evaluateRules(merged);
     }
     this.broadcast({ type: "put", originId: this.peerId, node: merged });
   }
 
-  async get<T = Record<string, unknown>>(id: string): Promise<(T & { id: string }) | null> {
+  async get<T = Record<string, unknown>>(
+    id: string,
+  ): Promise<(T & { id: string }) | null> {
     this.ensureReady();
     const node = await this.storage.getNode(id);
     if (!node) return null;
-    const sanitized = sanitizeForOutput((node.data ?? {}) as Record<string, unknown>);
+    const sanitized = sanitizeForOutput(
+      (node.data ?? {}) as Record<string, unknown>,
+    );
     return { id: node.id, ...(sanitized as T) };
   }
 
@@ -217,7 +239,10 @@ export class GunDB {
       if (Number.isFinite(score)) scored.push({ score, node });
     }
     scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit).map((s) => ({ ...s.node, similarity: s.score }));
+    return scored.slice(0, limit).map((s) => ({
+      ...s.node,
+      similarity: s.score,
+    }));
   }
 
   // Type system convenience
@@ -239,7 +264,11 @@ export class GunDB {
     this.ensureReady();
     const history = await this.getNodeHistory(id);
     const version = history.find((v) => v.timestamp === timestamp);
-    if (!version) throw new Error(`Version not found for node ${id} at timestamp ${timestamp}`);
+    if (!version) {
+      throw new Error(
+        `Version not found for node ${id} at timestamp ${timestamp}`,
+      );
+    }
 
     // Restore by putting the historical version
     await this.put(id, version.data);
@@ -254,12 +283,16 @@ export class GunDB {
   }
 
   // Any-change subscription (internal use for API streaming)
-  onAny(callback: (event: { id: string; node: NodeRecord | null }) => void): () => void {
+  onAny(
+    callback: (event: { id: string; node: NodeRecord | null }) => void,
+  ): () => void {
     this.ensureReady();
     this.anyListeners.add(callback);
     return () => this.offAny(callback);
   }
-  offAny(callback: (event: { id: string; node: NodeRecord | null }) => void): void {
+  offAny(
+    callback: (event: { id: string; node: NodeRecord | null }) => void,
+  ): void {
     this.anyListeners.delete(callback);
   }
 
@@ -302,7 +335,9 @@ export class GunDB {
       onOpen: (s) => {
         // Request a snapshot
         try {
-          s.send(JSON.stringify({ type: "sync_request", originId: this.peerId }));
+          s.send(
+            JSON.stringify({ type: "sync_request", originId: this.peerId }),
+          );
         } catch {
           /* ignore */
         }
@@ -386,9 +421,9 @@ export class GunDB {
         const merged = mergeNodes(existing, node);
         await this.storage.setNode(merged);
         this.emit(node.id, merged);
-        if (merged.vector && merged.vector.length > 0)
+        if (merged.vector && merged.vector.length > 0) {
           this.vectorIndex.upsert(node.id, merged.vector);
-        else this.vectorIndex.remove(node.id);
+        } else this.vectorIndex.remove(node.id);
         await this.evaluateRules(merged);
         try {
           ctx.broadcast(msg, ctx.source);

package/{src → legacy}/healthcheck.ts

@@ -32,7 +32,9 @@ async function checkApiHealth(): Promise<boolean> {
     });
 
     if (!response.ok) {
-      console.error(`API health check failed: ${response.status} ${response.statusText}`);
+      console.error(
+        `API health check failed: ${response.status} ${response.statusText}`,
+      );
       return false;
     }
 
@@ -49,19 +51,23 @@ async function checkWebHealth(): Promise<boolean> {
     const response = await fetch(`http://${HOST}:${WEB_PORT}/`, {
       method: "GET",
       headers: {
-        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        Accept:
+          "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
         "User-Agent": "pluresdb-healthcheck/1.0.0",
       },
       signal: AbortSignal.timeout(5000), // 5 second timeout
     });
 
     if (!response.ok) {
-      console.error(`Web health check failed: ${response.status} ${response.statusText}`);
+      console.error(
+        `Web health check failed: ${response.status} ${response.statusText}`,
+      );
       return false;
     }
 
     const contentType = response.headers.get("content-type");
-    return contentType?.includes("text/html") || contentType?.includes("application/json");
+    return contentType?.includes("text/html") ||
+      contentType?.includes("application/json");
   } catch (error) {
     console.error(`Web health check error: ${error.message}`);
     return false;
@@ -109,7 +115,7 @@ async function main(): Promise<void> {
   const uptime = Date.now() - startTime;
   const allHealthy = apiHealthy && webHealthy && dbHealthy;
 
-  const healthStatus: HealthStatus = {
+  const _healthStatus: HealthStatus = {
     status: allHealthy ? "healthy" : "unhealthy",
     checks: {
       api: apiHealthy,

package/{src → legacy}/http/api-server.ts

@@ -17,7 +17,9 @@ function corsHeaders(extra?: Record<string, string>): Headers {
   return headers;
 }
 
-export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHandle {
+export function startApiServer(
+  opts: { port: number; db: GunDB },
+): ApiServerHandle {
   const { port, db } = opts;
 
   const handler = async (req: Request): Promise<Response> => {
@@ -40,7 +42,9 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
             const cb = (e: { id: string; node: unknown | null }) => send(e);
             db.onAny(cb as any);
             (async () => {
-              for await (const n of db.list()) send({ id: n.id, node: { id: n.id, data: n.data } });
+              for await (const n of db.list()) {
+                send({ id: n.id, node: { id: n.id, data: n.data } });
+              }
             })();
             return () => db.offAny(cb as any);
           },
@@ -80,7 +84,9 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
               return json(cfg);
             }
             if (req.method === "POST") {
-              const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+              const body = (await req.json().catch(() => null)) as
+                | Record<string, unknown>
+                | null;
               if (!body) return json({ error: "missing body" }, 400);
               const current = await loadConfig();
               const next = { ...current, ...body } as Record<string, unknown>;
@@ -100,7 +106,9 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
             const body = (await req.json().catch(() => null)) as
               | { id?: string; data?: Record<string, unknown> }
               | null;
-            if (!body?.id || !body?.data) return json({ error: "missing body {id,data}" }, 400);
+            if (!body?.id || !body?.data) {
+              return json({ error: "missing body {id,data}" }, 400);
+            }
             await db.put(body.id, body.data);
             return json({ ok: true });
           }
@@ -128,7 +136,8 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
             return json(nodes.map((n) => ({ id: n.id, data: n.data })));
           }
           case "/api/list": {
-            const out: Array<{ id: string; data: Record<string, unknown> }> = [];
+            const out: Array<{ id: string; data: Record<string, unknown> }> =
+              [];
             for await (const n of db.list()) {
               out.push({ id: n.id, data: n.data as Record<string, unknown> });
             }
@@ -157,10 +166,97 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
           case "/api/restore": {
             const id = url.searchParams.get("id");
             const timestamp = url.searchParams.get("timestamp");
-            if (!id || !timestamp) return json({ error: "missing id or timestamp" }, 400);
+            if (!id || !timestamp) {
+              return json({ error: "missing id or timestamp" }, 400);
+            }
             await db.restoreNodeVersion(id, parseInt(timestamp));
             return json({ success: true });
           }
+          case "/api/identity": {
+            if (req.method !== "POST") return json({ error: "method" }, 405);
+            const body = (await req.json().catch(() => null)) as
+              | { name?: string; email?: string }
+              | null;
+            if (!body?.name || !body?.email) {
+              return json({ error: "missing name or email" }, 400);
+            }
+            // Generate a simple identity (stub implementation)
+            const id = `peer_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+            const publicKey = `pk_${Math.random().toString(36).substring(2)}`;
+            return json({ id, publicKey, name: body.name, email: body.email });
+          }
+          case "/api/peers/search": {
+            const q = url.searchParams.get("q") ?? "";
+            // Stub implementation - return empty array for now
+            // In a real implementation, this would search for peers in the network
+            return json([]);
+          }
+          case "/api/share": {
+            if (req.method !== "POST") return json({ error: "method" }, 405);
+            const body = (await req.json().catch(() => null)) as
+              | {
+                  nodeId?: string;
+                  targetPeerId?: string;
+                  accessLevel?: string;
+                }
+              | null;
+            if (!body?.nodeId || !body?.targetPeerId) {
+              return json(
+                { error: "missing nodeId or targetPeerId" },
+                400,
+              );
+            }
+            // Stub implementation - generate a shared node ID
+            const sharedNodeId = `shared_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+            return json({
+              sharedNodeId,
+              nodeId: body.nodeId,
+              targetPeerId: body.targetPeerId,
+              accessLevel: body.accessLevel || "read-only",
+            });
+          }
+          case "/api/share/accept": {
+            if (req.method !== "POST") return json({ error: "method" }, 405);
+            const body = (await req.json().catch(() => null)) as
+              | { sharedNodeId?: string }
+              | null;
+            if (!body?.sharedNodeId) {
+              return json({ error: "missing sharedNodeId" }, 400);
+            }
+            // Stub implementation - accept shared node
+            return json({ success: true, sharedNodeId: body.sharedNodeId });
+          }
+          case "/api/devices": {
+            if (req.method === "POST") {
+              const body = (await req.json().catch(() => null)) as
+                | { name?: string; type?: string }
+                | null;
+              if (!body?.name || !body?.type) {
+                return json({ error: "missing name or type" }, 400);
+              }
+              // Stub implementation - generate device ID
+              const id = `device_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+              return json({
+                id,
+                name: body.name,
+                type: body.type,
+                status: "online",
+              });
+            }
+            // GET devices list
+            return json([]);
+          }
+          case "/api/devices/sync": {
+            if (req.method !== "POST") return json({ error: "method" }, 405);
+            const body = (await req.json().catch(() => null)) as
+              | { deviceId?: string }
+              | null;
+            if (!body?.deviceId) {
+              return json({ error: "missing deviceId" }, 400);
+            }
+            // Stub implementation - sync with device
+            return json({ success: true, deviceId: body.deviceId });
+          }
           default:
             return json({ error: "not found" }, 404);
         }
@@ -168,27 +264,34 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
 
       if (req.method === "GET") {
         const mapPath = path === "/" ? "/index.html" : path;
-        const fileUrl = new URL(mapPath.startsWith("/") ? `.${mapPath}` : mapPath, STATIC_ROOT);
+        const fileUrl = new URL(
+          mapPath.startsWith("/") ? `.${mapPath}` : mapPath,
+          STATIC_ROOT,
+        );
         try {
           const data = await Deno.readFile(fileUrl);
           const contentType = mapPath.endsWith(".html")
             ? "text/html; charset=utf-8"
             : mapPath.endsWith(".js")
-              ? "application/javascript"
-              : mapPath.endsWith(".css")
-                ? "text/css"
-                : mapPath.endsWith(".json")
-                  ? "application/json"
-                  : mapPath.endsWith(".svg")
-                    ? "image/svg+xml"
-                    : mapPath.endsWith(".png")
-                      ? "image/png"
-                      : "application/octet-stream";
-          return new Response(data, { headers: corsHeaders({ "content-type": contentType }) });
+            ? "application/javascript"
+            : mapPath.endsWith(".css")
+            ? "text/css"
+            : mapPath.endsWith(".json")
+            ? "application/json"
+            : mapPath.endsWith(".svg")
+            ? "image/svg+xml"
+            : mapPath.endsWith(".png")
+            ? "image/png"
+            : "application/octet-stream";
+          return new Response(data, {
+            headers: corsHeaders({ "content-type": contentType }),
+          });
         } catch {
           if (path === "/" || path === "/index.html") {
             return new Response(INDEX_HTML, {
-              headers: corsHeaders({ "content-type": "text/html; charset=utf-8" }),
+              headers: corsHeaders({
+                "content-type": "text/html; charset=utf-8",
+              }),
             });
           }
         }
@@ -196,8 +299,9 @@ export function startApiServer(opts: { port: number; db: GunDB }): ApiServerHand
 
       return new Response("Not Found", { status: 404, headers: corsHeaders() });
     } catch (e) {
-      const msg =
-        e && typeof e === "object" && "message" in e ? String((e as any).message) : String(e);
+      const msg = e && typeof e === "object" && "message" in e
+        ? String((e as any).message)
+        : String(e);
       return json({ error: msg }, 500);
     }
   };

package/{src → legacy}/index.ts

@@ -9,14 +9,14 @@ export { GunDB } from "./core/database.ts";
 export type { DatabaseOptions, ServeOptions } from "./core/database.ts";
 
 export { mergeNodes } from "./core/crdt.ts";
-export type { NodeRecord, MeshMessage, VectorClock } from "./types/index.ts";
+export type { MeshMessage, NodeRecord, VectorClock } from "./types/index.ts";
 
 export { startApiServer } from "./http/api-server.ts";
 export type { ApiServerHandle } from "./http/api-server.ts";
 
 export { loadConfig, saveConfig } from "./config.ts";
 
-export { startMeshServer, connectToPeer } from "./network/websocket-server.ts";
+export { connectToPeer, startMeshServer } from "./network/websocket-server.ts";
 export type { MeshServer } from "./network/websocket-server.ts";
 
 export { RuleEngine } from "./logic/rules.ts";