wenay-common2 1.0.73 → 1.0.74

package/doc/wenay-common2.md

@@ -201,6 +201,43 @@ failures surface via `onPublishError`, never silently. Policy/session material:
 contract and the underlying primitives (`createRouteCoordinator`, `createSignalHub`,
 `createWebRtcConnector`). Oracle: `replay/peer-sdk.test.ts`.
 
+### Calls, presence and the media relay (messenger-style, on the same parts)
+```
+// presence rides in the fragment (host >= 1.0.74): subscribe FIRST, then list()
+c.app.func.peer.presence.changes.on(({account, online}) => {})
+await c.app.func.peer.presence.list()                       // ['a', 'b', ...] — connected right now
+
+// SERVER — media relay next to the fragment (per-account named lines, policy-gated watch):
+const media = Peer.createMediaRelay({
+    lines: {cam: 'video', mic: 'audio', screen: 'video'},
+    canWatch?: (watcher, owner, line) => bool,   // ACL, checked on paths + every forwarded frame
+})
+object: {peer: peer.fragment, media: {publish: media.publishOf(account), watch: media.watchOf(account)}}
+media.dropAccount(account)   // retire lines + keyspace (e.g. on presence offline); next publish revives
+
+// CLIENT — calls are envelopes over the SAME signal port; media attach stays app code:
+const calls = Peer.createCallManager({port: Peer.callPortOf(c.app.func.peer), self: 'a'})
+await calls.ready                                           // signal subscription confirmed server-side
+calls.rings.on(call => { call.accept() /* or call.decline() */ })
+const call = calls.call('b', {kinds: ['cam', 'mic']})       // meta rides opaquely
+call.changed.on(state => {})                                // 'active' | 'ended'
+await call.ended                                            // 'declined'|'busy'|'offline'|'timeout'|'hangup'|'canceled'
+call.hangup()
+// while active: publish own frames + attach the peer's lines (Media.attach* viewers)
+media.publish('cam', frame, Date.now());  attachVideoCanvas(c.app.func.media.watch.b.cam, canvas)
+```
+Relay-first is the privacy default (mainstream messengers route calls through their servers too);
+`promoteDirect` stays the policy-gated opt-in for the data path. Ring/accept/decline/hangup ride the
+existing signal hub — the host `authorize` hook sees them too (single server-side policy point), and
+an offline callee fails fast (`'offline'`), no timeout wait. The default incoming gate auto-declines
+with `'busy'` during a live call, which also settles simultaneous cross-calls. `video` relay lines
+are keep-latest (late joiner pulls `keyframe()` instantly), `audio` is a short lossless queue; frames
+ride as `[frame, sentAt]` so viewer latency stats work out of the box. Watch access is an ACL, not a
+convention: `watchOf(account)` views run `canWatch` on every new subscribe/keyframe and every live
+frame. "Media access follows the call" is a few lines of app code (grant on `'active'`, revoke on
+`'ended'`); after revocation an already-open policy view receives no more data. Oracle:
+`replay/peer-call.test.ts`.
+
 ## 🔁 Observe — reactive state + store/mirror API
 > `import { Observe } from "wenay-common2"` or `import * as Observe from "wenay-common2/observe"`.
 > This is the documented v2 reactive/store surface.
@@ -391,6 +428,3 @@ facade — details in rare docs. New code should declare `frame` on the line ins
 Wire-level proof/oracles: `npx ts-node replay/rpc-auto.test.ts` (real Socket.IO: auto-exposure, legacy
 parity, frame equivalence, gate lag sim), plus `replay/conflate-socket.test.ts`, `replay/conflate.test.ts`,
 `replay/coalesce.test.ts`. Full generic surface (history/time-travel, archive) → 🎞️ in rare docs.
-
-
-

package/lib/Common/events/route-signal-webrtc.d.ts

@@ -1,7 +1,7 @@
 import { ReplayRemote } from './replay-wire';
 import { RouteConnector } from './route-coordinator';
 import { ReplayMessageChannel } from './replay-channel';
-export type tSignalType = 'offer' | 'answer' | 'ice' | 'revoke' | 'close';
+export type tSignalType = 'offer' | 'answer' | 'ice' | 'revoke' | 'close' | 'ring' | 'accept' | 'decline' | 'hangup';
 export type SignalEnvelope = {
     type: tSignalType;
     pair: string;

package/lib/Common/events/route-signal-webrtc.js

@@ -11,28 +11,38 @@ function createSignalHub(deps = {}) {
     const ports = new Map();
     function register(account) {
         const [emit, signals] = (0, Listen_1.listen)();
-        ports.set(account, emit);
+        const accountPorts = ports.get(account) ?? [];
+        accountPorts.push(emit);
+        ports.set(account, accountPorts);
         async function send(env) {
             if (env == null || env.from != account)
                 return false;
             if (authorize && !(await authorize(env)))
                 return false;
-            const target = ports.get(env.to);
+            const targets = ports.get(env.to);
+            const target = targets?.[targets.length - 1];
             if (!target)
                 return false;
             target(env);
             return true;
         }
         function close() {
-            if (ports.get(account) == emit)
-                ports.delete(account);
+            const accountPorts = ports.get(account);
+            if (accountPorts) {
+                const i = accountPorts.indexOf(emit);
+                if (i >= 0)
+                    accountPorts.splice(i, 1);
+                if (!accountPorts.length)
+                    ports.delete(account);
+            }
             signals.close();
         }
         return { account, send, signals, close };
     }
     function revoke(pair, accounts, reason) {
         for (const account of accounts) {
-            ports.get(account)?.({ type: 'revoke', pair, from: '', to: account, reason });
+            const accountPorts = ports.get(account);
+            accountPorts?.[accountPorts.length - 1]?.({ type: 'revoke', pair, from: '', to: account, reason });
         }
     }
     return {

package/lib/Common/media/media-view.d.ts

@@ -1,5 +1,5 @@
 type tMediaLine = {
-    on(cb: (frame: any, sentAt?: number) => void): () => void;
+    on(cb: (frame: any, sentAt?: number) => void): any;
 };
 export type AttachVideoCanvasOpts = {
     createBitmap?: (blob: any) => Promise<any>;
@@ -38,5 +38,5 @@ export type PipeMediaPublishOpts = {
     stamp?: boolean;
     onError?: (e: unknown) => void;
 };
-export declare function pipeMediaPublish(line: tMediaLine, publish: (frame: Uint8Array, sentAt?: number) => unknown, opts?: PipeMediaPublishOpts): () => void;
+export declare function pipeMediaPublish(line: tMediaLine, publish: (frame: Uint8Array, sentAt?: number) => unknown, opts?: PipeMediaPublishOpts): any;
 export {};

package/lib/Common/media/media-view.js

@@ -4,6 +4,25 @@ exports.attachVideoCanvas = attachVideoCanvas;
 exports.attachAudioPlayer = attachAudioPlayer;
 exports.pipeMediaPublish = pipeMediaPublish;
 const media_source_1 = require("./media-source");
+function makeOff(raw) {
+    function unsubscribe(h) {
+        if (typeof h == 'function')
+            h();
+        else
+            h?.off?.();
+    }
+    return function off() {
+        if (typeof raw == 'function') {
+            raw();
+            return;
+        }
+        if (raw != null && typeof raw.then == 'function') {
+            void raw.then(unsubscribe);
+            return;
+        }
+        unsubscribe(raw);
+    };
+}
 function mimeForCodec(codec) {
     if (codec == 'png')
         return 'image/png';
@@ -57,7 +76,7 @@ function attachVideoCanvas(line, canvas, opts = {}) {
     let width = 0;
     let height = 0;
     let busy = false;
-    const off = line.on(async function onVideoFrame(raw, sentAt) {
+    const off = makeOff(line.on(async function onVideoFrame(raw, sentAt) {
         frames++;
         age.note(sentAt);
         rate.note();
@@ -85,7 +104,7 @@ function attachVideoCanvas(line, canvas, opts = {}) {
         finally {
             busy = false;
         }
-    });
+    }));
     return {
         stats: () => ({ frames, drawn, perSec: rate.perSec, ageMs: age.ageMs, width, height }),
         off,
@@ -150,7 +169,7 @@ function attachAudioPlayer(line, opts = {}) {
         playhead = at + nFrames / sampleRate;
         played++;
     }
-    const off = line.on(function onAudioFrame(raw, sentAt) {
+    const off = makeOff(line.on(function onAudioFrame(raw, sentAt) {
         frames++;
         age.note(sentAt);
         rate.note();
@@ -162,7 +181,7 @@ function attachAudioPlayer(line, opts = {}) {
         catch (e) {
             opts.onError?.(e);
         }
-    });
+    }));
     return {
         enable() {
             audioCtx = audioCtx ?? makeContext();

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

@@ -14,6 +14,15 @@ export type PeerRemote = {
     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 tPublishRepair<J extends tRelayGap = 'resume'> = J extends 'sacred' ? 'tail' : 'tail' | 'keyframe';
 export type PeerClientDeps<T extends object, J extends tRelayGap = 'resume'> = {

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

@@ -2,20 +2,29 @@ import { StorePatch } from '../Observe/store';
 import { ReplayRemote } from '../events/replay-wire';
 import { SignalEnvelope } from '../events/route-signal-webrtc';
 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) => import("./peer-relay").RelayPushResult;
             peers: Record<string, ReplayRemote<[StorePatch]>>;
+            presence: {
+                list: () => string[];
+                changes: import("../events/Listen").ListenApi<[PresenceChange]>;
+            };
         };
         close: () => void;
     };
@@ -30,6 +39,10 @@ export declare function createPeerHost(deps?: PeerHostDeps): {
         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, gap } = 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, 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 {};