@quo-systems/quo 0.2.1 → 0.2.3

package/SPEC.md

@@ -851,10 +851,14 @@ One ward is one runtime and one language, and every being in it shares both.
 A harbor that wants two languages starts two wards at least. Under
 `src/being/`, `src/ward/`, `src/harbor/` and `src/conformance/` no runtime is
 named. The whole
-platform surface is the language plus six globals -- `crypto`, `TextEncoder`,
-`TextDecoder`, `structuredClone`, `setTimeout`, `atob` -- and that list is a
-promise, not an accident: `test/terrain.test.ts` fails the build both when a
-file names a platform and when it reaches for a global outside the list.
+platform surface is the language plus ten globals. Six are the ward's own:
+`crypto`, `TextEncoder`, `TextDecoder`, `structuredClone`, `setTimeout` and
+`atob`. Four more came with the harbor, and are the whole of what a reach
+costs: `fetch` and `WebSocket`, the two kinds of reach; `DataView`, the frame
+id on a socket; and `clearTimeout`, the dialer's reconnect called off. That
+list is a promise, not an accident: `test/terrain.test.ts` fails the build
+both when a file names a platform and when it reaches for a global outside
+the list, and when the list names one the tree has stopped using.
 
 The package exports raw TypeScript, extension and all, on every specifier, so
 Node loads it directly and every other terrain reaches a ward through a
@@ -891,7 +895,8 @@ partition
   bind      key -> her bind table
               standings   id -> { ward, heir | null, current, next, seq }     her keys for a standing
               occupants   id -> heir pk
-              knocks      <ward>:<heir> | public:<ward> -> { current, next, spoke, seq }   before take
+              knocks      <ward>:<heir> | public:<ward> -> { current, next, spoke, sent, seq }   before take
+                          spoke: bytes came back once. sent: bytes went out once, answered or not
               answered    <ward>:<heir> | public:<ward> -> true                            knocked and answered
               minted      the last eight pks her side minted
   heirs     heir pk -> { being, id, current, announced, fresh, mark, spent }   the door's view of every occupant
@@ -1185,8 +1190,7 @@ way waits out the ceiling before asking again, because a suite does not
 become speakable by asking sooner. Its wait returns to the first second
 where the far side announced and was taken, and not where the line merely
 opened: a listener that opens and then refuses would otherwise be dialed at
-a fixed two seconds for good, which is what the lab measured before the
-code was read. Absent is this suite,
+a fixed two seconds for good. Absent is this suite,
 because a caller older than the header is this one. Present and different is
 refused as it is written: the number is compared as it was sent, so a suite
 is one spelling and not a family of them.
@@ -1234,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
@@ -1436,8 +1445,8 @@ alone, one JavaScript file and one declaration file per source file with
 every relative import rewritten, and the exports map points there, types
 beside default. The
 build runs before every gate and every publish and is never tracked;
-nothing under `test/` or `dock/` imports it except through the package
-name, which is how a consumer does. `test/package.test.ts` is the one
+nothing in this repository imports it except through the package name,
+which is how a consumer does. `test/package.test.ts` is the one
 suite that meets the package as a stranger: it packs the tarball,
 installs it into an empty folder, and imports every entry point under
 plain Node. `npm pack --dry-run` shows what ships: `dist/`, the four
@@ -1456,11 +1465,6 @@ test/             the suites.
 vectors/          fixed inputs and outputs: the arithmetic, Quo's own framing, the frames on the wire.
 ```
 
-`dock/` sits beside `src` and is not Quo: the beings, screens, model sides
-and real harbors built on it, each folder with its own document. This
-document does not read them, and they may not add a word to it. Its one
-claim on them is that every harbor there passes `src/conformance/` untouched.
-
 The hand to a kit in another language is two things, and they are of two
 kinds. `vectors/` is the byte-level hand: fixed inputs and outputs for
 everything a stranger can observe, the arithmetic, the ward pk, the digest,

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.1",
+  "version": "0.2.3",
   "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);