@hile/micro 4.0.5 → 4.0.6

package/AI.md

@@ -282,6 +282,9 @@ import { MessageWorkerThread } from '@hile/message-worker-thread'
 - `defineMicroMessage()` handlers receive request streams as `input: Readable | undefined`, separately from structured `data` and `invocation`.
 - `Application.call(namespace, url, data, options)` requires `options.context` and returns a promise. It accepts `options.input` for a streamed request with a normal response.
 - `Application.stream(namespace, url, data, options)` requires `options.context` and returns a readable response stream; it can carry a request input stream at the same time.
+- `Application.call()` and `Application.stream()` may target the application's own namespace. Self calls use the same Registry-discovered WebSocket and modem protocol as remote calls, so Context validation, request and response streams, cancellation, timeout, retry, circuit-breaker, and backpressure behavior stay uniform; business handlers do not need a local-call branch.
+- A peer address (`host:port`) is the routing and reuse identity, not an individual WebSocket identity. If both peers dial each other concurrently, including an application dialing itself, the server preserves both physical connections while they are active instead of replacing a connection that may carry an in-flight request. Later calls still reuse the cached peer connection.
+- This connection bookkeeping does not add or change wire frames; request, response, stream, credit, cancel, and abort protocol fields remain unchanged.
 - `Application.call()` and `Application.stream()` default retries to `0` when request input is streamed. Explicit nonzero retries fail before service discovery because streamed input is non-replayable.
 - A caller-owned request input source failure is surfaced as `MessageInputError`, aborts the peer invocation, and is not counted against that peer's circuit-breaker health.
 - `Application.publish(topic, payload)` returns an object with `update()` and `unpublish()`.
@@ -293,6 +296,7 @@ import { MessageWorkerThread } from '@hile/message-worker-thread'
 - Appending a secondary response getter to `client.request('/x', data)`
 - Returning a plain object from a handler called through `stream()`.
 - Retrying a consumed request stream or hiding it inside a replay-unsafe factory.
+- Branching business code on whether a Micro target namespace is local or remote.
 - Using pub/sub as a durable queue.
 - Forgetting to register `shutdown(await app.listen(...))`.
 
@@ -300,6 +304,7 @@ import { MessageWorkerThread } from '@hile/message-worker-thread'
 
 - Micro message files default-export `defineMicroMessage(...)` and receive `invocation.context`.
 - RPC callers use `await app.call(..., { context })`.
+- Same-namespace `call()` and `stream()` use normal Registry discovery, while `streamPeer()` keeps its exact-address selection; all three use the normal WebSocket/modem transport path and callers do not branch on locality.
 - Streaming handlers are async generators.
 - Request-stream handlers consume `input` and callers either pass `options.input` alongside metadata or pass a stream directly as `data`.
 - Streamed request calls do not configure nonzero retries.

package/README.md

@@ -80,6 +80,7 @@ const result = await app.call('example.service', '/ping', { hello: 'world' }, {
 - Appending a secondary response getter to `client.request('/x', data)`
 - Returning a plain object from a handler called through `stream()`.
 - Retrying a consumed request stream or hiding it inside a replay-unsafe factory.
+- Branching business code on whether a Micro target namespace is local or remote.
 - Using pub/sub as a durable queue.
 - Forgetting to register `shutdown(await app.listen(...))`.
 
@@ -87,6 +88,7 @@ const result = await app.call('example.service', '/ping', { hello: 'world' }, {
 
 - Micro message files default-export `defineMicroMessage(...)` and receive `invocation.context`.
 - RPC callers use `await app.call(..., { context })`.
+- Same-namespace `call()` and `stream()` use normal Registry discovery, while `streamPeer()` keeps its exact-address selection; all three use the normal WebSocket/modem transport path and callers do not branch on locality.
 - Streaming handlers are async generators.
 - Request-stream handlers consume `input` and callers either pass `options.input` alongside metadata or pass a stream directly as `data`.
 - Streamed request calls do not configure nonzero retries.

package/dist/server.d.ts

@@ -23,12 +23,14 @@ export declare class Server extends MessageLoader {
     readonly logger: Logger | Console;
     readonly clients: Map<string, Client>;
     private readonly clientExtras;
+    private readonly connections;
     private readonly pendingConnections;
     private readonly announceHost;
     readonly events: EventEmitter<any>;
     get host(): string;
     constructor(namespace: string, props?: MicroServerProps);
     private upstream;
+    private removeClient;
     private createClient;
     protected connect(host: string, port: number, timeout?: number, signal?: AbortSignal): Promise<Client>;
     private openConnection;

package/dist/server.js

@@ -12,6 +12,7 @@ export class Server extends MessageLoader {
     logger;
     clients = new Map();
     clientExtras = new Map();
+    connections = new Map();
     pendingConnections = new Map();
     announceHost;
     events = new EventEmitter();
@@ -54,29 +55,42 @@ export class Server extends MessageLoader {
             portNum > 65535) {
             return ws.close();
         }
-        this.createClient(ws, host, portNum, extras);
+        this.createClient(ws, host, portNum, extras, 'inbound');
     }
-    createClient(ws, host, port, extras = []) {
-        const key = `${host}:${port}`;
-        const previous = this.clients.get(key);
-        if (previous) {
-            const previousExtras = this.clientExtras.get(key) ?? [];
+    removeClient(client, fallback) {
+        const connection = this.connections.get(client) ?? fallback;
+        if (!connection)
+            return;
+        const { key, extras } = connection;
+        this.connections.delete(client);
+        if (this.clients.get(key) === client) {
             this.clients.delete(key);
             this.clientExtras.delete(key);
-            previous.dispose();
-            this.events.emit('disconnect', previous, previousExtras);
         }
-        const client = new Client({ server: this, ws, host, port });
-        ws.on('close', () => {
-            if (this.clients.get(key) === client) {
-                this.clients.delete(key);
-                this.clientExtras.delete(key);
-                client.dispose();
-                this.events.emit('disconnect', client, extras);
+        client.dispose();
+        this.events.emit('disconnect', client, extras);
+    }
+    createClient(ws, host, port, extras = [], direction) {
+        const key = `${host}:${port}`;
+        // host:port identifies a peer, not an individual WebSocket. When both peers
+        // dial at the same time (including a server dialing itself), the inbound
+        // half arrives while an outbound connection for the same peer is pending.
+        // Keep that inbound half alive for requests already using it, but reserve
+        // the peer cache slot for the outbound half that connect() will return.
+        const isDialCollision = direction === 'inbound' && this.pendingConnections.has(key);
+        if (!isDialCollision) {
+            const previous = this.clients.get(key);
+            if (previous) {
+                this.removeClient(previous, { key, extras: this.clientExtras.get(key) ?? [] });
             }
-        });
-        this.clients.set(key, client);
-        this.clientExtras.set(key, extras);
+        }
+        const client = new Client({ server: this, ws, host, port });
+        this.connections.set(client, { key, extras });
+        ws.on('close', () => this.removeClient(client));
+        if (!isDialCollision) {
+            this.clients.set(key, client);
+            this.clientExtras.set(key, extras);
+        }
         this.events.emit('connect', client, extras);
         return client;
     }
@@ -91,7 +105,7 @@ export class Server extends MessageLoader {
         if (!pending) {
             const controller = new AbortController();
             const promise = this.openConnection(host, port, controller.signal)
-                .then(ws => this.createClient(ws, host, port))
+                .then(ws => this.createClient(ws, host, port, [], 'outbound'))
                 .finally(() => { this.pendingConnections.delete(key); });
             promise.catch(() => undefined);
             pending = { promise, controller, waiters: 0 };
@@ -202,16 +216,15 @@ export class Server extends MessageLoader {
                     });
                 });
             }
-            const toDispose = [...this.clients.entries()];
-            for (const [key, client] of toDispose) {
-                const extras = this.clientExtras.get(key) ?? [];
-                this.clients.delete(key);
-                this.clientExtras.delete(key);
-                client.dispose();
-                this.events.emit('disconnect', client, extras);
+            for (const client of [...this.connections.keys()]) {
+                this.removeClient(client);
+            }
+            for (const [key, client] of [...this.clients.entries()]) {
+                this.removeClient(client, { key, extras: this.clientExtras.get(key) ?? [] });
             }
             this.clients.clear();
             this.clientExtras.clear();
+            this.connections.clear();
             this.wss = undefined;
             this.port = undefined;
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hile/micro",
-  "version": "4.0.5",
+  "version": "4.0.6",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -26,12 +26,12 @@
   "dependencies": {
     "@hile/context": "^4.0.3",
     "@hile/logger": "^4.0.2",
-    "@hile/message-loader": "^4.0.5",
-    "@hile/message-modem": "^4.0.4",
-    "@hile/message-ws": "^4.0.4",
+    "@hile/message-loader": "^4.0.6",
+    "@hile/message-modem": "^4.0.5",
+    "@hile/message-ws": "^4.0.5",
     "internal-ip": "^9.0.0",
     "ws": "^8.21.0",
     "yaml": "^2.9.0"
   },
-  "gitHead": "c57b2c5a3c017ae56d4a862a089b2af01368c3ba"
+  "gitHead": "f845e0eb6a9d56ef72d2305624ad44abcdff5063"
 }