dsh-remote-control 1.0.0 → 1.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote-control",
-  "version": "1.0.0",
-  "description": "DSH Remote Control host plugin: pairs a running DeepSeek Harness with the DRC relay so a WeChat Mini Program can send prompts, watch streamed output, and answer approvals. Payload-level E2E encryption; the relay never sees plaintext.",
+  "version": "1.1.0",
+  "description": "DSH Remote Control host plugin: pairs a running DeepSeek Harness with the DRC relay so a WeChat Mini Program can send prompts, watch streamed output, and answer approvals. Payload-level E2E encryption; the relay never sees plaintext. Also renders the pairing QR into the DSH right sidebar (same-origin read-only route + browser half).",
   "type": "module",
   "license": "MIT",
   "author": "providcc",
@@ -20,7 +20,9 @@
     "e2ee",
     "tweetnacl",
     "x25519",
-    "xsalsa20-poly1305"
+    "xsalsa20-poly1305",
+    "qrcode",
+    "sidebar"
   ],
   "engines": {
     "node": ">=20"
@@ -28,16 +30,21 @@
   "main": "./dist/bundle/index.js",
   "exports": {
     ".": "./dist/bundle/index.js",
+    "./client": "./dist/bundle/client.cjs",
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json"
   },
   "files": [
-    "dist",
+    "dist/bundle",
     "cordis.patch.yml"
   ],
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
     }
   },
   "publishConfig": {
@@ -61,8 +68,8 @@
   },
   "scripts": {
     "clean": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "build": "tsc -p tsconfig.json && node ../../scripts/bundle-plugin.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc -p client/tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsc -p client/tsconfig.json && node ../../scripts/bundle-plugin.mjs",
     "test": "pnpm build && node --test \"dist/tests/*.test.js\"",
     "format": "prettier --write .",
     "format:check": "prettier --check ."

package/dist/src/core/clock.d.ts

@@ -1,45 +0,0 @@
-/**
- * clock — 时间与定时器的注入点。
- *
- * 为什么端口里要有时钟：合帧窗口、空闲放锁、重连退避、审批超时这几件事
- * 全是**时间相关的策略**，没有注入点就只能靠真等（旧实现的窗口化与持锁策略
- * 就是这么没被测到的）。测试里换成假时钟，可以把 300 秒的空闲释放压成一次 `advance()`。
- */
-import type { Clock } from '../ports/index.js';
-export declare const DEFAULT_SYSTEM_CLOCK: Clock;
-/**
- * 让一个定时器**不再拖住进程退出**。
- *
- * 为什么必须要这个东西：`Clock` 端口只承诺 `setTimeout/clearTimeout`，句柄是 `unknown`，
- * 所以"别为了我留着事件循环"这件事在端口上表达不出来。而"载具探测的复查"这类定时器是
- * **顺手看一眼**的取证动作——宿主要是还活着它就照跑，进程要是已经无别的事可做，它就该
- * 立刻退，而不是被最长的那一发钉住（`node e2e/run.mjs` 1.2s 跑完却 60s 才退，就是这么来的；
- * 同理任何 headless/CLI 跑法都会白等一分钟）。
- *
- * 对 `FakeClock` 的数字句柄是**空操作**：那种场景下定时器本来就归测试掌控，
- * 没有"事件循环"可拖。所以这里只认 `unref` 存在与否，不做类型假设。
- */
-export declare function unrefTimer(handle: unknown): void;
-/**
- * 一次性定时器集合：每个建出来都 **unref**（见上），并统一登记，好让调用方在停机时一次撤掉。
- *
- * 为什么 `unref` 与"集中撤销"要成对：只 unref 不撤销，宿主没退的情况下这些复查仍会在
- * 任务结束之后去写 status.json（写的是过期的取证）；只撤销不 unref，宿主空闲时进程又被钉住。
- * 两件事都做，才既有"不拖尾"又有"任务结束就安静"。
- */
-export declare function createOneShotTimers(clock: Clock): {
-    schedule(fn: () => void, delayMs: number): void;
-    cancelAll(): void;
-};
-/** 假时钟：`advance(ms)` 按到期时间依次触发定时器，完全确定。 */
-export declare class FakeClock implements Clock {
-    private at;
-    private sequence;
-    private readonly timers;
-    now(): number;
-    setTimeout(fn: () => void, ms: number): unknown;
-    clearTimeout(handle: unknown): void;
-    /** 推进时间并触发所有到期定时器（按到期顺序，处理"定时器里又装定时器"）。 */
-    advance(ms: number): Promise<void>;
-    get pending(): number;
-}

package/dist/src/core/clock.js

@@ -1,83 +0,0 @@
-export const DEFAULT_SYSTEM_CLOCK = {
-    now: () => Date.now(),
-    setTimeout: (fn, ms) => setTimeout(fn, ms),
-    clearTimeout: (handle) => clearTimeout(handle),
-};
-/**
- * 让一个定时器**不再拖住进程退出**。
- *
- * 为什么必须要这个东西：`Clock` 端口只承诺 `setTimeout/clearTimeout`，句柄是 `unknown`，
- * 所以"别为了我留着事件循环"这件事在端口上表达不出来。而"载具探测的复查"这类定时器是
- * **顺手看一眼**的取证动作——宿主要是还活着它就照跑，进程要是已经无别的事可做，它就该
- * 立刻退，而不是被最长的那一发钉住（`node e2e/run.mjs` 1.2s 跑完却 60s 才退，就是这么来的；
- * 同理任何 headless/CLI 跑法都会白等一分钟）。
- *
- * 对 `FakeClock` 的数字句柄是**空操作**：那种场景下定时器本来就归测试掌控，
- * 没有"事件循环"可拖。所以这里只认 `unref` 存在与否，不做类型假设。
- */
-export function unrefTimer(handle) {
-    const maybe = handle;
-    if (maybe && typeof maybe.unref === 'function')
-        maybe.unref();
-}
-/**
- * 一次性定时器集合：每个建出来都 **unref**（见上），并统一登记，好让调用方在停机时一次撤掉。
- *
- * 为什么 `unref` 与"集中撤销"要成对：只 unref 不撤销，宿主没退的情况下这些复查仍会在
- * 任务结束之后去写 status.json（写的是过期的取证）；只撤销不 unref，宿主空闲时进程又被钉住。
- * 两件事都做，才既有"不拖尾"又有"任务结束就安静"。
- */
-export function createOneShotTimers(clock) {
-    const handles = [];
-    return {
-        schedule(fn, delayMs) {
-            const handle = clock.setTimeout(fn, delayMs);
-            unrefTimer(handle);
-            handles.push(handle);
-        },
-        cancelAll() {
-            // splice 让"撤过的不再撤"：stop() 可能被 effect 与 onDispose 两条路各走一次。
-            for (const handle of handles.splice(0))
-                clock.clearTimeout(handle);
-        },
-    };
-}
-/** 假时钟：`advance(ms)` 按到期时间依次触发定时器，完全确定。 */
-export class FakeClock {
-    at = 1_700_000_000_000;
-    sequence = 0;
-    timers = new Map();
-    now() {
-        return this.at;
-    }
-    setTimeout(fn, ms) {
-        const id = ++this.sequence;
-        this.timers.set(id, { at: this.at + ms, fn });
-        return id;
-    }
-    clearTimeout(handle) {
-        this.timers.delete(handle);
-    }
-    /** 推进时间并触发所有到期定时器（按到期顺序，处理"定时器里又装定时器"）。 */
-    async advance(ms) {
-        const target = this.at + ms;
-        for (;;) {
-            const due = [...this.timers.entries()]
-                .filter(([, timer]) => timer.at <= target)
-                .sort((a, b) => a[1].at - b[1].at)[0];
-            if (!due)
-                break;
-            const [id, timer] = due;
-            this.timers.delete(id);
-            this.at = Math.max(this.at, timer.at);
-            timer.fn();
-            await Promise.resolve();
-        }
-        this.at = target;
-        await Promise.resolve();
-    }
-    get pending() {
-        return this.timers.size;
-    }
-}
-//# sourceMappingURL=clock.js.map

package/dist/src/core/clock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"clock.js","sourceRoot":"","sources":["../../../src/core/clock.ts"],"names":[],"mappings":"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"}

package/dist/src/core/keys.d.ts

@@ -1,98 +0,0 @@
-export interface Conversation {
-    id: string;
-    clientIds: Set<string>;
-    kC2H: Uint8Array;
-    kH2C: Uint8Array;
-    psk: string;
-    /** host→client 方向的本地序号（中继也会编号，本端这一个是给"顺序可核对"用的）。 */
-    seqHost: number;
-    generation: number;
-    createdAt: number;
-    /** 最近一次有实际收发的时刻；剪枝只看这个，不看 `createdAt`。 */
-    lastActivityAt: number;
-}
-/**
- * 一本有界的密钥簿。
- *
- * 为什么必须有界（复核 🟡8）：D3 之后配对通道跨断连长存，而**中继侧的空闲 TTL 是 7 天**
- * （`apps/server/src/config.ts` 的 `DRC_CONV_IDLE_TTL_MS`）。也就是说"中继先把它忘掉"
- * 这件事几乎不会发生，长期跑的主机会把每一条曾经配对过的通道连同一份 PSK 永远留在内存里，
- * 并且每次广播都还对它们逐个密封一遍（白做功且随天数线性增长）。
- * 剪枝只由 host 侧负责，且必须**同时通知中继与上层**（见 `RelayClient.pruneConversations`），
- * 否则手机会对着一条主机已经不认得的通道说话。
- */
-export interface PrunePolicy {
-    /** 距今超过这么久而没有任何收发的通道可以剪掉。 */
-    idleTtlMs: number;
-    /** 通道数硬上界：超了就从最不活跃的开始剪（剪枝不看创建时刻，看最后活动）。 */
-    maxConversations: number;
-}
-export declare const DEFAULT_PRUNE_POLICY: PrunePolicy;
-export declare class ConversationBook {
-    private readonly byId;
-    /**
-     * 为一条新配对建立密钥。
-     *
-     * @param psk 必须来自 `PairingSlots.resolveFor(token)`——**不允许**"取最新的一个"。
-     */
-    open(args: {
-        id: string;
-        psk: string;
-        generation: number;
-        now: number;
-    }): Conversation;
-    /** 有实际收发就记一笔活跃（剪枝只看这个时刻）。未知通道返回 false，不顺手建条目。 */
-    touch(id: string, now: number): boolean;
-    get(id: string): Conversation | undefined;
-    has(id: string): boolean;
-    close(id: string): boolean;
-    /** 中继重启（generation 变化）时把旧会话全部丢掉：它们再也解不开了。 */
-    closeBefore(generation: number): string[];
-    /**
-     * 按策略剪枝，返回被剪掉的 id（调用方负责通知中继与上层，见
-     * `RelayClient.pruneConversations`）。
-     *
-     * 两条规则都做，因为它们是两种不同的失控：
-     * - 空闲超 TTL：一条通道一天没有任何收发，就不会再有人用它了；
-     * - 超出硬上界：从**最不活跃**的开始剪。没有这条，一个每天配一次对的用户
-     *   会在两周内攒下 260 条密钥，并且每次广播都对它们逐个密封一遍。
-     */
-    pruneStale(now: number, policy?: PrunePolicy): string[];
-    ids(): string[];
-    get size(): number;
-}
-/**
- * 待配对码槽位。
- *
- * 为什么必须是**多槽 Map** 而不是单个"当前 PSK"字段：主机可以一边自动补发一张码、
- * 一边又被用户手动 `/drc pair` 出一张新码，两张都有效；旧实现用单槽，
- * 于是手机用较早那张码配对成功、主机却拿最新那张的 PSK 派生密钥 → 全线解不开。
- * 这是线上事故换来的结论（取证 HANDOFF.md §4.5 与 e2e/multi-pair.test.mjs）。
- */
-export interface PairSlot {
-    token: string;
-    psk: string;
-    /** 本地认为的过期时刻；**收到中继的 `pair-ready.ttlMs` 后必须改写**（§2.3 硬约束 1）。 */
-    expiresAt: number;
-    createdAt: number;
-}
-export declare class PairingSlots {
-    private readonly now;
-    private readonly maxSlots;
-    private readonly slots;
-    constructor(now: () => number, maxSlots?: number);
-    /** 新建一张码。超上限时淘汰最旧的（而不是拒绝新建），因为"发不出去"比"少一张"更糟。 */
-    create(ttlMs: number): PairSlot;
-    /**
-     * 用服务端权威 TTL 改写本地过期时间。
-     * 忘了这一步的后果：主机在配对发生之前就清掉了 PSK，
-     * `peer-joined` 找不到密钥 → 静默丢 peer → 手机永远解不开。
-     */
-    applyServerTtl(token: string, ttlMs: number): boolean;
-    /** 按手机实际使用的码取 PSK。取不到就是 null，调用方必须拒绝这条配对而不是猜。 */
-    resolveFor(token: string | undefined): PairSlot | null;
-    /** 最近一张仍有效的码（只用于 `/drc pair` 展示与状态快照，绝不用于取密钥）。 */
-    latest(): PairSlot | null;
-    prune(): number;
-    get size(): number;
-}

package/dist/src/core/keys.js

@@ -1,176 +0,0 @@
-/**
- * keys — 会话密钥簿（配对通道 → 两把方向密钥）。
- *
- * 密钥全部由 `(psk, 方向, convId)` 派生（冻结项 B5），所以这本账的键只能是 convId。
- * **两个方向必须分开存**：手机用 `c2h` 发、用 `h2c` 收，主机正好相反。
- *
- * 一条来自旧实现线上事故的硬教训（取证 docs/legacy-spec/relay-and-wireformat.md §2.3）：
- * 主机挂着多张配对码时，**必须按手机实际使用的那张码取 PSK**，
- * 取错的结果是"配对显示成功、每一帧都解不开、会话列表空白"——极难定位。
- * 因此这里不提供"取最近一个"的接口，只有 `resolveFor(token)`。
- */
-import { generatePsk, randomPairingToken } from 'dsh-remote-wire';
-import { derivePskKey } from 'dsh-remote-wire';
-const C2H = 'c2h';
-const H2C = 'h2c';
-export const DEFAULT_PRUNE_POLICY = {
-    // 一天没有任何收发就认为这条通道不会再被用（手机真回来时会重新扫码，
-    // 而且它会先撞上 `unknown_session` → 中文提示，而不是"永远转圈"）。
-    idleTtlMs: 24 * 3600 * 1000,
-    maxConversations: 64,
-};
-export class ConversationBook {
-    byId = new Map();
-    /**
-     * 为一条新配对建立密钥。
-     *
-     * @param psk 必须来自 `PairingSlots.resolveFor(token)`——**不允许**"取最新的一个"。
-     */
-    open(args) {
-        const conversation = {
-            id: args.id,
-            clientIds: new Set(),
-            kC2H: derivePskKey(args.psk, C2H, args.id),
-            kH2C: derivePskKey(args.psk, H2C, args.id),
-            psk: args.psk,
-            seqHost: 0,
-            generation: args.generation,
-            createdAt: args.now,
-            lastActivityAt: args.now,
-        };
-        this.byId.set(args.id, conversation);
-        return conversation;
-    }
-    /** 有实际收发就记一笔活跃（剪枝只看这个时刻）。未知通道返回 false，不顺手建条目。 */
-    touch(id, now) {
-        const conversation = this.byId.get(id);
-        if (!conversation)
-            return false;
-        conversation.lastActivityAt = now;
-        return true;
-    }
-    get(id) {
-        return this.byId.get(id);
-    }
-    has(id) {
-        return this.byId.has(id);
-    }
-    close(id) {
-        return this.byId.delete(id);
-    }
-    /** 中继重启（generation 变化）时把旧会话全部丢掉：它们再也解不开了。 */
-    closeBefore(generation) {
-        const dropped = [];
-        for (const [id, conversation] of [...this.byId]) {
-            if (conversation.generation < generation) {
-                this.byId.delete(id);
-                dropped.push(id);
-            }
-        }
-        return dropped;
-    }
-    /**
-     * 按策略剪枝，返回被剪掉的 id（调用方负责通知中继与上层，见
-     * `RelayClient.pruneConversations`）。
-     *
-     * 两条规则都做，因为它们是两种不同的失控：
-     * - 空闲超 TTL：一条通道一天没有任何收发，就不会再有人用它了；
-     * - 超出硬上界：从**最不活跃**的开始剪。没有这条，一个每天配一次对的用户
-     *   会在两周内攒下 260 条密钥，并且每次广播都对它们逐个密封一遍。
-     */
-    pruneStale(now, policy = DEFAULT_PRUNE_POLICY) {
-        const dropped = [];
-        for (const [id, conversation] of [...this.byId]) {
-            if (now - conversation.lastActivityAt > policy.idleTtlMs) {
-                this.byId.delete(id);
-                dropped.push(id);
-            }
-        }
-        if (this.byId.size > policy.maxConversations) {
-            const ordered = [...this.byId.values()].sort((a, b) => a.lastActivityAt - b.lastActivityAt);
-            for (const conversation of ordered.slice(0, this.byId.size - policy.maxConversations)) {
-                this.byId.delete(conversation.id);
-                dropped.push(conversation.id);
-            }
-        }
-        return dropped;
-    }
-    ids() {
-        return [...this.byId.keys()];
-    }
-    get size() {
-        return this.byId.size;
-    }
-}
-export class PairingSlots {
-    now;
-    maxSlots;
-    slots = new Map();
-    constructor(now, maxSlots = 32) {
-        this.now = now;
-        this.maxSlots = maxSlots;
-    }
-    /** 新建一张码。超上限时淘汰最旧的（而不是拒绝新建），因为"发不出去"比"少一张"更糟。 */
-    create(ttlMs) {
-        if (this.slots.size >= this.maxSlots) {
-            const oldest = [...this.slots.values()].sort((a, b) => a.createdAt - b.createdAt)[0];
-            if (oldest)
-                this.slots.delete(oldest.token);
-        }
-        const created = {
-            token: randomToken(),
-            psk: generatePskValue(),
-            expiresAt: this.now() + ttlMs,
-            createdAt: this.now(),
-        };
-        this.slots.set(created.token, created);
-        return created;
-    }
-    /**
-     * 用服务端权威 TTL 改写本地过期时间。
-     * 忘了这一步的后果：主机在配对发生之前就清掉了 PSK，
-     * `peer-joined` 找不到密钥 → 静默丢 peer → 手机永远解不开。
-     */
-    applyServerTtl(token, ttlMs) {
-        const slot = this.slots.get(token);
-        if (!slot)
-            return false;
-        slot.expiresAt = this.now() + ttlMs;
-        return true;
-    }
-    /** 按手机实际使用的码取 PSK。取不到就是 null，调用方必须拒绝这条配对而不是猜。 */
-    resolveFor(token) {
-        if (!token)
-            return null;
-        const slot = this.slots.get(token);
-        if (!slot || slot.expiresAt < this.now())
-            return null;
-        return slot;
-    }
-    /** 最近一张仍有效的码（只用于 `/drc pair` 展示与状态快照，绝不用于取密钥）。 */
-    latest() {
-        const alive = [...this.slots.values()].filter((slot) => slot.expiresAt >= this.now());
-        if (alive.length === 0)
-            return null;
-        return alive.sort((a, b) => b.createdAt - a.createdAt)[0] ?? null;
-    }
-    prune() {
-        const before = this.slots.size;
-        for (const [token, slot] of [...this.slots]) {
-            if (slot.expiresAt < this.now())
-                this.slots.delete(token);
-        }
-        return before - this.slots.size;
-    }
-    get size() {
-        return this.slots.size;
-    }
-}
-/** 6 位配对码：直接用协议层的 CSPRNG 实现，避免在两处各写一遍拒绝采样。 */
-function randomToken() {
-    return randomPairingToken();
-}
-function generatePskValue() {
-    return generatePsk();
-}
-//# sourceMappingURL=keys.js.map

package/dist/src/core/keys.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/core/keys.ts"],"names":[],"mappings":"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"}

package/dist/src/core/pairing-window.d.ts

@@ -1,95 +0,0 @@
-/**
- * pairing-window — "让屏幕上永远有一张能用的码"这条策略。
- *
- * 为什么要有这一层（而不是在启动时发一张就完事）：取证
- * `docs/legacy-spec/host-plugin-runtime.md` §6.2。旧实现把它写成挂在状态快照里的
- * 3 秒循环，并且明确记着**三条 stale 判据各自防的事故**：
- *
- * - `!active` → 防"永远没有码"（一次发布失败之后就再也不发了）；
- * - `generationChanged` → 防"中继重启后一直挂一张死码"：中继的 pending-pair 表是内存的，
- *   重启即清空，那张码的 TTL 还没到但已经没人认得了；
- * - `剩余寿命 < 半程` → 防"用户扫到一个刚刚过期的码"。半程 + 3s 轮询 ⇒ 一张码在
- *   status.json 里的实际存活期约 `ttl/2 ~ ttl`。
- *
- * 新实现再加第四条判据，它是这次重写才有的能力：
- *
- * - `consumed` → 这张码已经被某部手机用掉了（`peer-joined` 带回的就是它的 token）。
- *   旧实现只能等半程刷新，于是"第二部手机要等新码"最坏要等半个 TTL；
- *   而 e2e 连跑多轮时每一轮都要一张**新码**（一次性码不可复用），
- *   没有这条判据的话多轮取证要么很慢、要么只能靠重启宿主。
- *
- * 还有一条不可让步的**发布闸门**：`relay === 'online'` 才发。
- * 因为 `RelayClient.raw()` 对非 OPEN 的 socket 是静默丢弃（`transport/relay.ts`），
- * 断连时"本地记了一张码、远端根本没收到"= 表里多一条永远配不上的 PSK，
- * 而 status.json 里却显示它有效（取证 §6.2 第 5 行）。
- *
- * 本模块是纯逻辑：不认 socket、不认 cordis、时钟与发布动作都由调用方注入，
- * 所以上面四条判据每一条都有单测（旧实现这三条**一条都没测过**）。
- */
-import type { Clock } from '../ports/index.js';
-/** 当前挂在 status.json 里的那张码。 */
-export interface ActivePair {
-    token: string;
-    /** 发起 `pair-begin` 的时刻；TTL 的两条基线都以它为准（见 §6.3 末尾那条不一致的记录）。 */
-    createdAt: number;
-    expiresAt: number;
-    /** 发布时中继的代次；代次变了说明中继的 pending 表已经清空，这张码是死的。 */
-    generation: number;
-}
-export interface WindowInput {
-    active: ActivePair | null;
-    now: number;
-    /** 中继当前代次。 */
-    generation: number;
-    /** 每张码的请求寿命（毫秒）；服务端 `pair-ready.ttlMs` 落地后以它为准。 */
-    ttlMs: number;
-}
-/** 需要重新发布的原因；返回 null 表示这张码仍然可用。 */
-export declare function staleReason(input: WindowInput): string | null;
-export interface WindowDeps {
-    clock: Clock;
-    /** 中继此刻是否在线。 */
-    relayOnline(): boolean;
-    /** 中继当前代次。 */
-    generation(): number;
-    /** 发一张新码，返回它的三个时间量；失败返回 null（保留旧码继续展示）。 */
-    publish(ttlMs: number): {
-        token: string;
-        createdAt: number;
-        expiresAt: number;
-    } | null;
-    /** 每轮最多发布几张：发布失败（socket 未 OPEN）时不许原地打转。 */
-    maxPublishPerTick?: number;
-    log(message: string, fields?: Record<string, string | number | boolean | undefined>): void;
-}
-/**
- * 由调用方按节拍驱动（本仓库里是 `StatusFile.start()` 的 3 秒 tick——
- * 旧实现就是挂在这里，理由是"反正每 3 秒就要写一次状态"）。
- *
- * 刻意**不自带定时器**：定时器属于宿主，一个纯策略类不该再占一只。
- */
-export declare class PairingWindow {
-    private readonly deps;
-    private readonly pairSec;
-    active: ActivePair | null;
-    private requestedTtlMs;
-    constructor(deps: WindowDeps, pairSec: number);
-    /** 服务端权威 TTL（`pair-ready.ttlMs`）：落地后覆盖请求值，并修正已挂出的那张码。 */
-    applyServerTtl(pairingToken: string, ttlMs: number): void;
-    /** 这张码已被某部手机用掉（`peer-joined` 带回的 token 就是它）。 */
-    markConsumed(pairingToken: string): void;
-    /**
-     * 认领一张**别处**发出去的码（手工 `/drc pair`、或 status 之外的入口）。
-     * 不认领的话窗口会认为"没有活动码"而再发一张，于是同一台主机挂两张有效码——
-     * 手机扫的是屏幕上那张，取错密钥就是全线解不开（多码事故的原样）。
-     */
-    adopt(created: {
-        token: string;
-        createdAt: number;
-        expiresAt: number;
-    }): void;
-    /** 一轮检查。返回"这一轮是否发布了新码"。 */
-    tick(): boolean;
-    /** 请求值来自 `pairOnStartSec`，服务端一旦回过 `ttlMs` 就以它为准。 */
-    private ttlMs;
-}

package/dist/src/core/pairing-window.js

@@ -1,92 +0,0 @@
-/** 需要重新发布的原因；返回 null 表示这张码仍然可用。 */
-export function staleReason(input) {
-    const { active, now, ttlMs, generation } = input;
-    if (!active)
-        return 'no-active-pair';
-    if (active.generation !== generation)
-        return 'relay-generation-changed';
-    if (active.expiresAt < now)
-        return 'expired';
-    if (active.expiresAt < now + ttlMs / 2)
-        return 'past-half-life';
-    return null;
-}
-/**
- * 由调用方按节拍驱动（本仓库里是 `StatusFile.start()` 的 3 秒 tick——
- * 旧实现就是挂在这里，理由是"反正每 3 秒就要写一次状态"）。
- *
- * 刻意**不自带定时器**：定时器属于宿主，一个纯策略类不该再占一只。
- */
-export class PairingWindow {
-    deps;
-    pairSec;
-    active = null;
-    requestedTtlMs;
-    constructor(deps, pairSec) {
-        this.deps = deps;
-        this.pairSec = pairSec;
-    }
-    /** 服务端权威 TTL（`pair-ready.ttlMs`）：落地后覆盖请求值，并修正已挂出的那张码。 */
-    applyServerTtl(pairingToken, ttlMs) {
-        if (ttlMs > 0)
-            this.requestedTtlMs = ttlMs;
-        if (this.active && this.active.token === pairingToken) {
-            // 基线用**发起时刻**（createdAt），不是 pair-ready 到达时刻：
-            // 两条基线不一致时本地会比中继早失效（偏危险方向），取证 §6.3 末尾。
-            this.active = { ...this.active, expiresAt: this.active.createdAt + ttlMs };
-        }
-    }
-    /** 这张码已被某部手机用掉（`peer-joined` 带回的 token 就是它）。 */
-    markConsumed(pairingToken) {
-        if (this.active?.token === pairingToken) {
-            this.deps.log('pairing code consumed, publishing a fresh one', { token: pairingToken });
-            this.active = null;
-        }
-    }
-    /**
-     * 认领一张**别处**发出去的码（手工 `/drc pair`、或 status 之外的入口）。
-     * 不认领的话窗口会认为"没有活动码"而再发一张，于是同一台主机挂两张有效码——
-     * 手机扫的是屏幕上那张，取错密钥就是全线解不开（多码事故的原样）。
-     */
-    adopt(created) {
-        this.active = { ...created, generation: this.deps.generation() };
-    }
-    /** 一轮检查。返回"这一轮是否发布了新码"。 */
-    tick() {
-        if (this.pairSec <= 0)
-            return false;
-        // 发布闸门：**不在线就一张都不发**。`RelayClient.raw()` 对非 OPEN 的 socket 是静默丢弃，
-        // 只记本地就会留下"status.json 显示有效、中继那边根本没收到"的死码（取证 §6.2）。
-        if (!this.deps.relayOnline())
-            return false;
-        let published = false;
-        const max = this.deps.maxPublishPerTick ?? 1;
-        for (let attempt = 0; attempt < max; attempt++) {
-            const ttlMs = this.ttlMs();
-            const reason = staleReason({
-                active: this.active,
-                now: this.deps.clock.now(),
-                generation: this.deps.generation(),
-                ttlMs,
-            });
-            if (!reason) {
-                // 不需要新码，但服务端 TTL 可能刚到：把已挂出那张的过期时间按权威值重算。
-                return published;
-            }
-            const created = this.deps.publish(ttlMs);
-            if (!created) {
-                this.deps.log('pairing publish failed', { reason });
-                return published;
-            }
-            this.active = { ...created, generation: this.deps.generation() };
-            this.deps.log('pairing published', { reason, token: created.token, ttlMs });
-            published = true;
-        }
-        return published;
-    }
-    /** 请求值来自 `pairOnStartSec`，服务端一旦回过 `ttlMs` 就以它为准。 */
-    ttlMs() {
-        return this.requestedTtlMs ?? Math.max(1_000, this.pairSec * 1_000);
-    }
-}
-//# sourceMappingURL=pairing-window.js.map