wenay-common2 1.0.70 → 1.0.74

package/lib/Common/peer/peer-call.d.ts

@@ -0,0 +1,65 @@
+import { SignalEnvelope, SignalPort } from '../events/route-signal-webrtc';
+export type tCallState = 'ringing' | 'active' | 'ended';
+export type tCallEnd = 'declined' | 'busy' | 'offline' | 'timeout' | 'hangup' | 'canceled' | 'closed';
+export type CallManagerDeps = {
+    port: SignalPort;
+    self: string;
+    ringTimeoutMs?: number;
+    incoming?: (info: {
+        peer: string;
+        meta?: unknown;
+    }) => boolean | Promise<boolean>;
+};
+export declare function callPortOf(remote: {
+    signal: {
+        send: (env: SignalEnvelope) => any;
+        signals: {
+            on: (cb: (env: SignalEnvelope) => void) => any;
+        };
+    };
+}): SignalPort;
+export declare function createCallManager(deps: CallManagerDeps): {
+    ready: Promise<void>;
+    call: (other: string, meta?: unknown) => {
+        id: string;
+        peer: string;
+        direction: "out" | "in";
+        meta: unknown;
+        state: () => tCallState;
+        reason: () => tCallEnd | null;
+        changed: import("../events/Listen").ListenApi<[tCallState]>;
+        ended: Promise<tCallEnd>;
+        accept(): void;
+        decline(why?: tCallEnd): void;
+        hangup(): void;
+    };
+    rings: import("../events/Listen").ListenApi<[{
+        id: string;
+        peer: string;
+        direction: "out" | "in";
+        meta: unknown;
+        state: () => tCallState;
+        reason: () => tCallEnd | null;
+        changed: import("../events/Listen").ListenApi<[tCallState]>;
+        ended: Promise<tCallEnd>;
+        accept(): void;
+        decline(why?: tCallEnd): void;
+        hangup(): void;
+    }]>;
+    active: () => {
+        id: string;
+        peer: string;
+        direction: "out" | "in";
+        meta: unknown;
+        state: () => tCallState;
+        reason: () => tCallEnd | null;
+        changed: import("../events/Listen").ListenApi<[tCallState]>;
+        ended: Promise<tCallEnd>;
+        accept(): void;
+        decline(why?: tCallEnd): void;
+        hangup(): void;
+    } | null;
+    close(): void;
+};
+export type CallManager = ReturnType<typeof createCallManager>;
+export type CallHandle = ReturnType<CallManager['call']>;

package/lib/Common/peer/peer-call.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callPortOf = callPortOf;
+exports.createCallManager = createCallManager;
+const Listen_1 = require("../events/Listen");
+function callPortOf(remote) {
+    return {
+        send: env => remote.signal.send(env),
+        signals: { on: cb => remote.signal.signals.on(cb) },
+    };
+}
+function createCallManager(deps) {
+    const { port, self, ringTimeoutMs = 30_000, incoming } = deps;
+    const [emitRing, rings] = (0, Listen_1.listen)();
+    const calls = new Map();
+    let n = 0;
+    const callScope = Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+    let evaluatingIncoming = 0;
+    let closed = false;
+    function makeCall(pair, other, direction, meta) {
+        let state = 'ringing';
+        let reason = null;
+        const [emitChange, changed] = (0, Listen_1.listen)();
+        let resolveEnded;
+        const ended = new Promise(r => { resolveEnded = r; });
+        const ringTimer = setTimeout(function onRingTimeout() { finish('timeout', direction == 'out'); }, ringTimeoutMs);
+        function send(type, why) {
+            void Promise.resolve(port.send({ type, pair, from: self, to: other, reason: why })).catch(swallowSendError);
+        }
+        function finish(why, notify, notifyAs = 'hangup') {
+            if (state == 'ended')
+                return;
+            state = 'ended';
+            reason = why;
+            clearTimeout(ringTimer);
+            calls.delete(pair);
+            if (notify)
+                send(notifyAs, why);
+            emitChange('ended');
+            changed.close();
+            resolveEnded(why);
+        }
+        function activate() {
+            if (state != 'ringing')
+                return;
+            state = 'active';
+            clearTimeout(ringTimer);
+            emitChange('active');
+        }
+        const handle = {
+            id: pair,
+            peer: other,
+            direction,
+            meta,
+            state: () => state,
+            reason: () => reason,
+            changed,
+            ended,
+            accept() {
+                if (direction != 'in' || state != 'ringing')
+                    return;
+                send('accept');
+                activate();
+            },
+            decline(why = 'declined') {
+                if (direction != 'in' || state != 'ringing')
+                    return;
+                finish(why, true, 'decline');
+            },
+            hangup() {
+                finish(state == 'ringing' && direction == 'out' ? 'canceled' : 'hangup', true);
+            },
+        };
+        return { handle, activate, finish };
+    }
+    function swallowSendError() { }
+    function hasLiveCall() {
+        for (const c of calls.values())
+            if (c.handle.state() != 'ended')
+                return true;
+        return false;
+    }
+    function call(other, meta) {
+        if (closed)
+            throw new Error('call manager is closed');
+        const pair = 'call:' + self + ':' + callScope + ':' + (++n);
+        const made = makeCall(pair, other, 'out', meta);
+        calls.set(pair, made);
+        Promise.resolve(port.send({ type: 'ring', pair, from: self, to: other, session: meta }))
+            .then(function onRingVerdict(accepted) {
+            if (accepted == false)
+                made.finish('offline', false);
+        }, function onRingSendError() { made.finish('offline', false); });
+        return made.handle;
+    }
+    async function onRing(env) {
+        if (calls.has(env.pair))
+            return;
+        evaluatingIncoming++;
+        const gate = incoming ?? function defaultBusyGate() {
+            return evaluatingIncoming == 1 && !hasLiveCall();
+        };
+        let allowed = false;
+        try {
+            allowed = !!(await gate({ peer: env.from, meta: env.session }));
+        }
+        catch {
+            allowed = false;
+        }
+        finally {
+            evaluatingIncoming--;
+        }
+        if (closed)
+            return;
+        if (!allowed) {
+            void Promise.resolve(port.send({ type: 'decline', pair: env.pair, from: self, to: env.from, reason: 'busy' })).catch(swallowSendError);
+            return;
+        }
+        const made = makeCall(env.pair, env.from, 'in', env.session);
+        calls.set(env.pair, made);
+        emitRing(made.handle);
+    }
+    const readyProbe = 'call-ready:' + self;
+    let resolveReady;
+    const ready = new Promise(r => { resolveReady = r; });
+    const offSignals = port.signals.on(function onCallSignal(env) {
+        if (closed || env == null || env.to != self)
+            return;
+        if (env.pair == readyProbe) {
+            resolveReady();
+            return;
+        }
+        if (env.type == 'ring') {
+            void onRing(env);
+            return;
+        }
+        const live = calls.get(env.pair);
+        if (!live)
+            return;
+        if (env.type == 'accept') {
+            live.activate();
+            return;
+        }
+        if (env.type == 'decline') {
+            live.finish(env.reason ?? 'declined', false);
+            return;
+        }
+        if (env.type == 'hangup') {
+            live.finish(live.handle.state() == 'ringing' ? 'canceled' : 'hangup', false);
+        }
+    });
+    Promise.resolve(port.send({ type: 'close', pair: readyProbe, from: self, to: self }))
+        .then(function onProbeVerdict(v) { if (v == false)
+        resolveReady(); }, function onProbeError() { resolveReady(); });
+    return {
+        ready,
+        call,
+        rings,
+        active: () => Array.from(calls.values()).map(c => c.handle).find(h => h.state() == 'active') ?? null,
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            if (typeof offSignals == 'function')
+                offSignals();
+            else
+                offSignals?.off?.();
+            for (const c of Array.from(calls.values()))
+                c.finish('closed', true);
+            rings.close();
+        },
+    };
+}

package/lib/Common/peer/peer-client.d.ts

@@ -2,7 +2,7 @@ import { StoreDrain, StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { RoutePolicy } from '../events/route-coordinator';
 import { RtcPeerConnection, SignalEnvelope } from '../events/route-signal-webrtc';
-import { PatchEnvelope } from './peer-relay';
+import { PatchEnvelope, RelayPushResult, tRelayGap } from './peer-relay';
 export type PeerRemote = {
     signal: {
         send: (env: SignalEnvelope) => Promise<boolean | void>;
@@ -10,10 +10,22 @@ export type PeerRemote = {
             on: (cb: (env: SignalEnvelope) => void) => any;
         };
     };
-    publish: (env: PatchEnvelope) => Promise<boolean | void> | boolean | void;
-    peers: Record<string, ReplayRemote<[StorePatch]>>;
+    publish: (env: PatchEnvelope) => Promise<RelayPushResult | void> | RelayPushResult | void;
+    peers: Record<string, ReplayRemote<[StorePatch]> & {
+        seq?: () => number | Promise<number>;
+    }>;
+    presence?: {
+        list: () => Promise<string[]> | string[];
+        changes: {
+            on: (cb: (change: {
+                account: string;
+                online: boolean;
+            }) => void) => any;
+        };
+    };
 };
-export type PeerClientDeps<T extends object> = {
+export type tPublishRepair<J extends tRelayGap = 'resume'> = J extends 'sacred' ? 'tail' : 'tail' | 'keyframe';
+export type PeerClientDeps<T extends object, J extends tRelayGap = 'resume'> = {
     remote: PeerRemote;
     account: string;
     initial: T;
@@ -22,10 +34,13 @@ export type PeerClientDeps<T extends object> = {
     accept?: (env: SignalEnvelope) => boolean | Promise<boolean>;
     policy?: RoutePolicy;
     peerInitial?: () => T;
+    journal?: J;
+    repair?: tPublishRepair<J>;
+    onPublishError?: (e: unknown) => void;
     history?: number;
     drain?: StoreDrain;
 };
-export declare function createPeerClient<T extends object>(deps: PeerClientDeps<T>): {
+export declare function createPeerClient<T extends object, J extends tRelayGap = 'resume'>(deps: PeerClientDeps<T, J>): {
     store: import("../Observe/store").Store<T>;
     peer: (other: string) => {
         account: string;
@@ -41,6 +56,7 @@ export declare function createPeerClient<T extends object>(deps: PeerClientDeps<
         close(): void;
     };
     onRoute: (cb: (ev: import("../events/route-coordinator").RouteChangeEvent) => void) => import("../..").ListenOff;
+    resync: () => Promise<void>;
     close(): void;
 };
 export type PeerClient<T extends object> = ReturnType<typeof createPeerClient<T>>;

package/lib/Common/peer/peer-client.js

@@ -7,15 +7,64 @@ const replay_wire_1 = require("../events/replay-wire");
 const route_coordinator_1 = require("../events/route-coordinator");
 const route_signal_webrtc_1 = require("../events/route-signal-webrtc");
 function createPeerClient(deps) {
-    const { remote, account, initial, rtc, session, accept, policy, peerInitial = () => ({}), history, drain, } = deps;
+    const { remote, account, initial, rtc, session, accept, policy, peerInitial = () => ({}), history, drain, journal = 'resume', onPublishError, } = deps;
+    const repair = deps.repair ?? 'tail';
     const store = (0, store_1.createStore)(initial, drain !== undefined ? { drain } : {});
     const exposed = (0, store_replay_1.exposeStoreReplay)(store, history !== undefined ? { history } : {});
+    let repairing = null;
+    function repairEnvelopes(from) {
+        const line = exposed.replay;
+        if (repair == 'tail' && from >= 0) {
+            const tail = line.getSince(from);
+            if (tail)
+                return tail;
+            if (journal == 'sacred') {
+                throw new Error('peer publish: local journal evicted seq ' + from + ', sacred relay is unrepairable — raise {history}');
+            }
+        }
+        const kf = exposed.replay.keyframe();
+        return kf ? [kf] : [];
+    }
+    async function runRepair(from) {
+        for (const env of repairEnvelopes(from)) {
+            const res = await remote.publish(env);
+            if (res != null && typeof res == 'object') {
+                throw new Error('peer publish: repair rejected at relay seq ' + res.seq);
+            }
+        }
+    }
+    function queueRepair(from) {
+        if (repairing)
+            return;
+        repairing = runRepair(from)
+            .catch(function reportRepairError(e) {
+            if (onPublishError)
+                onPublishError(e);
+            else
+                setTimeout(function rethrowRepairError() { throw e; }, 0);
+        })
+            .finally(() => { repairing = null; });
+    }
+    function handleVerdict(res) {
+        if (res != null && typeof res == 'object' && typeof res.seq == 'number')
+            queueRepair(res.seq);
+    }
     const offPublish = exposed.replay.line.on(function publishEnvelope(env) {
-        void remote.publish(env);
+        Promise.resolve(remote.publish(env)).then(handleVerdict, function onPublishReject(e) {
+            onPublishError?.(e);
+        });
     });
     const warmup = exposed.replay.keyframe();
     if (warmup)
-        void remote.publish(warmup);
+        Promise.resolve(remote.publish(warmup)).then(handleVerdict, e => onPublishError?.(e));
+    async function resync() {
+        const node = remote.peers[account];
+        const relaySeq = Number(await node?.seq?.() ?? -1);
+        const localSeq = exposed.replay.keyframe()?.seq ?? -1;
+        if (relaySeq >= localSeq)
+            return;
+        await runRepair(relaySeq);
+    }
     const port = {
         send: env => remote.signal.send(env),
         signals: { on: cb => remote.signal.signals.on(cb) },
@@ -96,6 +145,7 @@ function createPeerClient(deps) {
         store,
         peer,
         onRoute: coord.onRoute,
+        resync,
         close() {
             for (const view of Array.from(views.values()))
                 view.close();

package/lib/Common/peer/peer-host.d.ts

@@ -1,31 +1,48 @@
 import { StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { SignalEnvelope } from '../events/route-signal-webrtc';
-import { PatchEnvelope } from './peer-relay';
+import { PatchEnvelope, tRelayGap } from './peer-relay';
+export type PresenceChange = {
+    account: string;
+    online: boolean;
+};
 export type PeerHostDeps = {
     authorize?: (env: SignalEnvelope) => boolean | Promise<boolean>;
     history?: number;
+    gap?: tRelayGap;
+    accounts?: (account: string) => boolean;
 };
 export declare function createPeerHost(deps?: PeerHostDeps): {
     connection: (account: string) => {
         fragment: {
             signal: {
                 send: (env: SignalEnvelope) => Promise<boolean>;
-                signals: import("../..").ListenApi<[SignalEnvelope]>;
+                signals: import("../events/Listen").ListenApi<[SignalEnvelope]>;
             };
-            publish: (env: PatchEnvelope) => boolean;
+            publish: (env: PatchEnvelope) => import("./peer-relay").RelayPushResult;
             peers: Record<string, ReplayRemote<[StorePatch]>>;
+            presence: {
+                list: () => string[];
+                changes: import("../events/Listen").ListenApi<[PresenceChange]>;
+            };
         };
         close: () => void;
     };
     relay: (account: string) => {
-        push: (env: PatchEnvelope) => boolean;
-        remote: ReplayRemote<[StorePatch]>;
+        push: (env: PatchEnvelope) => import("./peer-relay").RelayPushResult;
+        remote: ReplayRemote<[StorePatch]> & {
+            seq: () => number;
+        };
+        gap: tRelayGap;
         seq: () => number;
         snapshot: () => any;
         close: () => void;
     };
     accounts: () => string[];
+    presence: {
+        list: () => string[];
+        changes: import("../events/Listen").ListenApi<[PresenceChange]>;
+    };
     revoke: (pair: string, accounts: string[], reason?: string) => void;
     close(): void;
 };

package/lib/Common/peer/peer-host.js

@@ -2,41 +2,85 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPeerHost = createPeerHost;
 const rpc_dynamic_1 = require("../rcp/rpc-dynamic");
+const Listen_1 = require("../events/Listen");
 const route_signal_webrtc_1 = require("../events/route-signal-webrtc");
 const peer_relay_1 = require("./peer-relay");
 function createPeerHost(deps = {}) {
-    const { authorize, history } = deps;
+    const { authorize, history, gap, accounts: accountAllowed } = deps;
     const hub = (0, route_signal_webrtc_1.createSignalHub)({ authorize });
     const relays = new Map();
-    const peersView = (0, rpc_dynamic_1.noStrict)({});
+    const peersMap = {};
+    const peersView = (0, rpc_dynamic_1.noStrict)(new Proxy(peersMap, {
+        has(_t, k) { return typeof k == 'string' && (!accountAllowed || accountAllowed(k)); },
+        get(t, k) {
+            if (typeof k != 'string')
+                return t[k];
+            if (accountAllowed && !accountAllowed(k))
+                return undefined;
+            return ensureRelay(k).remote;
+        },
+    }));
+    const online = new Map();
+    const [emitPresence, presenceChanges] = (0, Listen_1.listen)();
+    const presence = {
+        list: () => Array.from(online.keys()),
+        changes: presenceChanges,
+    };
+    function presenceJoin(account) {
+        const n = (online.get(account) ?? 0) + 1;
+        online.set(account, n);
+        if (n == 1)
+            emitPresence({ account, online: true });
+    }
+    function presenceLeave(account) {
+        const n = (online.get(account) ?? 0) - 1;
+        if (n > 0) {
+            online.set(account, n);
+            return;
+        }
+        online.delete(account);
+        emitPresence({ account, online: false });
+    }
     function ensureRelay(account) {
         let relay = relays.get(account);
         if (!relay) {
-            relay = (0, peer_relay_1.createPatchRelayJournal)({ history });
+            relay = (0, peer_relay_1.createPatchRelayJournal)({ history, gap });
             relays.set(account, relay);
-            peersView[account] = relay.remote;
+            peersMap[account] = relay.remote;
         }
         return relay;
     }
     function connection(account) {
         const port = hub.register(account);
         const mine = ensureRelay(account);
+        presenceJoin(account);
+        let closed = false;
         return {
             fragment: {
                 signal: { send: port.send, signals: port.signals },
                 publish: (env) => mine.push(env),
                 peers: peersView,
+                presence,
+            },
+            close: function closeConnection() {
+                if (closed)
+                    return;
+                closed = true;
+                port.close();
+                presenceLeave(account);
             },
-            close: () => port.close(),
         };
     }
     return {
         connection,
         relay: ensureRelay,
         accounts: () => Array.from(relays.keys()),
+        presence,
         revoke: hub.revoke,
         close() {
             hub.close();
+            presenceChanges.close();
+            online.clear();
             for (const relay of relays.values())
                 relay.close();
             relays.clear();

package/lib/Common/peer/peer-index.d.ts

@@ -1,3 +1,5 @@
 export * from './peer-relay';
 export * from './peer-host';
 export * from './peer-client';
+export * from './peer-media-relay';
+export * from './peer-call';

package/lib/Common/peer/peer-index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./peer-relay"), exports);
 __exportStar(require("./peer-host"), exports);
 __exportStar(require("./peer-client"), exports);
+__exportStar(require("./peer-media-relay"), exports);
+__exportStar(require("./peer-call"), exports);

package/lib/Common/peer/peer-media-relay.d.ts

@@ -0,0 +1,22 @@
+import { ListenReplayApi } from '../events/replay-listen';
+export type tMediaRelayKind = 'video' | 'audio';
+export type tCanWatch = (watcher: string, owner: string, line: string) => boolean;
+export type MediaRelayDeps = {
+    lines: Record<string, tMediaRelayKind>;
+    videoHistory?: number;
+    audioHistory?: number;
+    canWatch?: tCanWatch;
+};
+type tMediaFrame = [unknown, number];
+type tRelayLine = ListenReplayApi<tMediaFrame>;
+export declare function createMediaRelay(deps: MediaRelayDeps): {
+    publishOf: (account: string) => (line: string, frame: unknown, sentAt: number) => void;
+    watch: Record<string, Record<string, tRelayLine>>;
+    watchOf: (watcher: string) => Record<string, Record<string, tRelayLine>>;
+    lines: (account: string) => Record<string, tRelayLine>;
+    accounts: () => string[];
+    dropAccount: (account: string) => void;
+    close(): void;
+};
+export type MediaRelay = ReturnType<typeof createMediaRelay>;
+export {};