@quo-systems/quo 0.2.2 → 0.2.4

package/SPEC.md

@@ -1238,7 +1238,12 @@ is reachable through it without waiting for that line to fall; the listener's
 bound, dialed again
 with a wait that doubles from a second to thirty when the line drops, and
 while it is dialed it is one of the harbor's fallbacks, where a pk nobody
-here knows is sent. Fallbacks are a list and a pk is tried down it in
+here knows is sent. A device that slept, a phone in a pocket, comes back
+with that wait frozen and, often, its socket closed under it by the system
+without a word, so the dialer takes one call from the device, `wake`: a
+line in hand is made to announce, and a dead one closes under the word and
+is dialed again; a line that is down is dialed now, the wait called off; a
+dial in flight is left alone. Fallbacks are a list and a pk is tried down it in
 order: a harbor may dial more than one listener, and a rendezvous is a
 listener and nothing more, so a ward is never reachable through one place
 by anything but its own choice. A line that drops takes only its own place

package/dist/harbor/dial.d.ts

@@ -3,6 +3,7 @@ import { Socket } from './reach.ts';
 export type Dialer = {
     url: string;
     socket: Socket | null;
+    wake(): void;
     close(): void;
 };
 export declare function dial(harbor: Harbor, url: string): Dialer;

package/dist/harbor/dial.js

@@ -1,8 +1,9 @@
 import { REFUSED, Socket } from './reach.js';
 export function dial(harbor, url) {
-    const d = { url, socket: null, close: () => { } };
+    const d = { url, socket: null, wake: () => { }, close: () => { } };
     let stopped = false, wait = 1000, timer;
     const connect = () => {
+        timer = undefined; // no wait pending: this is the dial it was waiting for
         if (stopped)
             return;
         const line = new WebSocket(url.replace(/\/$/, '').replace(/^http/, 'ws'));
@@ -41,6 +42,18 @@ export function dial(harbor, url) {
             say();
         });
     };
+    d.wake = () => {
+        if (stopped)
+            return;
+        if (d.socket)
+            return d.socket.announce([...harbor.doors.keys()]);
+        if (timer === undefined)
+            return;
+        clearTimeout(timer);
+        timer = undefined;
+        wait = 1000;
+        connect();
+    };
     d.close = () => {
         stopped = true;
         clearTimeout(timer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quo-systems/quo",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",

package/src/harbor/dial.ts

@@ -11,14 +11,21 @@
 import type { Harbor } from './core.ts';
 import { REFUSED, Socket, type Line } from './reach.ts';
 
-export type Dialer = { url: string; socket: Socket | null; close(): void };
+// `wake` is the device saying it is back: a phone out of a pocket, a
+// laptop's lid opened. A device that slept comes back with its timer
+// frozen and, often, its socket closed under it by the system without a
+// word. So a line in hand is made to speak, an announce, and a dead one
+// closes under the word and is dialed again; a line that is down is dialed
+// now instead of waiting out the backoff; a dial in flight is left alone.
+export type Dialer = { url: string; socket: Socket | null; wake(): void; close(): void };
 
 export function dial(harbor: Harbor, url: string): Dialer {
-  const d: Dialer = { url, socket: null, close: () => {} };
+  const d: Dialer = { url, socket: null, wake: () => {}, close: () => {} };
   let stopped = false,
     wait = 1000,
     timer: ReturnType<typeof setTimeout> | undefined;
   const connect = () => {
+    timer = undefined; // no wait pending: this is the dial it was waiting for
     if (stopped) return;
     const line = new WebSocket(url.replace(/\/$/, '').replace(/^http/, 'ws')) as unknown as Line;
     const s: Socket = new Socket(
@@ -57,6 +64,15 @@ export function dial(harbor: Harbor, url: string): Dialer {
       say();
     });
   };
+  d.wake = () => {
+    if (stopped) return;
+    if (d.socket) return d.socket.announce([...harbor.doors.keys()]);
+    if (timer === undefined) return;
+    clearTimeout(timer);
+    timer = undefined;
+    wait = 1000;
+    connect();
+  };
   d.close = () => {
     stopped = true;
     clearTimeout(timer);