@delali/narsil 0.2.2 → 0.2.3-next.33

package/dist/distribution/transport/in-memory.mjs

@@ -0,0 +1,214 @@
+import { DEFAULT_TRANSPORT_CONFIG, TransportError, TransportErrorCodes, MAX_MESSAGE_SIZE_BYTES } from '../../chunk-C6VVLMRX.mjs';
+
+// src/distribution/transport/in-memory.ts
+function createInMemoryNetwork() {
+  const transports = /* @__PURE__ */ new Map();
+  return {
+    register(nodeId, transport) {
+      transports.set(nodeId, transport);
+    },
+    unregister(nodeId) {
+      transports.delete(nodeId);
+    },
+    getTransport(nodeId) {
+      return transports.get(nodeId);
+    }
+  };
+}
+function createInMemoryTransport(nodeId, network, config) {
+  const resolvedConfig = {
+    ...DEFAULT_TRANSPORT_CONFIG,
+    ...config
+  };
+  let listenHandler;
+  let isShutdown = false;
+  function assertNotShutdown() {
+    if (isShutdown) {
+      throw new TransportError(
+        TransportErrorCodes.PEER_UNAVAILABLE,
+        `Transport for node '${nodeId}' has been shut down`,
+        { nodeId }
+      );
+    }
+  }
+  function lookupPeer(target) {
+    const peer = network.getTransport(target);
+    if (peer === void 0) {
+      throw new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, `Node '${target}' is not reachable`, { target });
+    }
+    return peer;
+  }
+  const internal = {
+    deliverMessage(message, respond) {
+      if (listenHandler === void 0) {
+        return;
+      }
+      listenHandler(message, respond);
+    },
+    deliverStream(message, sink) {
+      if (listenHandler === void 0) {
+        sink.fail(
+          new TransportError(TransportErrorCodes.PEER_UNAVAILABLE, `Node '${nodeId}' has no listener registered`, {
+            nodeId,
+            requestId: message.requestId
+          })
+        );
+        return;
+      }
+      let chunkCount = 0;
+      const respond = async (response) => {
+        chunkCount++;
+        await sink.chunk(response.payload);
+      };
+      const finish = () => {
+        if (chunkCount === 0) {
+          sink.fail(
+            new TransportError(
+              TransportErrorCodes.PEER_UNAVAILABLE,
+              `Node '${nodeId}' answered the stream with no chunks`,
+              { nodeId, requestId: message.requestId }
+            )
+          );
+          return;
+        }
+        sink.end();
+      };
+      try {
+        const handlerResult = listenHandler(message, respond);
+        if (handlerResult instanceof Promise) {
+          handlerResult.then(finish, (error) => {
+            sink.fail(error instanceof Error ? error : new Error(String(error)));
+          });
+          return;
+        }
+        finish();
+      } catch (error) {
+        sink.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    },
+    async send(target, message) {
+      assertNotShutdown();
+      if (message.payload.byteLength > MAX_MESSAGE_SIZE_BYTES) {
+        throw new TransportError(
+          TransportErrorCodes.MESSAGE_TOO_LARGE,
+          `Message payload (${message.payload.byteLength} bytes) exceeds the ${MAX_MESSAGE_SIZE_BYTES} byte limit`,
+          { target, requestId: message.requestId, payloadSize: message.payload.byteLength }
+        );
+      }
+      const peer = lookupPeer(target);
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const timeoutId = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            reject(
+              new TransportError(
+                TransportErrorCodes.TIMEOUT,
+                `Request to node '${target}' timed out after ${resolvedConfig.requestTimeout}ms`,
+                { target, requestId: message.requestId, timeoutMs: resolvedConfig.requestTimeout }
+              )
+            );
+          }
+        }, resolvedConfig.requestTimeout);
+        try {
+          peer.deliverMessage(message, async (response) => {
+            if (!settled) {
+              settled = true;
+              clearTimeout(timeoutId);
+              resolve(response);
+            }
+          });
+        } catch (error) {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timeoutId);
+            reject(error);
+          }
+        }
+      });
+    },
+    async stream(target, message, handler) {
+      assertNotShutdown();
+      const peer = lookupPeer(target);
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const timeoutId = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            reject(
+              new TransportError(
+                TransportErrorCodes.TIMEOUT,
+                `Stream to node '${target}' timed out after ${resolvedConfig.snapshotTimeout}ms`,
+                { target, requestId: message.requestId, timeoutMs: resolvedConfig.snapshotTimeout }
+              )
+            );
+          }
+        }, resolvedConfig.snapshotTimeout);
+        const settle = (action) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          clearTimeout(timeoutId);
+          action();
+        };
+        const sink = {
+          chunk(payload) {
+            if (settled) {
+              return Promise.resolve();
+            }
+            try {
+              handler(payload);
+            } catch (error) {
+              settle(() => {
+                reject(
+                  new TransportError(
+                    TransportErrorCodes.DECODE_FAILED,
+                    `The stream chunk handler failed: ${error instanceof Error ? error.message : String(error)}`,
+                    { target, requestId: message.requestId }
+                  )
+                );
+              });
+            }
+            return Promise.resolve();
+          },
+          end() {
+            settle(resolve);
+          },
+          fail(error) {
+            settle(() => {
+              reject(error);
+            });
+          }
+        };
+        try {
+          peer.deliverStream(message, sink);
+        } catch (error) {
+          settle(() => {
+            reject(error);
+          });
+        }
+      });
+    },
+    async listen(handler) {
+      listenHandler = handler;
+      return () => {
+        if (listenHandler === handler) {
+          listenHandler = void 0;
+        }
+      };
+    },
+    async shutdown() {
+      if (isShutdown) {
+        return;
+      }
+      isShutdown = true;
+      network.unregister(nodeId);
+      listenHandler = void 0;
+    }
+  };
+  network.register(nodeId, internal);
+  return internal;
+}
+
+export { createInMemoryNetwork, createInMemoryTransport };

package/dist/distribution/transport/tcp.d.ts

@@ -0,0 +1,27 @@
+import { N as NodeTransport } from '../../types-D5OwhtsQ.js';
+import { T as TcpTransportConfig, a as TlsConfig } from '../../types-BQDlIvfS.js';
+
+/**
+ * Builds the TCP transport a cluster node reaches its peers through, with
+ * length-prefixed MessagePack frames and optional mutual TLS.
+ *
+ * The transport listens on `config.host` and `config.port`, and it dials a
+ * peer at the `host:port` address that peer registered with the coordinator.
+ * Passing `config.tls` makes every connection mutually authenticated: the
+ * server requests a client certificate and both sides verify against the
+ * configured authority.
+ *
+ * @param nodeId - The node this transport belongs to, used in error reports.
+ * @param config - The listen address, the connection limits, the timeouts,
+ * and the TLS material.
+ * @returns The transport, with `getPort` for reading the bound port and
+ * `rotateTlsContext` for renewing certificates without a restart.
+ *
+ * @public
+ */
+declare function createTcpTransport(nodeId: string, config?: Partial<TcpTransportConfig>): NodeTransport & {
+    getPort(): number;
+    rotateTlsContext(nextTlsConfig: TlsConfig): void;
+};
+
+export { TcpTransportConfig, TlsConfig, createTcpTransport };