@tienne/gestalt 0.111.0 → 0.113.0

package/dist/src/peer/network.js

@@ -1,19 +1,68 @@
 import { randomBytes } from 'node:crypto';
 import { isRawKey } from './keys.js';
 import { MirrorFeed } from './mirror.js';
-import { checkRosterUpdate, decodeInvite, encodeInvite, formatShareLink, isAdmin, isPersonName, isRelayUrl, joinProofText, memberOf, nextRoster, parseShareLink, signRoster, } from './roster.js';
+import { checkRosterUpdate, decodeInvite, encodeInvite, formatShareLink, isAdmin, isPersonName, isRelayUrl, isShareId, joinProofText, memberOf, nextRoster, parseShareLink, signRoster, } from './roster.js';
 import { aeadOpen, aeadSeal, canonical, deriveKey, hmac, openBox, safeEqual, sealBox, } from './seal.js';
 import { RelayTransport } from './transport.js';
 import { MAX_VIEWERS_PER_SHARE, REPLAY_CHUNK_BYTES } from './viewer.js';
-import { errMessage } from './errors.js';
+import { errMessage, PeerNetworkError } from './errors.js';
+import { isMessageId, MESSAGE_RECEIVE_LIMIT, newMessageId, plainLabel, RateLimiter, sanitizeMessageBody, } from './message.js';
+import { RelaySendError } from './transport.js';
+import { DEFAULT_FIRST_WATCH_APPROVAL } from './protocol.js';
+import { PeekDesk } from './peeks.js';
+import { QuestionDesk } from './questions.js';
 /** 초대 유효 시간. 설계 원문의 24시간 */
 export const INVITE_TTL_MS = 24 * 60 * 60 * 1000;
 /** 원격 구독 하나가 릴레이 소켓에 밀어 둘 수 있는 양 */
 export const MAX_REMOTE_BUFFERED_BYTES = 8 * 1024 * 1024;
 const WATCH_TIMEOUT_MS = 10_000;
+/** 답이 없거나 다시 청하면 되는 거절을 받았을 때 다시 청하는 횟수와 간격 상한 */
+const MAX_REWATCH_RETRIES = 6;
+const MAX_REWATCH_DELAY_MS = 60_000;
 const WATCH_NONCE_TTL_MS = 10 * 60 * 1000;
 const MAX_SEEN_WATCH = 4096;
-export class PeerNetworkError extends Error {
+const MAX_SEEN_MESSAGES = 8192;
+const MAX_REFUSED_PER_SENDER = 256;
+const MAX_REFUSED_SENDERS = 1024;
+/** 첫 접속 승인을 기다리는 시한. 넘으면 보는 쪽에 approval_timeout으로 알린다 */
+export const APPROVAL_TTL_MS = 10 * 60 * 1000;
+/** 승인 대기를 알리는 시간. 이 동안은 긴 안내 문구를 붙이고 지나면 훅이 짧은 한 줄만 붙인다 */
+export const APPROVAL_NOTICE_MS = 60 * 1000;
+/** 끝난 보기를 `peer watches`에 남겨 두는 개수. 거절이나 kick으로 끝난 이유를 CLI에서 보게 한다 */
+const MAX_CLOSED_WATCHES = 16;
+/** 보는 쪽이 다시 청하지 않고 보기를 끝내는 거절 이유 */
+const FINAL_REFUSALS = new Set([
+    'not_found',
+    'bad_proof',
+    'kicked',
+    'denied',
+    'approval_timeout',
+    'share_closed',
+]);
+export { PeerNetworkError };
+/** 주인 데몬이 시한 안에 watch에 답하지 않았다 */
+export class WatchTimeout extends PeerNetworkError {
+}
+/** 주인 데몬이 watch를 거절했다. reason은 주인 데몬이 보낸 글자를 정리한 것이다 */
+export class WatchRefused extends PeerNetworkError {
+    reason;
+    constructor(reason) {
+        super(refusalText(reason));
+        this.reason = reason;
+    }
+}
+/** 거절 이유를 사람이 읽는 문장으로. 이유 글자는 끝에 괄호로 남겨 스크립트가 찾게 한다 */
+export function refusalText(reason) {
+    switch (reason) {
+        case 'denied':
+            return '주인이 거절했어요 (denied)';
+        case 'kicked':
+            return '주인이 이 공유에서 끊었어요 (kicked)';
+        case 'approval_timeout':
+            return '주인이 승인하지 않아 기다리다 끝났어요 (approval_timeout)';
+        default:
+            return `주인 데몬이 거절했어요: ${reason}`;
+    }
 }
 /**
  * 팀, 명단, 릴레이 통로, 원격 공유를 묶는다. 데몬이 하나 들고 있다.
@@ -36,12 +85,52 @@ export class PeerNetwork {
     announced = [];
     /** 최근 받은 watch 요청의 `기기|nonce`와 받은 시각. 릴레이가 옛 요청을 다시 보내면 거절한다 */
     seenWatch = new Map();
+    /** 받은 메시지의 `기기|id`. 릴레이가 같은 봉인을 다시 보내면 버린다 */
+    seenMessages = new Set();
+    /**
+     * 수신 한도로 거절한 메시지 id를 `공유|기기`마다 따로 기억한다. 창이 지난 뒤 릴레이가 같은
+     * 봉인을 다시 보내도 넣지 않는다. 공용 seenMessages에 넣으면 한 사람이 맞는 증명으로
+     * 쏟아부어 다른 팀원의 기억을 밀어낼 수 있어서 나눈다
+     */
+    refusedMessages = new Map();
+    sendLimiter = new RateLimiter();
+    /** 보는 쪽이 12건으로 먼저 막는다. 주인 쪽은 릴레이에 쌓였다 한꺼번에 온 것도 받게 넉넉하다 */
+    receiveLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
     maxBuffered;
+    approvalTtl;
+    approvalNotice;
+    /**
+     * 주인 쪽 통제 상태. 전부 공유가 열려 있는 동안만 메모리에 둔다. 공유는 데몬이 다시 뜨면
+     * 닫히므로 DB에 남길 필요가 없고 forgetShare가 공유를 닫을 때 같이 버린다.
+     * - pending: 첫 접속 승인을 기다리는 요청. 키는 `공유|기기`
+     * - approved: 공유마다 받아 준 기기
+     * - blocked: 공유마다 끊거나 거절한 기기. 공유가 열려 있는 동안 다시 못 붙고 메시지도 못 넣는다
+     */
+    pending = new Map();
+    approved = new Map();
+    /** 첫 접속 설정. 메시지마다 읽으므로 DB가 아니라 메모리에 두고 setFirstWatch로만 바꾼다 */
+    firstWatchMode;
+    /** 거절 답과 감사 행을 쓰는 양의 상한. 끊긴 사람이 새 id로 계속 보내도 디스크와 릴레이를 못 채운다 */
+    rejectLimiter = new RateLimiter(MESSAGE_RECEIVE_LIMIT);
+    blocked = new Map();
+    closedWatches = [];
+    /** 질문과 답. 주인 쪽 열린 질문도 여기 있다 */
+    questions;
+    /** 요약 요청과 답. 주인 쪽 알림과 보는 쪽 대기 요청도 여기 있다 */
+    peeks;
     constructor(options) {
         this.options = options;
         this.team = options.state.getTeam();
         this.roster = options.state.getRoster();
         this.maxBuffered = options.maxBufferedBytes ?? MAX_REMOTE_BUFFERED_BYTES;
+        this.approvalTtl = options.approvalTtlMs ?? APPROVAL_TTL_MS;
+        this.approvalNotice = options.approvalNoticeMs ?? APPROVAL_NOTICE_MS;
+        this.questions = new QuestionDesk(this.questionHost());
+        this.peeks = new PeekDesk(this.peekHost(), {
+            noticeMs: options.peekNoticeMs,
+            timeoutMs: options.peekTimeoutMs,
+        });
+        this.firstWatchMode = options.state.getSettings().firstWatch ?? DEFAULT_FIRST_WATCH_APPROVAL;
     }
     get key() {
         return this.options.key;
@@ -52,6 +141,16 @@ export class PeerNetwork {
             this.connect();
     }
     async stop() {
+        for (const p of this.pending.values()) {
+            clearTimeout(p.timer);
+            clearTimeout(p.shorten);
+        }
+        this.pending.clear();
+        this.questions.stop();
+        this.peeks.stop();
+        for (const w of this.watches.values())
+            if (w.retry)
+                clearTimeout(w.retry);
         for (const s of [...this.subs.values()])
             this.endSub(s, 'daemon_stop', false);
         for (const w of [...this.watches.values()])
@@ -145,8 +244,15 @@ export class PeerNetwork {
      */
     async join(code, timeoutMs = 60_000) {
         const invite = decodeInvite(code);
-        if (this.team && this.roster && memberOf(this.roster.roster, this.key.id)) {
-            throw new PeerNetworkError(`이미 팀에 들어 있어요 (${this.team.team})`);
+        // 명단에서 빠지면 릴레이가 바로 끊어서 새 명단을 못 받는다. 그래서 들고 있는 명단에는 아직 내가
+        // 있다. 릴레이가 removed로 끊었으면 같은 팀, 같은 관리자의 재초대만 받는다. removed는 릴레이가
+        // 정하는 값이라 이걸로 다른 팀에 옮겨 가는 길까지 열지 않는다
+        const removed = this.transport?.state === 'removed';
+        const rejoin = removed && this.team?.team === invite.team && this.team.anchor === invite.admin;
+        if (this.team && this.roster && memberOf(this.roster.roster, this.key.id) && !rejoin) {
+            throw new PeerNetworkError(removed
+                ? `명단에서 빠진 팀(${this.team.team})의 관리자가 새로 만든 초대로만 다시 들어올 수 있어요`
+                : `이미 팀에 들어 있어요 (${this.team.team})`);
         }
         if (Date.now() >= invite.expiresAt)
             throw new PeerNetworkError('초대 코드가 만료됐어요');
@@ -235,6 +341,10 @@ export class PeerNetwork {
         this.transport?.publishRoster(signed);
         return { removed, epoch: signed.roster.epoch };
     }
+    /** 팀에서 쓰는 내 이름. 팀이 없으면 undefined */
+    get person() {
+        return this.team?.person;
+    }
     /** 내 공유의 링크. 팀이 없으면 undefined */
     linkFor(shareId, shareKey) {
         if (!this.roster)
@@ -248,16 +358,41 @@ export class PeerNetwork {
     }
     lookupWatch(id) {
         const w = this.watches.get(id);
-        return w ? { stream: w.feed, token: w.token } : undefined;
+        if (!w)
+            return undefined;
+        return {
+            stream: w.feed,
+            token: w.token,
+            owner: w.feed.ownerPerson,
+            share: w.share,
+            answer: (question, text) => this.questions.answer(id, question, text).then((r) => ({ ok: true, question: r.question }), (err) => ({ ok: false, error: errMessage(err) })),
+            // 승인을 기다리는 동안 연 뷰어도 받아 준 뒤에 입력창이 있어야 한다. 페이지는 열 때 한 번
+            // 그려지므로 기다리는 중에는 입력창을 두고 보내기는 sendMessage가 막는다
+            ...(w.messages || w.feed.currentStatus === 'waiting'
+                ? {
+                    send: (text) => this.sendMessage(id, text, 'human').then((r) => ({ ok: true, id: r.id }), (err) => ({ ok: false, error: errMessage(err) })),
+                }
+                : {}),
+        };
     }
+    /** 보고 있는 공유와 최근에 끝난 보기. 끝난 것은 closed에 이유가 있다 */
     listWatches() {
-        return [...this.watches.values()].map((w) => ({
+        const live = [...this.watches.values()].map((w) => ({
             id: w.id,
             share: w.share,
             owner: w.feed.ownerPerson,
             status: w.feed.currentStatus,
             events: w.feed.eventCount,
         }));
+        const ended = this.closedWatches.map((c) => ({
+            id: c.id,
+            share: c.share,
+            owner: c.owner,
+            status: 'closed',
+            events: c.events,
+            closed: c.reason,
+        }));
+        return [...live, ...ended];
     }
     /** 링크로 원격 공유를 보기 시작한다. 주인 데몬이 받아 줄 때까지 기다린다 */
     async watch(link) {
@@ -288,23 +423,27 @@ export class PeerNetwork {
             shareKey: Buffer.from(parsed.shareKey, 'base64url'),
             owner,
             feed: new MirrorFeed(id, owner, ownerMember.person, parsed.shareId),
+            messages: false,
+            retries: 0,
         };
         this.watches.set(id, w);
+        let waiting;
         try {
-            await this.requestWatch(w);
+            waiting = (await this.requestWatch(w)) === 'waiting';
         }
         catch (err) {
             this.watches.delete(id);
             w.feed.close('watch_failed');
             throw err;
         }
-        this.options.state.audit('watch_open', null, JSON.stringify({ watch: id, share: w.share, owner: ownerMember.person }));
-        return { id, share: w.share, owner: ownerMember.person, feed: w.feed, token: w.token };
+        this.options.state.audit('watch_open', null, JSON.stringify({ watch: id, share: w.share, owner: ownerMember.person, waiting }));
+        return { id, share: w.share, owner: ownerMember.person, feed: w.feed, token: w.token, waiting };
     }
     unwatch(id) {
         const w = this.watches.get(id);
         if (!w)
             return false;
+        // 승인을 기다리는 중이면 sub가 없다. 그때 주인에게 알리는 건 closeWatch가 watch_cancel로 한다
         if (w.sub)
             this.sendBox(w.owner, { t: 'unwatch', share: w.share, sub: w.sub });
         this.closeWatch(w, 'unwatch');
@@ -411,6 +550,17 @@ export class PeerNetwork {
             if (!memberOf(r, sub.watcher))
                 this.endSub(sub, 'removed', false);
         }
+        for (const [key, p] of [...this.pending]) {
+            if (!memberOf(r, p.watcher))
+                this.dropApproval(key);
+        }
+        // 빠진 기기가 같은 키로 다시 초대돼 와도 묻지 않고 붙지 않게 승인은 지운다. 막은 목록은
+        // 공유가 닫힐 때까지 둔다. 지우면 kick한 기기가 다시 들어와 풀린다
+        for (const map of this.approved.values()) {
+            for (const machine of [...map.keys()])
+                if (!memberOf(r, machine))
+                    map.delete(machine);
+        }
         for (const w of [...this.watches.values()]) {
             if (!memberOf(r, w.owner))
                 this.closeWatch(w, 'owner_removed');
@@ -462,19 +612,291 @@ export class PeerNetwork {
                 return this.onWatchRequest(from, msg);
             case 'watch_ok':
             case 'watch_err':
+            case 'watch_wait':
                 return this.onWatchReply(from, msg);
             case 'watch_end':
                 return this.onWatchEnd(from, msg);
+            case 'watch_cancel':
+                return this.onWatchCancel(from, msg);
             case 'unwatch': {
                 const sub = this.subs.get(msg.sub);
                 if (sub && sub.watcher === from)
                     this.endSub(sub, 'unwatch', false);
                 return;
             }
+            case 'msg':
+                return void this.onMessageRequest(from, msg).catch((err) => {
+                    process.stderr.write(`[peer] message failed: ${errMessage(err)}\n`);
+                });
+            case 'msg_status':
+                return this.onMessageStatus(from, msg);
+            case 'ask':
+            case 'ask_close':
+            case 'answer':
+            case 'answer_status':
+                return this.questions.receive(from, msg);
+            case 'peek':
+            case 'peek_reply':
+                return this.peeks.receive(from, msg);
             default:
                 return;
         }
     }
+    /**
+     * 보는 쪽: 원격 공유 주인 세션에 메시지를 보낸다. 주인 데몬이 오프라인이면 릴레이가 7일까지
+     * 들고 있는다. 상태는 보기의 MirrorFeed에 쌓여 뷰어로 간다.
+     */
+    async sendMessage(watchId, raw, origin = 'human') {
+        const w = this.watches.get(watchId);
+        if (!w)
+            throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${watchId}`);
+        if (w.feed.currentStatus === 'waiting')
+            throw new PeerNetworkError('주인 승인을 기다리는 중이라 아직 메시지를 못 보내요');
+        if (!w.messages)
+            throw new PeerNetworkError('이 공유는 주인이 메시지를 받지 않게 열었어요');
+        const clean = sanitizeMessageBody(raw);
+        if (!clean.ok)
+            throw new PeerNetworkError(clean.reason);
+        const member = this.roster ? memberOf(this.roster.roster, w.owner) : undefined;
+        const t = this.transport;
+        if (!member)
+            throw new PeerNetworkError('공유 주인이 명단에 없어요');
+        if (!t || t.state !== 'online')
+            throw new PeerNetworkError('릴레이에 안 붙어 있어요');
+        // 보내기 직전에 센다. 명단이나 연결 때문에 못 보낸 시도는 한도를 안 깎는다.
+        // 주인 쪽 수신 한도는 MESSAGE_RECEIVE_LIMIT로 따로 정한다
+        if (!this.sendLimiter.take(`${w.share}|${w.owner}`)) {
+            throw new PeerNetworkError('메시지를 너무 자주 보냈어요. 10분에 12건까지예요');
+        }
+        const id = newMessageId();
+        const body = {
+            t: 'msg',
+            share: w.share,
+            id,
+            body: clean.text,
+            origin,
+            proof: hmac(w.shareKey, messageProofText(w.share, this.key.id, id, clean.text)),
+        };
+        // 릴레이 답보다 주인 데몬의 상태가 먼저 올 수 있어서 레코드를 미리 둔다. 알리는 건 답을 받은 뒤다
+        w.feed.reserveMessage(id, clean.text, Date.now());
+        const box = sealBox(this.key, w.owner, member.boxKey, JSON.stringify(body));
+        let result;
+        try {
+            result = await t.send(w.owner, Buffer.from(JSON.stringify(box)), { queue: true });
+        }
+        catch (err) {
+            const reason = err instanceof RelaySendError ? err.reason : errMessage(err);
+            w.feed.setMessage(id, { status: 'rejected', reason });
+            throw new PeerNetworkError(`메시지를 못 보냈어요: ${errMessage(err)}`);
+        }
+        w.feed.setMessage(id, { status: result === 'queued' ? 'queued' : 'sent' });
+        return { id, status: w.feed.getMessage(id)?.status ?? 'sent' };
+    }
+    listMessages(watchId) {
+        const w = this.watches.get(watchId);
+        if (!w)
+            throw new PeerNetworkError(`보고 있는 공유가 아니에요: ${watchId}`);
+        return w.feed.messages;
+    }
+    /** 주인 쪽: 받은 메시지를 검사하고 주인 세션 인박스에 쓴다 */
+    async onMessageRequest(from, msg) {
+        // 꼴이 틀린 공유 id는 감사 로그와 CLI 출력으로 흘러가지 않게 답 없이 버린다
+        if (!isShareId(msg.share) || !isMessageId(msg.id))
+            return;
+        // 릴레이가 같은 봉인을 다시 보내면 한 번만 넣는다. 기억은 검사를 다 통과한 뒤에 한다.
+        // 앞에서 기억하면 증명 없는 가짜 id로 칸을 밀어내 옛 봉인을 다시 넣게 할 수 있다
+        const dedupe = `${from}|${msg.id}`;
+        const sender = `${msg.share}|${from}`;
+        if (this.seenMessages.has(dedupe) || this.refusedMessages.get(sender)?.has(msg.id))
+            return;
+        const status = (s, reason) => {
+            this.sendBox(from, {
+                t: 'msg_status',
+                share: msg.share,
+                id: msg.id,
+                status: s,
+                ...(reason ? { reason } : {}),
+            });
+        };
+        const person = this.personOf(from);
+        const reject = (reason) => {
+            // 거절은 증명 없이도 탈 수 있는 길이 있어서 보낸 기기마다 상한을 둔다. 넘으면 답도 기록도 없이 버린다
+            if (!this.rejectLimiter.take(from))
+                return;
+            status('rejected', reason);
+            this.options.state.audit('message_reject', msg.share, JSON.stringify({ id: msg.id, person, reason }));
+        };
+        const owned = this.options.lookupShare(msg.share);
+        if (!owned || owned.stream.isClosed)
+            return reject('share_closed');
+        if (typeof msg.body !== 'string' || typeof msg.proof !== 'string')
+            return reject('bad_frame');
+        const expected = hmac(Buffer.from(owned.shareKey, 'base64url'), messageProofText(msg.share, from, msg.id, msg.body));
+        if (!safeEqual(msg.proof, expected))
+            return reject('bad_proof');
+        // 메시지는 구독이 아니라 링크 증명으로 받아서 구독을 끊어도 링크는 남는다. 끊거나 거절한 사람과
+        // 아직 안 받아 준 사람은 여기서 막는다. 릴레이가 들고 있다 나중에 넘긴 봉인도 같은 규칙을 탄다
+        const refusal = this.messageRefusal(msg.share, from);
+        if (refusal) {
+            this.rememberRefused(sender, msg.id);
+            return reject(refusal);
+        }
+        const clean = sanitizeMessageBody(msg.body);
+        if (!clean.ok)
+            return reject(clean.reason);
+        if (!this.receiveLimiter.take(sender)) {
+            this.rememberRefused(sender, msg.id);
+            return reject('rate_limited');
+        }
+        const deliver = owned.deliver;
+        if (!deliver)
+            return reject('messages_off');
+        // deliver의 첫 await 전에 기억해야 동시에 온 같은 봉인이 둘 다 들어가지 않는다
+        this.seenMessages.add(dedupe);
+        if (this.seenMessages.size > MAX_SEEN_MESSAGES) {
+            const oldest = this.seenMessages.values().next().value;
+            if (oldest !== undefined)
+                this.seenMessages.delete(oldest);
+        }
+        const origin = msg.origin === 'agent' ? 'agent' : 'human';
+        this.options.state.audit('message_receive', msg.share, JSON.stringify({ id: msg.id, person, origin, bytes: Buffer.byteLength(clean.text) }));
+        status('arrived');
+        const inbound = {
+            kind: 'message',
+            id: msg.id,
+            share: msg.share,
+            from,
+            person,
+            origin,
+            body: clean.text,
+        };
+        const result = await this.insertInbound(deliver, inbound, {
+            inserted: (maybeWritten) => {
+                status('inserted');
+                this.options.state.audit('message_insert', msg.share, JSON.stringify({ id: msg.id, person, ...(maybeWritten ? { maybeWritten: true } : {}) }));
+            },
+            delivered: () => {
+                status('delivered');
+                this.options.state.audit('message_deliver', msg.share, JSON.stringify({ id: msg.id, person }));
+            },
+        });
+        if (!result.ok && !result.maybeWritten)
+            reject(result.reason);
+    }
+    /**
+     * 검사를 마친 메시지나 답을 주인 세션 인박스에 넣는다. 메시지와 답이 같이 쓴다. 들어갔는지 지켜보는
+     * 일은 deliver가 쓰기 전에 걸어 둔다. 그래서 쓰기가 끝나기 전에 보일 수 있고 그때는 inserted를 먼저
+     * 부른 뒤 delivered를 부른다. 소켓에 붙은 뒤 실패했으면 줄이 들어갔을 수 있다. 거절로 알리면 보낸
+     * 사람이 다시 보내 겹칠 수 있어서 inserted로 보고 대화 기록에 보이면 delivered로 올린다. deliver가
+     * 던지면 deliver_failed로 돌려준다. 넣지 못했을 때 무엇을 할지는 부르는 쪽이 정한다.
+     */
+    async insertInbound(deliver, inbound, on) {
+        let inserted = false;
+        let seenEarly = false;
+        let result;
+        try {
+            result = await deliver(inbound, () => {
+                if (inserted)
+                    on.delivered();
+                else
+                    seenEarly = true;
+            });
+        }
+        catch (err) {
+            process.stderr.write(`[peer] ${inbound.kind} deliver failed: ${errMessage(err)}\n`);
+            return { ok: false, reason: 'deliver_failed' };
+        }
+        if (!result.ok && !result.maybeWritten)
+            return result;
+        on.inserted(!result.ok);
+        inserted = true;
+        if (seenEarly)
+            on.delivered();
+        return result;
+    }
+    rememberRefused(sender, id) {
+        let ids = this.refusedMessages.get(sender);
+        if (!ids) {
+            ids = new Set();
+            this.refusedMessages.set(sender, ids);
+            if (this.refusedMessages.size > MAX_REFUSED_SENDERS) {
+                const oldest = this.refusedMessages.keys().next().value;
+                if (oldest !== undefined)
+                    this.refusedMessages.delete(oldest);
+            }
+        }
+        ids.add(id);
+        if (ids.size > MAX_REFUSED_PER_SENDER) {
+            const oldest = ids.values().next().value;
+            if (oldest !== undefined)
+                ids.delete(oldest);
+        }
+    }
+    /** 보는 쪽: 주인 데몬이 알려 온 상태를 반영한다 */
+    onMessageStatus(from, msg) {
+        if (!isMessageId(msg.id) || !isMessageStatus(msg.status))
+            return;
+        for (const w of this.watches.values()) {
+            if (w.owner !== from || w.share !== msg.share || !w.feed.getMessage(msg.id))
+                continue;
+            // 주인 데몬이 보낸 글자라 CLI 터미널에 찍히기 전에 제어 문자를 지운다
+            const reason = plainLabel(msg.reason);
+            w.feed.setMessage(msg.id, { status: msg.status, ...(reason ? { reason } : {}) });
+        }
+    }
+    /** 주인 쪽: 주인 세션 모델의 질문을 보낸다. 자세한 건 QuestionDesk.ask */
+    ask(shares, raw, to, ttlMs) {
+        return this.questions.ask(shares, raw, to, ttlMs);
+    }
+    questionHost() {
+        return {
+            state: this.options.state,
+            key: this.options.key,
+            sendBox: (to, msg) => this.sendBox(to, msg),
+            subs: () => this.subs.values(),
+            watches: () => this.watches.values(),
+            watch: (id) => this.watches.get(id),
+            personOf: (machine) => this.personOf(machine),
+            machinesOf: (person) => this.machinesOf(person),
+            refusal: (share, from) => this.messageRefusal(share, from),
+            takeReject: (from) => this.rejectLimiter.take(from),
+            lookupShare: (id) => this.options.lookupShare(id),
+            insertInbound: (deliver, inbound, on) => this.insertInbound(deliver, inbound, on),
+            prepareSend: (owner, msg) => this.prepareSealed(owner, msg, true),
+        };
+    }
+    /** 보는 쪽: 보고 있는 공유의 요약을 주인 데몬에 청한다. 자세한 건 PeekDesk.peek */
+    peek(target, since) {
+        return this.peeks.peek(target, since);
+    }
+    peekHost() {
+        return {
+            state: this.options.state,
+            key: this.options.key,
+            sendBox: (to, msg) => this.sendBox(to, msg),
+            watches: () => this.watches.values(),
+            prepareDirect: (owner, msg) => this.prepareSealed(owner, msg, false),
+            personOf: (machine) => this.personOf(machine),
+            refusal: (share, from) => this.messageRefusal(share, from),
+            takeReject: (from) => this.rejectLimiter.take(from),
+            lookupShare: (id) => this.options.lookupShare(id),
+            changed: () => this.changed(),
+        };
+    }
+    /**
+     * 그 기기에 보낼 봉인을 지금 만든다. 명단에 없거나 릴레이에 안 붙어 있으면 바로 던진다. 돌려준 함수가
+     * 보낸다. queue면 받는 기기가 오프라인일 때 릴레이가 들고 있는다
+     */
+    prepareSealed(to, msg, queue) {
+        const member = this.roster ? memberOf(this.roster.roster, to) : undefined;
+        const t = this.transport;
+        if (!member)
+            throw new PeerNetworkError('공유 주인이 명단에 없어요');
+        if (!t || t.state !== 'online')
+            throw new PeerNetworkError('릴레이에 안 붙어 있어요');
+        const sealed = sealBox(this.key, to, member.boxKey, JSON.stringify(msg));
+        return () => t.send(to, Buffer.from(JSON.stringify(sealed)), queue ? { queue: true } : {});
+    }
     onJoinRequest(from, data) {
         try {
             this.handleJoin(from, data);
@@ -550,20 +972,40 @@ export class PeerNetwork {
         }
         if (!this.rememberWatchNonce(from, msg.nonce))
             return reply('replay');
+        const block = this.blocked.get(msg.share)?.get(from);
+        if (block)
+            return reply(block);
+        const after = Number.isSafeInteger(msg.after) && msg.after > 0 ? msg.after : 0;
+        // 승인은 salt와 세션 키를 정하기 전에 본다. 키를 보낸 뒤에 막으면 보는 쪽이 이미 대화를 열어 읽을 수 있다
+        if (!this.approved.get(msg.share)?.has(from)) {
+            if (this.firstWatchMode === 'ask') {
+                return this.holdForApproval(from, msg.share, msg.nonce, after);
+            }
+            // 기다리는 사이 설정을 team으로 바꿨으면 남은 대기를 치운다. 안 치우면 목록과 훅에 계속 보인다
+            this.dropApproval(`${msg.share}|${from}`);
+            this.grant(msg.share, from, 'team');
+        }
+        this.startSub(from, msg.share, msg.nonce, after, owned);
+    }
+    /** 받아 준 사람의 구독을 연다. 공유 세션 키는 여기서 처음 정한다 */
+    startSub(from, share, nonce, after, owned) {
         // 같은 사람이 다시 청하면 앞의 구독을 바꾼다. 보는 쪽이 모르는 교체일 수 있어서 알린다
         for (const s of [...this.subs.values()]) {
-            if (s.watcher === from && s.share === msg.share)
+            if (s.watcher === from && s.share === share)
                 this.endSub(s, 'replaced', true);
         }
-        if (owned.stream.viewerCount >= MAX_VIEWERS_PER_SHARE)
-            return reply('too_many');
+        if (owned.stream.viewerCount >= MAX_VIEWERS_PER_SHARE) {
+            this.sendBox(from, { t: 'watch_err', share, nonce, reason: 'too_many' });
+            return;
+        }
         const sub = randomBytes(9).toString('base64url');
         const salt = randomBytes(32);
+        const shareKey = Buffer.from(owned.shareKey, 'base64url');
         const remote = {
             sub,
-            share: msg.share,
+            share,
             watcher: from,
-            key: streamKey(shareKey, salt, msg.share, from, sub),
+            key: streamKey(shareKey, salt, share, from, sub),
             stream: owned.stream,
             unsubscribe: () => { },
             ended: false,
@@ -571,14 +1013,281 @@ export class PeerNetwork {
         this.subs.set(sub, remote);
         this.sendBox(from, {
             t: 'watch_ok',
-            share: msg.share,
-            nonce: msg.nonce,
+            share,
+            nonce,
             sub,
             salt: salt.toString('base64url'),
+            messages: owned.deliver !== undefined,
         });
-        const person = this.roster ? memberOf(this.roster.roster, from)?.person : undefined;
-        this.options.state.audit('remote_watch', msg.share, JSON.stringify({ person: person ?? null, sub }));
-        this.pump(remote, Number.isSafeInteger(msg.after) && msg.after > 0 ? msg.after : 0);
+        this.options.state.audit('remote_watch', share, JSON.stringify({ person: this.personOf(from), sub }));
+        this.changed();
+        this.pump(remote, after);
+    }
+    /**
+     * 첫 접속을 주인이 받아 줄 때까지 붙잡아 둔다. 보는 쪽에는 watch_wait로 알린다. 같은 사람이
+     * 다시 청하면(주인이나 보는 쪽이 릴레이에 다시 붙은 경우) 시한은 그대로 두고 nonce만 바꾼다.
+     */
+    holdForApproval(from, share, nonce, after) {
+        const key = `${share}|${from}`;
+        let p = this.pending.get(key);
+        if (p) {
+            p.nonce = nonce;
+            p.after = after;
+        }
+        else {
+            let waiting = 0;
+            for (const q of this.pending.values())
+                if (q.share === share)
+                    waiting++;
+            if (waiting >= MAX_VIEWERS_PER_SHARE) {
+                this.sendBox(from, { t: 'watch_err', share, nonce, reason: 'too_many' });
+                return;
+            }
+            const at = Date.now();
+            const timer = setTimeout(() => this.expireApproval(key), this.approvalTtl);
+            timer.unref();
+            // 긴 안내 문구는 처음 한동안만 붙이고 그 뒤로는 짧게 줄인다. 시각 비교는 타이머가 몇 ms 일찍
+            // 울리면 어긋나서 울린 사실을 표시로 남기고 훅 파일을 다시 쓴다
+            const shorten = setTimeout(() => {
+                const q = this.pending.get(key);
+                if (!q)
+                    return;
+                q.brief = true;
+                this.changed();
+            }, this.approvalNotice);
+            shorten.unref();
+            p = {
+                share,
+                watcher: from,
+                nonce,
+                after,
+                at,
+                expiresAt: at + this.approvalTtl,
+                timer,
+                shorten,
+                brief: false,
+            };
+            this.pending.set(key, p);
+            this.options.state.audit('approval_request', share, JSON.stringify({ person: this.personOf(from) }));
+            this.changed();
+        }
+        this.sendBox(from, { t: 'watch_wait', share, nonce, expiresAt: p.expiresAt });
+    }
+    /**
+     * 승인 대기 하나를 치운다. 타이머 둘을 풀고 훅 파일을 다시 쓰게 한다. reason을 주면 보는 쪽에
+     * 그 이유로 거절을 알린다. 치운 대기를 돌려준다.
+     */
+    dropApproval(key, reason) {
+        const p = this.pending.get(key);
+        if (!p)
+            return undefined;
+        clearTimeout(p.timer);
+        clearTimeout(p.shorten);
+        this.pending.delete(key);
+        if (reason) {
+            this.sendBox(p.watcher, { t: 'watch_err', share: p.share, nonce: p.nonce, reason });
+        }
+        this.changed();
+        return p;
+    }
+    expireApproval(key) {
+        const p = this.dropApproval(key, 'approval_timeout');
+        if (!p)
+            return;
+        try {
+            this.options.state.audit('approval_expire', p.share, JSON.stringify({ person: this.personOf(p.watcher) }));
+        }
+        catch {
+            // 데몬이 멈추는 중이면 DB가 이미 닫혔을 수 있다
+        }
+    }
+    /** 보는 쪽이 승인을 기다리다 그만뒀다. 그 요청의 nonce가 맞을 때만 치운다 */
+    onWatchCancel(from, msg) {
+        if (typeof msg.share !== 'string' || typeof msg.nonce !== 'string')
+            return;
+        const key = `${msg.share}|${from}`;
+        // 릴레이가 옛 취소를 다시 보내도 그 뒤에 새로 청한 대기는 안 지워진다
+        if (this.pending.get(key)?.nonce !== msg.nonce)
+            return;
+        const p = this.dropApproval(key);
+        this.options.state.audit('approval_cancel', p.share, JSON.stringify({ person: this.personOf(from) }));
+    }
+    grant(share, machine, by) {
+        let map = this.approved.get(share);
+        if (!map) {
+            map = new Map();
+            this.approved.set(share, map);
+        }
+        map.set(machine, by);
+        this.options.state.audit('approval_grant', share, JSON.stringify({ person: this.personOf(machine), by }));
+    }
+    block(share, machine, reason) {
+        let map = this.blocked.get(share);
+        if (!map) {
+            map = new Map();
+            this.blocked.set(share, map);
+        }
+        map.set(machine, reason);
+        this.approved.get(share)?.delete(machine);
+    }
+    /** 이 공유로 이 기기가 보낸 메시지를 막을 이유. 받을 수 있으면 undefined */
+    messageRefusal(share, from) {
+        const block = this.blocked.get(share)?.get(from);
+        if (block)
+            return block;
+        if (this.firstWatchMode === 'ask' && !this.approved.get(share)?.has(from)) {
+            return 'not_approved';
+        }
+        return undefined;
+    }
+    /**
+     * 첫 접속 설정을 바꾼다. ask로 조이면 팀 설정으로 들어온 사람의 승인을 거두고 구독을 끝낸다.
+     * 보는 쪽은 approval_revoked를 받고 다시 청해 승인 대기에 오른다. 거둔 구독 수를 돌려준다.
+     */
+    setFirstWatch(mode) {
+        this.firstWatchMode = mode;
+        if (mode !== 'ask')
+            return 0;
+        let revoked = 0;
+        for (const [share, map] of this.approved) {
+            const machines = [...map].filter(([, by]) => by === 'team').map(([m]) => m);
+            if (machines.length === 0)
+                continue;
+            for (const m of machines)
+                map.delete(m);
+            for (const sub of [...this.subs.values()]) {
+                if (sub.share !== share || !machines.includes(sub.watcher))
+                    continue;
+                this.endSub(sub, 'approval_revoked', true);
+                revoked++;
+            }
+            this.options.state.audit('approval_revoke', share, JSON.stringify({ persons: unique(machines.map((m) => this.personOf(m))) }));
+        }
+        this.changed();
+        return revoked;
+    }
+    /** 명단의 이름을 한 줄 라벨로. 감사 로그와 CLI, 훅 출력으로 나간다 */
+    personOf(machine) {
+        const person = this.roster ? memberOf(this.roster.roster, machine)?.person : undefined;
+        return plainLabel(person, 32) ?? '?';
+    }
+    machinesOf(person) {
+        if (!this.roster)
+            throw new PeerNetworkError('아직 팀에 안 들었어요');
+        const keys = this.roster.roster.members
+            .filter((m) => m.person === person)
+            .map((m) => m.machineKey);
+        if (keys.length === 0)
+            throw new PeerNetworkError(`명단에 없는 이름이에요: ${person}`);
+        return keys;
+    }
+    changed() {
+        try {
+            this.options.onControlChange?.();
+        }
+        catch (err) {
+            process.stderr.write(`[peer] control change failed: ${errMessage(err)}\n`);
+        }
+    }
+    /** 주인 쪽: 공유 하나를 누가 보고 누가 기다리고 누가 막혔는지 */
+    shareControl(share) {
+        const watchers = new Set();
+        for (const s of this.subs.values()) {
+            if (s.share === share)
+                watchers.add(this.personOf(s.watcher));
+        }
+        const pending = [];
+        for (const p of this.pending.values()) {
+            if (p.share === share) {
+                pending.push({
+                    person: this.personOf(p.watcher),
+                    at: p.at,
+                    expiresAt: p.expiresAt,
+                    brief: p.brief,
+                });
+            }
+        }
+        const blocked = [...(this.blocked.get(share) ?? new Map())].map(([machine, reason]) => ({ person: this.personOf(machine), reason }));
+        return { watchers: [...watchers], pending, blocked, peeks: this.peeks.notices(share) };
+    }
+    /** 주인 쪽: 승인을 기다리는 그 사람의 요청을 받아 준다. 받아 준 기기는 공유가 열린 동안 기억한다 */
+    approve(person, shares) {
+        const hits = this.pendingOf(person, shares);
+        for (const p of hits) {
+            this.dropApproval(`${p.share}|${p.watcher}`);
+            this.grant(p.share, p.watcher, 'owner');
+            const owned = this.options.lookupShare(p.share);
+            if (owned && !owned.stream.isClosed) {
+                this.startSub(p.watcher, p.share, p.nonce, p.after, owned);
+            }
+            else {
+                this.sendBox(p.watcher, {
+                    t: 'watch_err',
+                    share: p.share,
+                    nonce: p.nonce,
+                    reason: 'not_found',
+                });
+            }
+        }
+        return { person, shares: unique(hits.map((p) => p.share)), count: hits.length };
+    }
+    /** 주인 쪽: 승인을 기다리는 그 사람의 요청을 거절한다. 그 공유가 열린 동안 다시 못 붙는다 */
+    deny(person, shares) {
+        const hits = this.pendingOf(person, shares);
+        for (const p of hits) {
+            this.block(p.share, p.watcher, 'denied');
+            this.dropApproval(`${p.share}|${p.watcher}`, 'denied');
+            this.options.state.audit('approval_deny', p.share, JSON.stringify({ person }));
+        }
+        return { person, shares: unique(hits.map((p) => p.share)), count: hits.length };
+    }
+    pendingOf(person, shares) {
+        const machines = new Set(this.machinesOf(person));
+        const hits = [...this.pending.values()].filter((p) => machines.has(p.watcher) && shares.includes(p.share));
+        if (hits.length === 0)
+            throw new PeerNetworkError(`승인을 기다리는 사람이 아니에요: ${person}`);
+        return hits;
+    }
+    /**
+     * 주인 쪽: 그 사람의 기기 전부를 공유에서 끊는다. 구독을 끝내고 그 구독 몫의 세션 키를 메모리에서
+     * 지운다. 지금 안 보고 있어도 막아 둔다. 공유가 열린 동안 다시 붙지 못하고 메시지도 못 넣는다.
+     */
+    kick(person, shares) {
+        const machines = this.machinesOf(person);
+        if (machines.includes(this.key.id))
+            throw new PeerNetworkError('자기 자신은 끊을 수 없어요');
+        let count = 0;
+        for (const share of shares) {
+            let ended = 0;
+            for (const machine of machines) {
+                this.block(share, machine, 'kicked');
+                this.dropApproval(`${share}|${machine}`, 'kicked');
+            }
+            for (const sub of [...this.subs.values()]) {
+                if (sub.share !== share || !machines.includes(sub.watcher))
+                    continue;
+                this.endSub(sub, 'kicked', true);
+                ended++;
+            }
+            this.options.state.audit('kick', share, JSON.stringify({ person, ended }));
+            count += ended;
+        }
+        this.changed();
+        return { person, shares, count };
+    }
+    /**
+     * 주인 쪽: 공유가 닫혔다. 승인을 기다리던 사람에게 알리고 그 공유의 승인과 막은 목록을 버린다.
+     * 붙어 있던 구독은 공유 스트림의 closed 프레임으로 끝난다.
+     */
+    forgetShare(share) {
+        for (const [key, p] of [...this.pending]) {
+            if (p.share === share)
+                this.dropApproval(key, 'share_closed');
+        }
+        this.approved.delete(share);
+        this.blocked.delete(share);
+        this.peeks.forget(share);
+        this.changed();
     }
     /**
      * 처음 보는 nonce면 기억하고 true. 공유는 데몬이 다시 뜨면 닫히므로 메모리에만 둔다.
@@ -653,6 +1362,10 @@ export class PeerNetwork {
             this.endSub(remote, 'share_closed', false);
     }
     post(remote, frames) {
+        // 끊긴 구독은 키를 지웠다. 지금 부르는 쪽(pump의 step, onLocalFrame)이 ended를 먼저 보지만
+        // 호출부가 늘어도 지운 키로 봉인한 프레임이 나가지 않게 여기서도 막는다
+        if (remote.ended)
+            return;
         const env = {
             k: 's',
             share: remote.share,
@@ -667,6 +1380,9 @@ export class PeerNetwork {
         remote.ended = true;
         remote.unsubscribe();
         this.subs.delete(remote.sub);
+        // 이 구독 몫의 세션 키를 메모리에서 지운다. 새 프레임은 ended를 보는 앞 경로가 거르고 post가 한 번 더 막는다
+        remote.key.fill(0);
+        this.changed();
         if (notify)
             this.sendBox(remote.watcher, {
                 t: 'watch_end',
@@ -682,19 +1398,24 @@ export class PeerNetwork {
         }
     }
     // ── 보는 쪽 ──────────────────────────────────────────────
+    /**
+     * 주인 데몬에 보기를 청한다. watch_ok면 'ok', 주인 승인을 기다리면 'waiting'으로 끝난다.
+     * 기다리는 동안 pending.nonce는 남겨 두고 나중에 오는 watch_ok나 watch_err를 그 nonce로 맞춘다.
+     */
     requestWatch(w) {
         return new Promise((resolve, reject) => {
-            if (w.pending) {
-                clearTimeout(w.pending.timer);
-                w.pending.reject(new PeerNetworkError('다시 청해서 앞 요청을 버렸어요'));
-            }
+            this.dropPending(w, '다시 청해서 앞 요청을 버렸어요');
+            if (w.retry)
+                clearTimeout(w.retry);
+            w.retry = undefined;
             const nonce = randomBytes(16).toString('base64url');
             const timer = setTimeout(() => {
-                w.pending = undefined;
-                reject(new PeerNetworkError('주인 데몬이 답하지 않았어요'));
+                if (w.pending?.nonce === nonce)
+                    w.pending = undefined;
+                reject(new WatchTimeout('주인 데몬이 답하지 않았어요'));
             }, WATCH_TIMEOUT_MS);
             timer.unref();
-            w.pending = { nonce, resolve, reject, timer };
+            w.pending = { nonce, settle: { resolve, reject, timer } };
             w.sub = undefined;
             w.key = undefined;
             const sent = this.sendBox(w.owner, {
@@ -711,41 +1432,114 @@ export class PeerNetwork {
             }
         });
     }
+    dropPending(w, why) {
+        const settle = w.pending?.settle;
+        w.pending = undefined;
+        if (!settle)
+            return;
+        clearTimeout(settle.timer);
+        settle.reject(new PeerNetworkError(why));
+    }
     rewatch(w) {
-        this.requestWatch(w).catch((err) => {
-            if (err instanceof PeerNetworkError && /not_found|bad_proof/.test(err.message)) {
-                this.closeWatch(w, 'share_closed');
-            }
-            else {
-                w.feed.markOffline();
-            }
+        this.requestWatch(w)
+            .then((r) => {
+            if (r === 'waiting')
+                w.feed.markWaiting();
+        })
+            .catch((err) => {
+            if (err instanceof WatchRefused)
+                return this.onRefused(w, err.reason);
+            w.feed.markOffline();
+            // 앞 요청을 버려서 실패한 건 새 요청이 이미 나갔으니 다시 걸지 않는다
+            if (err instanceof WatchTimeout)
+                this.scheduleRewatch(w);
         });
     }
+    /**
+     * 조금 뒤에 다시 청한다. 주인 데몬이 답하지 않았거나 too_many처럼 다시 청하면 되는 거절일 때다.
+     * 이게 없으면 다음 presence가 올 때까지 보기가 offline에 멈춘다. 간격은 두 배씩 늘리고 횟수는
+     * 구독이 열릴 때만 0으로 돌아간다. 상한에 닿으면 멈추고 주인이 릴레이에 다시 붙을 때 다시 청한다.
+     */
+    scheduleRewatch(w) {
+        if (w.retry || w.retries >= MAX_REWATCH_RETRIES || !this.watches.has(w.id))
+            return;
+        const delay = Math.min(MAX_REWATCH_DELAY_MS, 1000 * 2 ** w.retries);
+        w.retries++;
+        w.retry = setTimeout(() => {
+            w.retry = undefined;
+            if (this.watches.has(w.id) && !w.pending)
+                this.rewatch(w);
+        }, delay);
+        w.retry.unref();
+    }
+    /** 주인 데몬이 보기를 거절했다. 다시 청해도 안 되는 이유면 보기를 끝낸다 */
+    onRefused(w, reason) {
+        if (!FINAL_REFUSALS.has(reason)) {
+            w.feed.markOffline();
+            this.scheduleRewatch(w);
+            return;
+        }
+        const closeAs = reason === 'not_found' || reason === 'bad_proof' ? 'share_closed' : reason;
+        this.closeWatch(w, closeAs);
+    }
     onWatchReply(from, msg) {
         const w = [...this.watches.values()].find((x) => x.owner === from && x.share === msg.share && x.pending?.nonce === msg.nonce);
-        if (!w || !w.pending)
+        if (!w || !w.pending) {
+            // 기다리다 그만둔 뒤 취소와 승인이 엇갈리면 맞는 보기가 없는 watch_ok가 온다. 주인 쪽에
+            // 구독이 열린 채로 남지 않게 그 구독을 끊어 달라고 돌려보낸다
+            if (msg.t === 'watch_ok' && typeof msg.sub === 'string' && isShareId(msg.share)) {
+                this.sendBox(from, { t: 'unwatch', share: msg.share, sub: msg.sub });
+            }
+            return;
+        }
+        const settle = w.pending.settle;
+        if (msg.t === 'watch_wait') {
+            w.feed.markWaiting();
+            if (settle) {
+                clearTimeout(settle.timer);
+                w.pending.settle = undefined;
+                settle.resolve('waiting');
+            }
             return;
-        const pending = w.pending;
+        }
         w.pending = undefined;
-        clearTimeout(pending.timer);
+        if (settle)
+            clearTimeout(settle.timer);
         if (msg.t === 'watch_err') {
-            pending.reject(new PeerNetworkError(`주인 데몬이 거절했어요: ${msg.reason}`));
+            // 주인 데몬이 보낸 글자라 CLI와 뷰어에 찍히기 전에 정리한다
+            const err = new WatchRefused(plainLabel(msg.reason, 64) ?? 'unknown');
+            if (settle)
+                settle.reject(err);
+            else
+                this.onRefused(w, err.reason);
             return;
         }
         if (typeof msg.sub !== 'string' || typeof msg.salt !== 'string') {
-            pending.reject(new PeerNetworkError('주인 데몬 답이 맞지 않아요'));
+            const err = new PeerNetworkError('주인 데몬 답이 맞지 않아요');
+            if (settle)
+                settle.reject(err);
+            else
+                w.feed.markOffline();
             return;
         }
         w.sub = msg.sub;
+        // 재청 횟수는 구독이 실제로 열렸을 때만 지운다. 거절 답에서 지우면 too_many가 이어질 때 간격이
+        // 늘지 않고 상한에도 안 닿아 1초마다 끝없이 청한다
+        w.retries = 0;
+        w.messages = msg.messages === true;
         w.key = streamKey(w.shareKey, Buffer.from(msg.salt, 'base64url'), w.share, this.key.id, msg.sub);
-        pending.resolve();
+        settle?.resolve('ok');
     }
     onWatchEnd(from, msg) {
         const w = [...this.watches.values()].find((x) => x.owner === from && x.sub === msg.sub);
         if (!w)
             return;
         w.sub = undefined;
+        w.key?.fill(0);
         w.key = undefined;
+        // 주인이 끊었으면 다시 청하지 않는다. 다시 청해도 주인 데몬이 kicked로 거절한다
+        if (msg.reason === 'kicked')
+            return this.closeWatch(w, 'kicked');
         this.rewatch(w);
     }
     onStream(from, env) {
@@ -774,11 +1568,25 @@ export class PeerNetwork {
         if (!this.watches.has(w.id))
             return;
         this.watches.delete(w.id);
-        if (w.pending) {
-            clearTimeout(w.pending.timer);
-            w.pending.reject(new PeerNetworkError(`보기가 끝났어요: ${reason}`));
-            w.pending = undefined;
+        if (w.retry)
+            clearTimeout(w.retry);
+        w.retry = undefined;
+        // 승인을 기다리던 중이면 주인 쪽 대기가 시한까지 남지 않게 그 nonce로 취소를 보낸다
+        if (w.pending && !w.sub) {
+            this.sendBox(w.owner, { t: 'watch_cancel', share: w.share, nonce: w.pending.nonce });
         }
+        this.dropPending(w, `보기가 끝났어요: ${reason}`);
+        w.key?.fill(0);
+        w.key = undefined;
+        this.closedWatches.push({
+            id: w.id,
+            share: w.share,
+            owner: w.feed.ownerPerson,
+            events: w.feed.eventCount,
+            reason,
+        });
+        if (this.closedWatches.length > MAX_CLOSED_WATCHES)
+            this.closedWatches.shift();
         w.feed.close(reason);
         try {
             this.options.state.audit('watch_close', null, JSON.stringify({ watch: w.id, share: w.share, reason }));
@@ -800,6 +1608,21 @@ export class PeerNetwork {
 function watchProofText(share, watcher, nonce) {
     return canonical({ p: 'gestalt-peer-watch-v1', share, watcher, nonce });
 }
+/** 링크를 가진 쪽만 만드는 메시지 증명. 본문까지 넣어 릴레이가 내용을 바꾸지 못하게 한다 */
+function messageProofText(share, from, id, body) {
+    return canonical({ p: 'gestalt-peer-msg-v1', share, from, id, body });
+}
+function unique(items) {
+    return [...new Set(items)];
+}
+function isMessageStatus(v) {
+    return (v === 'queued' ||
+        v === 'sent' ||
+        v === 'arrived' ||
+        v === 'inserted' ||
+        v === 'delivered' ||
+        v === 'rejected');
+}
 function streamKey(shareKey, salt, share, watcher, sub) {
     return deriveKey(shareKey, salt, `gestalt-peer-stream-v1|${share}|${watcher}|${sub}`);
 }