@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/server/index.d.ts

@@ -1,17 +1,20 @@
-import { E as ExecuteResult, S as ServerOptions, W as WSHandlerOptions } from '../types-DtDutWRU.js';
-import { S as Sirannon } from '../sirannon-B1oTfebD.js';
+import { W as WriteConcern, R as ReadConcern, E as ExecuteResult, d as ServerOptions, e as WSHandlerOptions } from '../types-D-74JiXb.js';
+import { S as Sirannon } from '../sirannon-Cd-lK6T0.js';
 import '../types-BFSsG77t.js';
-import '../types-DRkJlqex.js';
+import '../database-BVY1GqE7.js';
+import '../types-BeozgNPr.js';
 
 /** Body for POST /db/:id/query */
 interface QueryRequest {
     sql: string;
     params?: Record<string, unknown> | unknown[];
+    readConcern?: ReadConcern;
 }
 /** Body for POST /db/:id/execute */
 interface ExecuteRequest {
     sql: string;
     params?: Record<string, unknown> | unknown[];
+    writeConcern?: WriteConcern;
 }
 /** A single statement within a transaction batch. */
 interface TransactionStatement {
@@ -21,6 +24,7 @@ interface TransactionStatement {
 /** Body for POST /db/:id/transaction */
 interface TransactionRequest {
     statements: TransactionStatement[];
+    writeConcern?: WriteConcern;
 }
 /** Response for a successful query. */
 interface QueryResponse {
@@ -40,6 +44,7 @@ interface ErrorResponse {
     error: {
         code: string;
         message: string;
+        details?: Record<string, unknown>;
     };
 }
 /** Inbound WS message types. */
@@ -111,6 +116,9 @@ declare class SirannonServer {
     private readonly port;
     private readonly cors;
     private readonly onRequestHook;
+    private readonly resolveExecutionTarget;
+    private readonly getReplicationStatus;
+    private readonly getClusterStatus;
     private readonly sirannon;
     private readonly wsHandler;
     constructor(sirannon: Sirannon, options?: ServerOptions);
@@ -121,6 +129,7 @@ declare class SirannonServer {
     private registerWebSocketRoute;
     private withCors;
     private wrapDbRoute;
+    private wrapDbGetRoute;
 }
 declare function createServer(sirannon: Sirannon, options?: ServerOptions): SirannonServer;
 
@@ -131,6 +140,7 @@ interface WSConnection {
 declare class WSHandler {
     private readonly sirannon;
     private readonly maxPayloadLength;
+    private readonly resolveExecutionTarget;
     private readonly connections;
     private readonly cdcContexts;
     private readonly cdcPending;
@@ -149,6 +159,7 @@ declare class WSHandler {
     private createCDCContext;
     private maybeCleanupCDC;
     private isValidParams;
+    private resolveTarget;
     private send;
     private sendError;
     private sendSirannonError;

package/dist/server/index.mjs

@@ -1,4 +1,5 @@
-import { ChangeTracker, SubscriptionManager } from '../chunk-AX66KWBR.mjs';
+import { ChangeTracker, SubscriptionManager } from '../chunk-UTO3ZAFS.mjs';
+import '../chunk-GS7T5YMI.mjs';
 import { SirannonError } from '../chunk-O7BHI3CF.mjs';
 import uWS from 'uWebSockets.js';
 
@@ -19,7 +20,7 @@ function handleLiveness() {
     });
   };
 }
-function handleReadiness(sirannon) {
+function handleReadiness(sirannon, getReplicationStatus) {
   return (res) => {
     const dbs = sirannon.databases();
     const databases = [];
@@ -37,12 +38,43 @@ function handleReadiness(sirannon) {
       status: degraded ? "degraded" : "ok",
       databases
     };
+    if (getReplicationStatus) {
+      const replStatus = getReplicationStatus();
+      if (replStatus) {
+        body.replication = {
+          role: replStatus.role,
+          writeForwarding: replStatus.writeForwarding,
+          peers: replStatus.peers,
+          localSeq: replStatus.localSeq.toString(),
+          replicationGroupId: replStatus.replicationGroupId,
+          primaryTerm: replStatus.primaryTerm?.toString(),
+          currentPrimary: replStatus.currentPrimary,
+          coordinator: replStatus.coordinator,
+          controller: replStatus.controller,
+          inSyncReplicas: replStatus.inSyncReplicas,
+          laggingReplicas: replStatus.laggingReplicas,
+          syncState: replStatus.syncState,
+          readAvailability: replStatus.readAvailability,
+          writeAvailability: replStatus.writeAvailability
+        };
+        body.status = readinessStatusForReplication(replStatus, body.status);
+      }
+    }
     const payload = JSON.stringify(body);
     res.cork(() => {
       res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
     });
   };
 }
+function readinessStatusForReplication(replication, current) {
+  if (replication.syncState === "syncing" || replication.syncState === "catching-up") return "syncing";
+  if (replication.controller?.state === "active" && replication.writeAvailability === "unavailable")
+    return "failing_over";
+  if (replication.readAvailability === "unavailable" && replication.writeAvailability === "unavailable")
+    return "unavailable";
+  if ((replication.laggingReplicas?.length ?? 0) > 0) return "degraded";
+  return current;
+}
 
 // src/server/http-handler.ts
 function initAbortHandler(res) {
@@ -116,8 +148,8 @@ function sendJson(res, data) {
     res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
   });
 }
-function sendError(res, status, code, message) {
-  const body = { error: { code, message } };
+function sendError(res, status, code, message, details) {
+  const body = { error: details ? { code, message, details } : { code, message } };
   const payload = JSON.stringify(body);
   res.cork(() => {
     res.writeStatus(`${status}`).writeHeader("Content-Type", "application/json").end(payload);
@@ -132,19 +164,29 @@ function httpStatusForError(err) {
     case "QUERY_ERROR":
     case "TRANSACTION_ERROR":
       return 400;
+    case "STALE_PRIMARY":
+    case "PROTOCOL_VERSION_MISMATCH":
+      return 409;
     case "HOOK_DENIED":
       return 403;
     case "DATABASE_CLOSED":
     case "SHUTDOWN":
+    case "READ_CONCERN_ERROR":
+    case "COORDINATOR_UNAVAILABLE":
+    case "AUTHORITY_LOST":
+    case "NO_SAFE_PRIMARY":
+    case "NODE_NOT_IN_SYNC":
+    case "NODE_DRAINING":
+    case "UNSAFE_RECOVERY_REQUIRED":
       return 503;
     default:
       return 500;
   }
 }
-async function resolveDatabase(res, sirannon, id) {
-  let db;
+async function resolveExecutionTarget(res, sirannon, id, resolver) {
+  let target;
   try {
-    db = await sirannon.resolve(id);
+    target = resolver ? await resolver(id) : await sirannon.resolve(id);
   } catch (err) {
     if (err instanceof SirannonError) {
       sendError(res, httpStatusForError(err), err.code, err.message);
@@ -153,13 +195,13 @@ async function resolveDatabase(res, sirannon, id) {
     }
     return null;
   }
-  if (!db) {
+  if (!target) {
     sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${id}' not found`);
     return null;
   }
-  return db;
+  return target;
 }
-function handleQuery(sirannon) {
+function handleQuery(sirannon, resolveTarget) {
   return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
@@ -167,23 +209,29 @@ function handleQuery(sirannon) {
       sendError(res, 400, "INVALID_REQUEST", 'Field "sql" is required and must be a string');
       return;
     }
-    const db = await resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const readConcern = parseReadConcern(res, body.readConcern);
+    if (!readConcern.ok) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const rows = await db.query(body.sql, body.params);
+      const rows = await target.query(
+        body.sql,
+        body.params,
+        readConcern.value ? { readConcern: readConcern.value } : void 0
+      );
       if (abort.aborted) return;
       sendJson(res, { rows });
     } catch (err) {
       if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
-function handleExecute(sirannon) {
+function handleExecute(sirannon, resolveTarget) {
   return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
@@ -191,23 +239,29 @@ function handleExecute(sirannon) {
       sendError(res, 400, "INVALID_REQUEST", 'Field "sql" is required and must be a string');
       return;
     }
-    const db = await resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const writeConcern = parseWriteConcern(res, body.writeConcern);
+    if (!writeConcern.ok) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const result = await db.execute(body.sql, body.params);
+      const result = await target.execute(
+        body.sql,
+        body.params,
+        writeConcern.value ? { writeConcern: writeConcern.value } : void 0
+      );
       if (abort.aborted) return;
       sendJson(res, toExecuteResponse(result));
     } catch (err) {
       if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
-function handleTransaction(sirannon) {
+function handleTransaction(sirannon, resolveTarget) {
   return async (res, dbId, rawBody, abort) => {
     const body = parseBody(res, rawBody);
     if (!body) return;
@@ -219,6 +273,8 @@ function handleTransaction(sirannon) {
       sendError(res, 400, "INVALID_REQUEST", "Transaction requires at least one statement");
       return;
     }
+    const writeConcern = parseWriteConcern(res, body.writeConcern);
+    if (!writeConcern.ok) return;
     for (let i = 0; i < body.statements.length; i++) {
       const stmt = body.statements[i];
       if (!stmt.sql || typeof stmt.sql !== "string") {
@@ -226,17 +282,20 @@ function handleTransaction(sirannon) {
         return;
       }
     }
-    const db = await resolveDatabase(res, sirannon, dbId);
-    if (!db) return;
+    const target = await resolveExecutionTarget(res, sirannon, dbId, resolveTarget);
+    if (!target) return;
     try {
-      const results = await db.transaction(async (tx) => {
-        const txResults = [];
-        for (const stmt of body.statements) {
-          if (abort.aborted) throw new Error("Request aborted");
-          txResults.push(await tx.execute(stmt.sql, stmt.params));
-        }
-        return txResults;
-      });
+      const results = await target.transaction(
+        async (tx) => {
+          const txResults = [];
+          for (const stmt of body.statements) {
+            if (abort.aborted) throw new Error("Request aborted");
+            txResults.push(await tx.execute(stmt.sql, stmt.params));
+          }
+          return txResults;
+        },
+        writeConcern.value ? { writeConcern: writeConcern.value } : void 0
+      );
       if (abort.aborted) return;
       sendJson(res, {
         results: results.map(toExecuteResponse)
@@ -244,13 +303,93 @@ function handleTransaction(sirannon) {
     } catch (err) {
       if (abort.aborted) return;
       if (err instanceof SirannonError) {
-        sendError(res, httpStatusForError(err), err.code, err.message);
+        sendError(res, httpStatusForError(err), err.code, err.message, errorDetails(err));
       } else {
         sendError(res, 500, "INTERNAL_ERROR", "An unexpected error occurred");
       }
     }
   };
 }
+function parseReadConcern(res, value) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isPlainRecord(value)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern" must be an object when provided');
+    return { ok: false };
+  }
+  const keys = Object.keys(value);
+  if (keys.length !== 1 || !keys.includes("level")) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern" must contain only "level"');
+    return { ok: false };
+  }
+  if (!isReadConcernLevel(value.level)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "readConcern.level" is invalid');
+    return { ok: false };
+  }
+  return { ok: true, value: { level: value.level } };
+}
+function parseWriteConcern(res, value) {
+  if (value === void 0) return { ok: true, value: void 0 };
+  if (!isPlainRecord(value)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern" must be an object when provided');
+    return { ok: false };
+  }
+  const allowedKeys = /* @__PURE__ */ new Set(["level", "timeoutMs"]);
+  if (!Object.keys(value).every((key) => allowedKeys.has(key))) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern" contains unsupported keys');
+    return { ok: false };
+  }
+  if (!isWriteConcernLevel(value.level)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern.level" is invalid');
+    return { ok: false };
+  }
+  const timeoutMs = value.timeoutMs;
+  if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs <= 0)) {
+    sendError(res, 400, "INVALID_REQUEST", 'Field "writeConcern.timeoutMs" must be a positive safe integer');
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    value: timeoutMs === void 0 ? { level: value.level } : { level: value.level, timeoutMs }
+  };
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isReadConcernLevel(value) {
+  return value === "local" || value === "majority" || value === "linearizable";
+}
+function isWriteConcernLevel(value) {
+  return value === "local" || value === "majority" || value === "all";
+}
+function handleClusterStatus(getClusterStatus) {
+  return (res, dbId) => {
+    if (!getClusterStatus) {
+      sendError(res, 404, "NOT_FOUND", "Cluster status is not configured");
+      return;
+    }
+    const status = getClusterStatus(dbId);
+    if (!status) {
+      sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${dbId}' not found`);
+      return;
+    }
+    sendJson(res, toClusterStatusResponse(status));
+  };
+}
+function toClusterStatusResponse(status) {
+  return {
+    ...status,
+    currentPrimary: status.currentPrimary ? { ...status.currentPrimary } : status.currentPrimary,
+    readEndpoints: status.readEndpoints?.map((endpoint) => ({
+      ...endpoint,
+      readConcerns: [...endpoint.readConcerns]
+    })),
+    primaryTerm: status.primaryTerm?.toString()
+  };
+}
+function errorDetails(err) {
+  const details = err.details;
+  return details && Object.keys(details).length > 0 ? details : void 0;
+}
 
 // src/server/ws-handler.ts
 var DEFAULT_POLL_INTERVAL_MS = 50;
@@ -258,6 +397,7 @@ var DEFAULT_MAX_PAYLOAD_LENGTH = 1048576;
 var WSHandler = class {
   sirannon;
   maxPayloadLength;
+  resolveExecutionTarget;
   connections = /* @__PURE__ */ new Map();
   cdcContexts = /* @__PURE__ */ new Map();
   cdcPending = /* @__PURE__ */ new Map();
@@ -265,6 +405,7 @@ var WSHandler = class {
   constructor(sirannon, options) {
     this.sirannon = sirannon;
     this.maxPayloadLength = options?.maxPayloadLength ?? DEFAULT_MAX_PAYLOAD_LENGTH;
+    this.resolveExecutionTarget = options?.resolveExecutionTarget;
   }
   async handleOpen(conn, databaseId) {
     if (this.closed) {
@@ -283,9 +424,23 @@ var WSHandler = class {
       conn.close(1008, "Database closed");
       return;
     }
+    let executionTarget;
+    try {
+      executionTarget = await this.resolveTarget(databaseId);
+    } catch (err) {
+      this.sendSirannonError(conn, "", err);
+      conn.close(1011, "Execution target resolution failed");
+      return;
+    }
+    if (!executionTarget) {
+      this.sendError(conn, "", "DATABASE_NOT_FOUND", `Database '${databaseId}' not found`);
+      conn.close(1008, "Database not found");
+      return;
+    }
     this.connections.set(conn, {
       databaseId,
       database,
+      executionTarget,
       subscriptions: /* @__PURE__ */ new Map()
     });
   }
@@ -377,7 +532,7 @@ var WSHandler = class {
     }
     try {
       const params = msg.params ?? void 0;
-      const rows = await state.database.query(msg.sql, params);
+      const rows = await state.executionTarget.query(msg.sql, params);
       this.send(conn, { type: "result", id, data: { rows } });
     } catch (err) {
       this.sendSirannonError(conn, id, err);
@@ -394,7 +549,7 @@ var WSHandler = class {
     }
     try {
       const params = msg.params ?? void 0;
-      const result = await state.database.execute(msg.sql, params);
+      const result = await state.executionTarget.execute(msg.sql, params);
       this.send(conn, {
         type: "result",
         id,
@@ -426,8 +581,9 @@ var WSHandler = class {
       return;
     }
     const filter = msg.filter ?? void 0;
+    let ctx = null;
     try {
-      const ctx = await this.ensureCDC(state.databaseId, state.database);
+      ctx = await this.ensureCDC(state.databaseId, state.database);
       await ctx.tracker.watch(ctx.cdcConn, msg.table);
       const sub = ctx.manager.subscribe(msg.table, filter, (event) => {
         this.sendChange(conn, id, event);
@@ -435,6 +591,9 @@ var WSHandler = class {
       state.subscriptions.set(id, sub);
       this.send(conn, { type: "subscribed", id });
     } catch (err) {
+      if (ctx?.manager.size === 0) {
+        this.maybeCleanupCDC(state.databaseId);
+      }
       this.sendSirannonError(conn, id, err);
     }
   }
@@ -474,6 +633,13 @@ var WSHandler = class {
     const cdcConn = await this.sirannon.driver.open(database.path, { walMode: true });
     const tracker = new ChangeTracker();
     const manager = new SubscriptionManager();
+    try {
+      await tracker.advanceToLatest(cdcConn);
+    } catch (err) {
+      await cdcConn.close().catch(() => {
+      });
+      throw err;
+    }
     let polling = false;
     let consecutiveErrors = 0;
     const MAX_CONSECUTIVE_ERRORS = 10;
@@ -500,9 +666,7 @@ var WSHandler = class {
       }
     };
     const interval = setInterval(tick, DEFAULT_POLL_INTERVAL_MS);
-    if (typeof interval === "object" && "unref" in interval && typeof interval.unref === "function") {
-      interval.unref();
-    }
+    interval.unref?.();
     return { cdcConn, tracker, manager, stopPolling };
   }
   maybeCleanupCDC(databaseId) {
@@ -517,6 +681,12 @@ var WSHandler = class {
     if (params === void 0 || params === null) return true;
     return typeof params === "object";
   }
+  async resolveTarget(databaseId) {
+    if (!this.resolveExecutionTarget) {
+      return await this.sirannon.resolve(databaseId) ?? null;
+    }
+    return await this.resolveExecutionTarget(databaseId) ?? null;
+  }
   send(conn, msg) {
     try {
       conn.send(JSON.stringify(msg));
@@ -580,6 +750,10 @@ function writeCorsOrigin(res, cors, requestOrigin) {
     res.writeHeader("Vary", "Origin");
   }
 }
+function selectWebSocketProtocol(header) {
+  const [firstProtocol] = header.split(",");
+  return firstProtocol?.trim() ?? "";
+}
 function decodeRemoteAddress(res) {
   return Buffer.from(res.getRemoteAddressAsText()).toString();
 }
@@ -606,6 +780,9 @@ var SirannonServer = class {
   port;
   cors;
   onRequestHook;
+  resolveExecutionTarget;
+  getReplicationStatus;
+  getClusterStatus;
   sirannon;
   wsHandler;
   constructor(sirannon, options) {
@@ -614,7 +791,10 @@ var SirannonServer = class {
     this.port = options?.port ?? 9876;
     this.cors = resolveCors(options?.cors);
     this.onRequestHook = options?.onRequest;
-    this.wsHandler = new WSHandler(sirannon);
+    this.resolveExecutionTarget = options?.resolveExecutionTarget;
+    this.getReplicationStatus = options?.getReplicationStatus;
+    this.getClusterStatus = options?.getClusterStatus;
+    this.wsHandler = new WSHandler(sirannon, { resolveExecutionTarget: this.resolveExecutionTarget });
     this.app = uWS.App();
     this.registerRoutes();
   }
@@ -657,10 +837,14 @@ var SirannonServer = class {
       });
     }
     this.app.get("/health", this.withCors(handleLiveness()));
-    this.app.get("/health/ready", this.withCors(handleReadiness(this.sirannon)));
-    this.app.post("/db/:id/query", this.wrapDbRoute(handleQuery(this.sirannon)));
-    this.app.post("/db/:id/execute", this.wrapDbRoute(handleExecute(this.sirannon)));
-    this.app.post("/db/:id/transaction", this.wrapDbRoute(handleTransaction(this.sirannon)));
+    this.app.get("/health/ready", this.withCors(handleReadiness(this.sirannon, this.getReplicationStatus)));
+    this.app.get("/db/:id/cluster", this.wrapDbGetRoute(handleClusterStatus(this.getClusterStatus)));
+    this.app.post("/db/:id/query", this.wrapDbRoute(handleQuery(this.sirannon, this.resolveExecutionTarget)));
+    this.app.post("/db/:id/execute", this.wrapDbRoute(handleExecute(this.sirannon, this.resolveExecutionTarget)));
+    this.app.post(
+      "/db/:id/transaction",
+      this.wrapDbRoute(handleTransaction(this.sirannon, this.resolveExecutionTarget))
+    );
     this.registerWebSocketRoute();
     this.app.any("/*", (res) => {
       sendError(res, 404, "NOT_FOUND", "Route not found");
@@ -679,6 +863,7 @@ var SirannonServer = class {
         const method = req.getMethod();
         const secWebSocketKey = req.getHeader("sec-websocket-key");
         const secWebSocketProtocol = req.getHeader("sec-websocket-protocol");
+        const selectedWebSocketProtocol = selectWebSocketProtocol(secWebSocketProtocol);
         const secWebSocketExtensions = req.getHeader("sec-websocket-extensions");
         const headers = {};
         req.forEach((key, value) => {
@@ -694,7 +879,7 @@ var SirannonServer = class {
             res.upgrade(
               { databaseId: dbId },
               secWebSocketKey,
-              secWebSocketProtocol,
+              selectedWebSocketProtocol,
               secWebSocketExtensions,
               context
             );
@@ -713,7 +898,7 @@ var SirannonServer = class {
           res.upgrade(
             { databaseId: dbId },
             secWebSocketKey,
-            secWebSocketProtocol,
+            selectedWebSocketProtocol,
             secWebSocketExtensions,
             context
           );
@@ -815,6 +1000,39 @@ var SirannonServer = class {
       });
     };
   }
+  wrapDbGetRoute(handler) {
+    const onRequestHook = this.onRequestHook;
+    const corsHeaders = this.cors;
+    return (res, req) => {
+      const dbId = req.getParameter(0) ?? "";
+      const method = req.getMethod();
+      const path = req.getUrl();
+      if (corsHeaders) {
+        writeCorsOrigin(res, corsHeaders, req.getHeader("origin"));
+      }
+      if (!onRequestHook) {
+        handler(res, dbId);
+        return;
+      }
+      const headers = {};
+      req.forEach((key, value) => {
+        headers[key] = value;
+      });
+      const ctx = {
+        headers,
+        method,
+        path,
+        databaseId: dbId,
+        remoteAddress: decodeRemoteAddress(res)
+      };
+      runOnRequest(res, ctx, onRequestHook).then((allowed) => {
+        if (allowed) {
+          handler(res, dbId);
+        }
+      }).catch(() => {
+      });
+    };
+  }
 };
 function createServer(sirannon, options) {
   return new SirannonServer(sirannon, options);

package/dist/sirannon-Cd-lK6T0.d.ts

@@ -0,0 +1,31 @@
+import { D as Database } from './database-BVY1GqE7.js';
+import { S as SQLiteDriver } from './types-BFSsG77t.js';
+import { S as SirannonOptions, D as DatabaseOptions, B as BeforeQueryHook, A as AfterQueryHook, a as BeforeConnectHook, b as DatabaseOpenHook, c as DatabaseCloseHook } from './types-D-74JiXb.js';
+
+declare class Sirannon {
+    readonly options: SirannonOptions;
+    private readonly dbs;
+    private readonly opening;
+    private _shutdown;
+    private readonly _driver;
+    private readonly hookRegistry;
+    private readonly metricsCollector;
+    private readonly lifecycleManager;
+    constructor(options: SirannonOptions);
+    get driver(): SQLiteDriver;
+    open(id: string, path: string, options?: DatabaseOptions): Promise<Database>;
+    close(id: string): Promise<void>;
+    get(id: string): Database | undefined;
+    resolve(id: string): Promise<Database | undefined>;
+    has(id: string): boolean;
+    databases(): Map<string, Database>;
+    shutdown(): Promise<void>;
+    onBeforeQuery(hook: BeforeQueryHook): void;
+    onAfterQuery(hook: AfterQueryHook): void;
+    onBeforeConnect(hook: BeforeConnectHook): void;
+    onDatabaseOpen(hook: DatabaseOpenHook): void;
+    onDatabaseClose(hook: DatabaseCloseHook): void;
+    private ensureRunning;
+}
+
+export { Sirannon as S };