@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/transport/memory.d.ts

@@ -1,9 +1,9 @@
-import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-CbjfRwrK.js';
-import { R as ReplicationBatch } from '../types-CjhxcjhA.js';
-import '../change-tracker-CjRFuZdB.js';
-import '../types-DPSmjU54.js';
-import '../query-types-p1liOP-b.js';
-import '../types-B0EhgDbr.js';
+import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-BrAiDGOb.js';
+import { R as ReplicationBatch } from '../types-DqODKeOq.js';
+import '../change-tracker-DqCdeEyx.js';
+import '../types-Dc8oWlxj.js';
+import '../query-types-5B02ixH0.js';
+import '../types-guEKSzMr.js';
 
 type BatchHandler = (batch: ReplicationBatch, fromPeerId: string) => Promise<void>;
 type AckHandler = (ack: ReplicationAck, fromPeerId: string) => void;
@@ -16,15 +16,15 @@ type SyncCompleteHandler = (complete: SyncComplete, fromPeerId: string) => Promi
 type SyncAckHandler = (ack: SyncAck, fromPeerId: string) => void;
 
 /**
- * In-process ReplicationTransport for testing and single-process multi-node
- * scenarios.
+ * Sends replication messages between nodes that share one process, for tests
+ * and for single-process setups with several nodes.
  *
- * Messages between peers are delivered through a shared MemoryBus via
- * microtask scheduling (`queueMicrotask`), preserving the async delivery
- * semantics of a real network transport with no I/O. All
- * message types (batches, acks, forwards) go through runtime
- * validation before delivery, and malformed payloads are silently dropped
- * to match the behaviour of a lossy network.
+ * The transport delivers each message through a shared {@link MemoryBus} in a
+ * later microtask (`queueMicrotask`), so that delivery stays asynchronous, as
+ * it is over a network, with no I/O. For a forwarded write, the transport
+ * calls the primary's handler directly and returns its result. Every send
+ * method validates its message first and throws a `TransportError` for a
+ * malformed one.
  *
  * @public
  */
@@ -48,9 +48,9 @@ declare class InMemoryTransport implements ReplicationTransport {
     private syncAckHandler;
     constructor(bus: MemoryBus);
     private get role();
-    /** Connects to the configured peers and announces this node. */
+    /** Joins the bus and connects this node to every other connected transport on the bus. */
     connect(localNodeId: string, config: TransportConfig): Promise<void>;
-    /** Closes every peer connection. */
+    /** Leaves the bus and disconnects this node from every peer. */
     disconnect(): Promise<void>;
     /** Sends one batch of changes to one peer. */
     send(peerId: string, batch: ReplicationBatch): Promise<void>;
@@ -64,15 +64,15 @@ declare class InMemoryTransport implements ReplicationTransport {
     requestSync(peerId: string, request: SyncRequest): Promise<void>;
     /** Sends one page of first-sync table data. */
     sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
-    /** Tells a joining node that first sync has finished, and sends the manifests to verify it. */
+    /** Tells a joining node that first sync is complete, and sends the manifests that the node checks its copy against. */
     sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
-    /** Confirms to the source that a joining node stored one first-sync page. */
+    /** Tells the source whether this joining node stored one first-sync page. */
     sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
     /** Registers the handler that applies incoming change batches. */
     onBatchReceived(handler: BatchHandler): void;
     /** Registers the handler that records incoming acknowledgements. */
     onAckReceived(handler: AckHandler): void;
-    /** Registers the handler that runs a write a replica forwarded. */
+    /** Registers the handler that executes a write that a replica forwards. */
     onForwardReceived(handler: ForwardHandler): void;
     /** Registers the handler that serves a first-sync request. */
     onSyncRequested(handler: SyncRequestHandler): void;
@@ -82,11 +82,11 @@ declare class InMemoryTransport implements ReplicationTransport {
     onSyncCompleteReceived(handler: SyncCompleteHandler): void;
     /** Registers the handler that records first-sync page acknowledgements. */
     onSyncAckReceived(handler: SyncAckHandler): void;
-    /** Registers the handler that runs when a peer connects. */
+    /** Registers the handler that the transport calls when a peer connects. */
     onPeerConnected(handler: PeerConnectedHandler): void;
-    /** Registers the handler that runs when a peer disconnects. */
+    /** Registers the handler that the transport calls when a peer disconnects. */
     onPeerDisconnected(handler: PeerDisconnectedHandler): void;
-    /** Returns every connected peer, keyed by identifier. */
+    /** Returns every connected peer, keyed by node ID. */
     peers(): ReadonlyMap<string, NodeInfo>;
     private _receiveBatch;
     private _receiveAck;
@@ -99,10 +99,9 @@ declare class InMemoryTransport implements ReplicationTransport {
 }
 
 /**
- * Shared message bus that connects InMemoryTransport instances within the
- * same process. Each transport registers itself on `connect()` and messages
- * are delivered via direct method calls on the target transport through
- * microtask scheduling, simulating async network delivery with no I/O.
+ * Connects {@link InMemoryTransport} instances inside one process. Each
+ * transport joins the bus in `connect()`. A sending transport looks up its
+ * target on the bus and calls the target's receive method, with no network I/O.
  *
  * @public
  */

package/dist/transport/memory.mjs

@@ -63,7 +63,7 @@ function isValidAck(ack) {
 function isValidForwardedTransaction(req) {
   if (typeof req !== "object" || req === null) return false;
   const r = req;
-  return typeof r.requestId === "string" && Array.isArray(r.statements) && optionalString(r.groupId) && optionalBigint(r.primaryTerm);
+  return typeof r.requestId === "string" && Array.isArray(r.statements) && optionalString(r.groupId) && optionalBigint(r.primaryTerm) && optionalWriteConcern(r.writeConcern);
 }
 function isValidSyncRequest(req) {
   if (typeof req !== "object" || req === null) return false;
@@ -91,6 +91,15 @@ function optionalString(value) {
 function optionalBigint(value) {
   return value === void 0 || typeof value === "bigint";
 }
+function optionalWriteConcern(value) {
+  if (value === void 0) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const concern = value;
+  const knownLevel = concern.level === "local" || concern.level === "majority" || concern.level === "all";
+  const timeoutMs = concern.timeoutMs;
+  const validTimeout = timeoutMs === void 0 || typeof timeoutMs === "number" && Number.isSafeInteger(timeoutMs) && timeoutMs > 0;
+  return knownLevel && validTimeout;
+}
 function optionalNonNegativeInteger(value) {
   return value === void 0 || typeof value === "number" && Number.isInteger(value) && value >= 0;
 }
@@ -120,7 +129,7 @@ var InMemoryTransport = class {
   get role() {
     return this.localRole;
   }
-  /** Connects to the configured peers and announces this node. */
+  /** Joins the bus and connects this node to every other connected transport on the bus. */
   async connect(localNodeId, config) {
     if (this.connected) {
       throw new TransportError("Transport is already connected");
@@ -166,7 +175,7 @@ var InMemoryTransport = class {
       }
     }
   }
-  /** Closes every peer connection. */
+  /** Leaves the bus and disconnects this node from every peer. */
   async disconnect() {
     if (!this.connected) return;
     this.connected = false;
@@ -266,7 +275,7 @@ var InMemoryTransport = class {
       });
     });
   }
-  /** Tells a joining node that first sync has finished, and sends the manifests to verify it. */
+  /** Tells a joining node that first sync is complete, and sends the manifests that the node checks its copy against. */
   async sendSyncComplete(peerId, complete) {
     this.ensureConnected();
     if (!isValidSyncComplete(complete)) throw new TransportError("Invalid sync complete structure");
@@ -278,7 +287,7 @@ var InMemoryTransport = class {
       });
     });
   }
-  /** Confirms to the source that a joining node stored one first-sync page. */
+  /** Tells the source whether this joining node stored one first-sync page. */
   async sendSyncAck(peerId, ack) {
     this.ensureConnected();
     if (!isValidSyncAck(ack)) throw new TransportError("Invalid sync ack structure");
@@ -297,7 +306,7 @@ var InMemoryTransport = class {
   onAckReceived(handler) {
     this.ackHandler = handler;
   }
-  /** Registers the handler that runs a write a replica forwarded. */
+  /** Registers the handler that executes a write that a replica forwards. */
   onForwardReceived(handler) {
     this.forwardHandler = handler;
   }
@@ -317,15 +326,15 @@ var InMemoryTransport = class {
   onSyncAckReceived(handler) {
     this.syncAckHandler = handler;
   }
-  /** Registers the handler that runs when a peer connects. */
+  /** Registers the handler that the transport calls when a peer connects. */
   onPeerConnected(handler) {
     this.peerConnectedHandler = handler;
   }
-  /** Registers the handler that runs when a peer disconnects. */
+  /** Registers the handler that the transport calls when a peer disconnects. */
   onPeerDisconnected(handler) {
     this.peerDisconnectedHandler = handler;
   }
-  /** Returns every connected peer, keyed by identifier. */
+  /** Returns every connected peer, keyed by node ID. */
   peers() {
     return this.connectedPeers;
   }