shennian 0.2.87 → 0.2.89

package/dist/src/channels/wechat-channel/client.d.ts

@@ -0,0 +1,74 @@
+import type { WeChatChannelRuntime, WeChatChannelBindingConfig } from './runtime.js';
+export type WeChatChannelApiClientOptions = {
+    serverUrl?: string;
+    machineToken?: string;
+    fetchImpl?: typeof fetch;
+};
+export type WeChatChannelObservedMessage = {
+    stableMessageKey: string;
+    senderRole: 'self' | 'contact' | 'system' | 'unknown';
+    senderName?: string | null;
+    kind: string;
+    normalizedText?: string | null;
+    anchorText?: string | null;
+    anchorMetadata?: unknown;
+    neighborContext?: unknown;
+    textExcerpt?: string | null;
+    bbox?: unknown;
+    mediaMetadata?: unknown;
+    isBaseline?: boolean;
+    deliveryStatus?: string;
+    observedAt?: string;
+    visualBlocks?: Array<{
+        blockId: string;
+        blockKind: string;
+        bbox?: unknown;
+        model: string;
+        dims: number;
+        vectorBase64: string;
+    }>;
+};
+export type WeChatChannelApiClient = ReturnType<typeof createWeChatChannelApiClient>;
+export type WeChatChannelObserveInput = {
+    screenshots: Array<{
+        captureIndex?: number;
+        mimeType: string;
+        dataBase64: string;
+        width: number;
+        height: number;
+    }>;
+    edgeOcrBlocks?: unknown[];
+    visibleConversationFingerprints?: unknown[];
+    localLedgerTailAnchors?: unknown[];
+};
+export type WeChatChannelObserveResponse = {
+    ok: true;
+    observedMessages?: WeChatChannelObservedMessage[];
+    diff?: unknown;
+    reasonCode?: string;
+};
+export type WeChatChannelOutboundStatusInput = {
+    replyId: string;
+    idempotencyKey: string;
+    status: string;
+    replyBaseRevision?: number;
+    sentAt?: string;
+    confirmedAt?: string;
+    failureCode?: string;
+    lastErrorSummary?: string;
+};
+export declare function createWeChatChannelApiClient(options?: WeChatChannelApiClientOptions): {
+    getRuntimePolicy: () => Promise<unknown>;
+    upsertRuntime: (runtime: WeChatChannelRuntime, binding?: WeChatChannelBindingConfig) => Promise<unknown>;
+    observe: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: WeChatChannelObserveInput) => Promise<WeChatChannelObserveResponse>;
+    ingest: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: {
+        idempotencyKey: string;
+        messages: WeChatChannelObservedMessage[];
+    }) => Promise<unknown>;
+    reportOutboundStatus: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: WeChatChannelOutboundStatusInput) => Promise<unknown>;
+    reportRunStatus: (runtime: WeChatChannelRuntime, binding: WeChatChannelBindingConfig, input: {
+        status: string;
+        reasonCode?: string;
+        traceId?: string;
+    }) => Promise<unknown>;
+};

package/dist/src/channels/wechat-channel/client.js

@@ -0,0 +1,96 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @test src/__tests__/wechat-channel-client.test.ts
+import { SERVERS } from '../../region.js';
+import { loadConfig } from '../../config/index.js';
+export function createWeChatChannelApiClient(options = {}) {
+    const config = loadConfig();
+    const serverUrl = normalizeServerUrl(options.serverUrl || config.serverUrl || SERVERS.cn.url);
+    const machineToken = options.machineToken || config.machineToken;
+    const fetchImpl = options.fetchImpl || fetch;
+    if (!machineToken)
+        throw new Error('WeChat channel requires a paired machine token');
+    async function request(path, body) {
+        const response = await fetchImpl(`${serverUrl}/api/channels/wechat${path}`, {
+            method: body === undefined ? 'GET' : 'POST',
+            headers: {
+                authorization: `Bearer ${machineToken}`,
+                ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await response.text();
+        const payload = text ? JSON.parse(text) : null;
+        if (!response.ok || payload?.ok === false) {
+            const reason = payload?.reasonCode || response.statusText || 'request_failed';
+            throw new Error(`WeChat channel API ${path} failed: ${reason}`);
+        }
+        return payload;
+    }
+    return {
+        getRuntimePolicy: () => request('/runtime-policy'),
+        upsertRuntime: (runtime, binding) => request('/runtime', {
+            runtimeId: runtime.runtimeId,
+            machineId: runtime.machineId,
+            pollIntervalSeconds: Math.round(runtime.policy.pollIntervalMs / 1000),
+            foregroundPolicy: runtime.foregroundPolicy,
+            clientRuntimeVersion: String(runtime.policy.runtimeVersion),
+            ...(binding ? bindingPayload(binding) : {}),
+        }),
+        observe: (runtime, binding, input) => request('/observe', {
+            runtimeId: runtime.runtimeId,
+            bindingId: binding.bindingId,
+            sessionId: binding.sessionId,
+            machineId: runtime.machineId,
+            conversationName: binding.conversationDisplayName,
+            schemaVersion: runtime.policy.runtimeVersion,
+            screenshots: input.screenshots,
+            edgeOcrBlocks: input.edgeOcrBlocks ?? [],
+            visibleConversationFingerprints: input.visibleConversationFingerprints ?? [],
+            localLedgerTailAnchors: input.localLedgerTailAnchors ?? [],
+        }),
+        ingest: (runtime, binding, input) => request('/ingest', {
+            runtimeId: runtime.runtimeId,
+            idempotencyKey: input.idempotencyKey,
+            bindingId: binding.bindingId,
+            sessionId: binding.sessionId,
+            machineId: runtime.machineId,
+            messages: input.messages,
+        }),
+        reportOutboundStatus: (runtime, binding, input) => request('/outbound-status', {
+            runtimeId: runtime.runtimeId,
+            replyId: input.replyId,
+            idempotencyKey: input.idempotencyKey,
+            bindingId: binding.bindingId,
+            sessionId: binding.sessionId,
+            machineId: runtime.machineId,
+            status: input.status,
+            replyBaseRevision: input.replyBaseRevision,
+            sentAt: input.sentAt,
+            confirmedAt: input.confirmedAt,
+            failureCode: input.failureCode,
+            lastErrorSummary: input.lastErrorSummary,
+        }),
+        reportRunStatus: (runtime, binding, input) => request('/run-status', {
+            runtimeId: runtime.runtimeId,
+            bindingId: binding.bindingId,
+            sessionId: binding.sessionId,
+            machineId: runtime.machineId,
+            status: input.status,
+            reasonCode: input.reasonCode,
+            traceId: input.traceId,
+        }),
+    };
+}
+function bindingPayload(binding) {
+    return {
+        bindingId: binding.bindingId,
+        sessionId: binding.sessionId,
+        conversationName: binding.conversationDisplayName,
+        enabled: binding.enabled,
+        allowReply: binding.allowReply,
+        downloadMedia: binding.downloadMedia,
+    };
+}
+function normalizeServerUrl(url) {
+    return url.replace(/\/+$/, '');
+}

package/dist/src/channels/wechat-channel/cooldown.d.ts

@@ -0,0 +1,15 @@
+export type WeChatChannelCooldownState = {
+    consecutiveInterruptions: number;
+    cooldownUntil?: string | null;
+    manualReviewReason?: string | null;
+};
+export declare const WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_THRESHOLD = 3;
+export declare const WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_MS: number;
+export declare function isWeChatChannelCooldownActive(state: WeChatChannelCooldownState | undefined, now?: Date): boolean;
+export declare function noteWeChatChannelInterruption(input: {
+    state?: WeChatChannelCooldownState;
+    reason?: string;
+    now?: Date;
+}): WeChatChannelCooldownState;
+export declare function noteWeChatChannelStableRun(state?: WeChatChannelCooldownState): WeChatChannelCooldownState;
+export declare function clearExpiredWeChatChannelCooldown(state: WeChatChannelCooldownState, now?: Date): WeChatChannelCooldownState;

package/dist/src/channels/wechat-channel/cooldown.js

@@ -0,0 +1,38 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @arch docs/features/wechat-rpa-outbound-ledger.md
+// @test src/__tests__/wechat-channel-cooldown.test.ts
+export const WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_THRESHOLD = 3;
+export const WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_MS = 5 * 60 * 1000;
+export function isWeChatChannelCooldownActive(state, now = new Date()) {
+    if (!state?.cooldownUntil)
+        return false;
+    const until = new Date(state.cooldownUntil).getTime();
+    return Number.isFinite(until) && until > now.getTime();
+}
+export function noteWeChatChannelInterruption(input) {
+    const now = input.now ?? new Date();
+    const previous = input.state ?? { consecutiveInterruptions: 0 };
+    const consecutiveInterruptions = previous.consecutiveInterruptions + 1;
+    const next = {
+        consecutiveInterruptions,
+        cooldownUntil: previous.cooldownUntil ?? null,
+        manualReviewReason: previous.manualReviewReason ?? null,
+    };
+    if (consecutiveInterruptions >= WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_THRESHOLD) {
+        next.cooldownUntil = new Date(now.getTime() + WECHAT_CHANNEL_INTERRUPTION_COOLDOWN_MS).toISOString();
+        next.manualReviewReason = input.reason || 'user_interruption_cooldown';
+    }
+    return next;
+}
+export function noteWeChatChannelStableRun(state) {
+    return {
+        consecutiveInterruptions: 0,
+        cooldownUntil: state?.cooldownUntil ?? null,
+        manualReviewReason: state?.manualReviewReason ?? null,
+    };
+}
+export function clearExpiredWeChatChannelCooldown(state, now = new Date()) {
+    if (isWeChatChannelCooldownActive(state, now))
+        return state;
+    return { ...state, cooldownUntil: null };
+}

package/dist/src/channels/wechat-channel/fingerprint.d.ts

@@ -0,0 +1,28 @@
+export type WeChatConversationListFingerprint = {
+    conversationId?: string | null;
+    title?: string | null;
+    preview?: string | null;
+    timeText?: string | null;
+    unreadText?: string | null;
+    fingerprint?: string | null;
+    bbox?: unknown;
+};
+export type WeChatConversationFingerprintTarget = {
+    bindingId: string;
+    conversationDisplayName: string;
+    lastConversationFingerprint?: string | null;
+    lastPreview?: string | null;
+};
+export type WeChatConversationFingerprintMatch = {
+    bindingId: string;
+    item: WeChatConversationListFingerprint;
+    score: number;
+    reason: 'fingerprint' | 'title-preview' | 'title' | 'none';
+};
+export declare function buildWeChatConversationFingerprint(input: WeChatConversationListFingerprint): string;
+export declare function matchWeChatConversationFingerprints(input: {
+    visibleItems: WeChatConversationListFingerprint[];
+    targets: WeChatConversationFingerprintTarget[];
+    minScore?: number;
+}): WeChatConversationFingerprintMatch[];
+export declare function scoreConversationFingerprint(target: WeChatConversationFingerprintTarget, item: WeChatConversationListFingerprint): WeChatConversationFingerprintMatch;

package/dist/src/channels/wechat-channel/fingerprint.js

@@ -0,0 +1,71 @@
+// @arch docs/features/wechat-rpa-productization-plan.md
+// @test src/__tests__/wechat-channel-fingerprint.test.ts
+export function buildWeChatConversationFingerprint(input) {
+    return [input.title, input.preview, input.timeText, input.unreadText]
+        .map((part) => normalizeFingerprintPart(part))
+        .filter(Boolean)
+        .join('|');
+}
+export function matchWeChatConversationFingerprints(input) {
+    const minScore = input.minScore ?? 0.72;
+    const unusedItems = input.visibleItems.map((item) => ({
+        ...item,
+        fingerprint: item.fingerprint || buildWeChatConversationFingerprint(item),
+    }));
+    const matches = [];
+    for (const target of input.targets) {
+        let best = null;
+        for (const item of unusedItems) {
+            const candidate = scoreConversationFingerprint(target, item);
+            if (!best || candidate.score > best.score)
+                best = candidate;
+        }
+        if (best && best.score >= minScore && best.reason !== 'none') {
+            matches.push(best);
+            const index = unusedItems.findIndex((item) => item === best.item);
+            if (index >= 0)
+                unusedItems.splice(index, 1);
+        }
+    }
+    return matches;
+}
+export function scoreConversationFingerprint(target, item) {
+    const itemFingerprint = item.fingerprint || buildWeChatConversationFingerprint(item);
+    if (target.lastConversationFingerprint && itemFingerprint && target.lastConversationFingerprint === itemFingerprint) {
+        return { bindingId: target.bindingId, item, score: 1, reason: 'fingerprint' };
+    }
+    const titleScore = similarity(target.conversationDisplayName, item.title);
+    const previewScore = target.lastPreview ? similarity(target.lastPreview, item.preview) : 0;
+    if (titleScore >= 0.8 && previewScore >= 0.55) {
+        return { bindingId: target.bindingId, item, score: titleScore * 0.7 + previewScore * 0.3, reason: 'title-preview' };
+    }
+    if (titleScore >= 0.88)
+        return { bindingId: target.bindingId, item, score: titleScore * 0.86, reason: 'title' };
+    return { bindingId: target.bindingId, item, score: titleScore * 0.5 + previewScore * 0.2, reason: 'none' };
+}
+function normalizeFingerprintPart(value) {
+    return typeof value === 'string' ? value.trim().replace(/\s+/g, ' ').toLowerCase() : '';
+}
+function similarity(left, right) {
+    const a = normalizeFingerprintPart(left);
+    const b = normalizeFingerprintPart(right);
+    if (!a || !b)
+        return 0;
+    if (a === b)
+        return 1;
+    const distance = levenshtein(a, b);
+    return 1 - distance / Math.max(a.length, b.length);
+}
+function levenshtein(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const curr = Array.from({ length: b.length + 1 }, () => 0);
+    for (let i = 1; i <= a.length; i += 1) {
+        curr[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        for (let j = 0; j <= b.length; j += 1)
+            prev[j] = curr[j];
+    }
+    return prev[b.length];
+}

package/dist/src/channels/wechat-channel/helper-assets.d.ts

@@ -0,0 +1,28 @@
+export declare const WECHAT_CHANNEL_HELPER_VERSION = "0.1.0";
+export type WeChatChannelHelperAssetManifest = {
+    schemaVersion: 1;
+    helperVersion: string;
+    protocolVersion: number;
+    platforms: Record<string, {
+        executable: string;
+        sha256: string | null;
+        signed: boolean;
+        notarized: boolean;
+    }>;
+};
+export type WeChatChannelHelperAssetResolution = {
+    ok: true;
+    helperPath: string;
+    version: string;
+    manifest: WeChatChannelHelperAssetManifest;
+    warning?: string;
+} | {
+    ok: false;
+    reasonCode: 'unsupported_platform' | 'manifest_missing' | 'helper_missing' | 'integrity_mismatch';
+    message: string;
+};
+export declare function resolveWeChatChannelHelperAsset(input?: {
+    platform?: NodeJS.Platform | string;
+    baseDir?: string;
+    verifyIntegrity?: boolean;
+}): WeChatChannelHelperAssetResolution;

package/dist/src/channels/wechat-channel/helper-assets.js

@@ -0,0 +1,68 @@
+// @arch docs/features/wechat-rpa-helper-runtime.md
+// @test src/__tests__/wechat-channel-helper-assets.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+export const WECHAT_CHANNEL_HELPER_VERSION = '0.1.0';
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+export function resolveWeChatChannelHelperAsset(input = {}) {
+    const platform = input.platform ?? process.platform;
+    if (platform !== 'darwin') {
+        return {
+            ok: false,
+            reasonCode: 'unsupported_platform',
+            message: 'WeChat channel helper is only available on macOS in the first version',
+        };
+    }
+    const baseDir = input.baseDir ?? defaultHelperAssetBaseDir();
+    const manifestPath = path.join(baseDir, 'manifest.json');
+    const manifest = readManifest(manifestPath);
+    if (!manifest) {
+        return {
+            ok: false,
+            reasonCode: 'manifest_missing',
+            message: `WeChat channel helper manifest is missing: ${manifestPath}`,
+        };
+    }
+    const asset = manifest.platforms.darwin;
+    const helperPath = asset ? path.join(baseDir, asset.executable) : '';
+    if (!asset || !helperPath || !fs.existsSync(helperPath)) {
+        return {
+            ok: false,
+            reasonCode: 'helper_missing',
+            message: `WeChat channel helper executable is missing: ${helperPath || baseDir}`,
+        };
+    }
+    if (input.verifyIntegrity !== false && asset.sha256) {
+        const actual = crypto.createHash('sha256').update(fs.readFileSync(helperPath)).digest('hex');
+        if (actual !== asset.sha256) {
+            return {
+                ok: false,
+                reasonCode: 'integrity_mismatch',
+                message: `WeChat channel helper integrity mismatch: ${helperPath}`,
+            };
+        }
+    }
+    return {
+        ok: true,
+        helperPath,
+        version: manifest.helperVersion,
+        manifest,
+        warning: asset.signed && asset.notarized ? undefined : 'helper_not_signed_or_notarized',
+    };
+}
+function defaultHelperAssetBaseDir() {
+    return path.resolve(moduleDir, '../../../assets/wechat-channel/macos');
+}
+function readManifest(filePath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (parsed.schemaVersion !== 1 || typeof parsed.helperVersion !== 'string' || !parsed.platforms?.darwin)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/channels/wechat-channel/helper-client.d.ts

@@ -0,0 +1,25 @@
+import { type WeChatChannelHelperCommandName, type WeChatChannelHelperHealthResult, type WeChatChannelHelperReady, type WeChatChannelHelperResponse, type WeChatChannelHelperWarmupSnapshot } from './helper-protocol.js';
+export type WeChatChannelHelperClientOptions = {
+    helperPath: string;
+    expectedHelperVersion: string;
+    args?: string[];
+    cwd?: string;
+};
+export declare class WeChatChannelHelperClient {
+    private options;
+    private child;
+    private lines;
+    private readyState;
+    private warmupState;
+    private pending;
+    constructor(options: WeChatChannelHelperClientOptions);
+    start(): Promise<WeChatChannelHelperReady>;
+    request<T = unknown>(command: WeChatChannelHelperCommandName, params?: Record<string, unknown>, traceId?: string): Promise<WeChatChannelHelperResponse<T>>;
+    healthCheck(traceId?: string): Promise<WeChatChannelHelperResponse<WeChatChannelHelperHealthResult>>;
+    getReadyState(): WeChatChannelHelperReady | null;
+    getWarmupState(): WeChatChannelHelperWarmupSnapshot | null;
+    stop(): Promise<void>;
+    private handleLine;
+    private captureWarmupSnapshot;
+    private rejectAllPending;
+}

package/dist/src/channels/wechat-channel/helper-client.js

@@ -0,0 +1,149 @@
+// @arch docs/features/wechat-rpa-helper-runtime.md
+// @test src/__tests__/wechat-channel-helper-client.test.ts
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline';
+import { createWeChatChannelHelperHello, extractWeChatChannelHelperWarmupSnapshot, timeoutForWeChatChannelHelperCommand, validateWeChatChannelHelperReady, } from './helper-protocol.js';
+export class WeChatChannelHelperClient {
+    options;
+    child = null;
+    lines = null;
+    readyState = null;
+    warmupState = null;
+    pending = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        if (this.child)
+            throw new Error('WeChat channel helper is already started');
+        const child = spawn(this.options.helperPath, this.options.args ?? [], {
+            cwd: this.options.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.lines = createInterface({ input: child.stdout });
+        this.lines.on('line', (line) => this.handleLine(line));
+        child.once('exit', () => this.rejectAllPending(new Error('WeChat channel helper process exited')));
+        const readyPromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('WeChat channel helper handshake timed out')), 2_000);
+            const onLine = (line) => {
+                let frame;
+                try {
+                    frame = JSON.parse(line);
+                }
+                catch {
+                    clearTimeout(timer);
+                    this.lines?.off('line', onLine);
+                    reject(new Error('WeChat channel helper sent invalid handshake JSON'));
+                    return;
+                }
+                if (!isReadyFrame(frame))
+                    return;
+                clearTimeout(timer);
+                this.lines?.off('line', onLine);
+                const validation = validateWeChatChannelHelperReady(frame, this.options.expectedHelperVersion);
+                if (!validation.ok)
+                    reject(new Error(`${validation.errorCode}: ${validation.errorSummary}`));
+                else {
+                    this.readyState = frame;
+                    this.captureWarmupSnapshot(frame);
+                    resolve(frame);
+                }
+            };
+            this.lines?.on('line', onLine);
+        });
+        child.stdin.write(`${JSON.stringify(createWeChatChannelHelperHello(this.options.expectedHelperVersion))}\n`);
+        return readyPromise;
+    }
+    async request(command, params, traceId) {
+        if (!this.child)
+            throw new Error('WeChat channel helper is not started');
+        const id = randomUUID();
+        const timeoutMs = timeoutForWeChatChannelHelperCommand(command);
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`helper_command_timeout: ${command}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        this.child.stdin.write(`${JSON.stringify({ id, command, params, traceId })}\n`);
+        const response = await promise;
+        this.captureWarmupSnapshot(response);
+        this.captureWarmupSnapshot(response.result);
+        return response;
+    }
+    async healthCheck(traceId) {
+        return this.request('health.check', {}, traceId);
+    }
+    getReadyState() {
+        return this.readyState ? { ...this.readyState, capabilities: [...this.readyState.capabilities] } : null;
+    }
+    getWarmupState() {
+        if (!this.warmupState)
+            return null;
+        return {
+            warmState: this.warmupState.warmState,
+            metrics: this.warmupState.metrics ? { ...this.warmupState.metrics } : undefined,
+        };
+    }
+    async stop() {
+        const child = this.child;
+        this.child = null;
+        this.readyState = null;
+        this.lines?.close();
+        this.lines = null;
+        this.rejectAllPending(new Error('WeChat channel helper stopped'));
+        if (!child || child.killed)
+            return;
+        child.kill('SIGTERM');
+    }
+    handleLine(line) {
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!isResponseFrame(frame))
+            return;
+        const pending = this.pending.get(frame.id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pending.delete(frame.id);
+        pending.resolve(frame);
+    }
+    captureWarmupSnapshot(value) {
+        const snapshot = extractWeChatChannelHelperWarmupSnapshot(value);
+        if (snapshot)
+            this.warmupState = snapshot;
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pending.delete(id);
+        }
+    }
+}
+function isReadyFrame(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return record.type === 'ready'
+        && typeof record.helperVersion === 'string'
+        && typeof record.protocolVersion === 'number'
+        && Array.isArray(record.capabilities)
+        && typeof record.pid === 'number';
+}
+function isResponseFrame(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return typeof record.id === 'string'
+        && typeof record.ok === 'boolean'
+        && typeof record.latencyMs === 'number';
+}