@walkhi/code-relax 0.1.0-beta.71 → 0.1.0-beta.78

package/dist/src/message-upload-files.mjs

@@ -1,109 +1,115 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import sharp from 'sharp';
-import media from '../shared/code-browser.cjs';
-import { validateInlineImage } from './message-images.mjs';
-import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_TOTAL_BYTES } from './file-upload-session.mjs';
-import { fileRevision } from './file-transfer-range.mjs';
-
-const mimeTypes = { pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
-  json: 'application/json', zip: 'application/zip', doc: 'application/msword',
-  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
-
-// Reuse the incoming-file contract without sending workstation bytes to the phone.
-export async function stageWorkstationMessageFile(file, uploadsRoot) {
-  const handle = await fs.open(file.path, 'r');
-  const session = createFileUploadSession(uploadsRoot);
-  try {
-    const stat = await handle.stat();
-    if (!stat.isFile() || stat.size < 1 || stat.size > MAX_FILE_BYTES) throw new Error('附件为空或超过 20 MiB。');
-    const validate = async () => {
-      if (fileRevision(await handle.stat()) !== file.revision || fileRevision(await fs.stat(file.path)) !== file.revision) {
-        throw new Error('电脑文件已变化，请重新添加。');
-      }
-    };
-    await validate();
-    const bytes = Buffer.alloc(stat.size);
-    for (let offset = 0; offset < bytes.length;) {
-      const { bytesRead } = await handle.read(bytes, offset, bytes.length - offset, offset);
-      if (!bytesRead) throw new Error('电脑文件读取不完整，请重新添加。');
-      offset += bytesRead;
-    }
-    await validate();
-    const sha256 = crypto.createHash('sha256').update(bytes).digest('hex');
-    const started = await session.receive({ type: 'start', name: file.name, size: bytes.length, sha256 });
-    for (let offset = 0; offset < bytes.length; offset += FILE_CHUNK_BYTES) {
-      await session.receive({ type: 'chunk', id: started.id, offset, data: bytes.subarray(offset, offset + FILE_CHUNK_BYTES) });
-    }
-    await validate();
-    const result = await session.receive({ type: 'finish', id: started.id });
-    await session.receive({ type: 'commit' });
-    return { ...result, mediaKind: media.mediaKind(file),
-      mimeType: media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream' };
-  } finally { await handle.close(); await session.close(); }
-}
-
-async function localFile(file, directory) {
-  if (typeof file?.path !== 'string' || typeof file.name !== 'string' || !file.name || /[\r\n\0]/.test(file.name)) {
-    throw new Error('附件信息无效，请重新选择。');
-  }
-  const root = await fs.realpath(directory), resolved = await fs.realpath(file.path);
-  if (path.relative(root, path.dirname(resolved)) !== '') throw new Error('附件必须来自本次工作站上传目录。');
-  const handle = await fs.open(resolved, 'r');
-  try {
-    const stat = await handle.stat();
-    if (!stat.isFile() || stat.size < 1 || stat.size > MAX_FILE_BYTES) throw new Error('附件为空或超过 20 MiB。');
-    const bytes = await handle.readFile();
-    if (bytes.length !== stat.size) throw new Error('附件在读取时发生变化，请重新上传。');
-    const mimeType = media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream';
-    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType)) throw new Error('附件类型无效。');
-    return { name: file.name, mimeType, bytes };
-  } finally { await handle.close(); }
-}
-
-export async function readMessageUploads(body, uploadsRoot) {
-  const images = body.images ?? [], originals = body.originalImages ?? [], files = body.files ?? [];
-  if (![images, originals, files].every(Array.isArray) || images.length + originals.length > 4 || files.length + originals.length > MAX_FILE_COUNT) {
-    throw new Error('每条消息最多 4 张图片、4 个文件。');
-  }
-  const uploads = [];
-  let imageBytes = 0, fileBytes = 0;
-  for (const image of images) {
-    let file;
-    if (typeof image === 'string' && image.startsWith('data:')) {
-      validateInlineImage(image);
-      const mimeType = image.slice(5, image.indexOf(';'));
-      file = { name: `image.${mimeType.split('/')[1]}`, mimeType, bytes: Buffer.from(image.slice(image.indexOf(',') + 1), 'base64') };
-    } else {
-      if (typeof image !== 'string' || !/^[a-f0-9]{64}$/.test(image)) throw new Error('图片标识无效。');
-      let extension = 'webp';
-      try { await fs.access(path.join(uploadsRoot, `${image}.webp`)); }
-      catch (error) { if (error.code !== 'ENOENT') throw error; extension = 'png'; }
-      file = await localFile({ path: path.join(uploadsRoot, `${image}.${extension}`), name: `image.${extension}` }, uploadsRoot);
-    }
-    imageBytes += file.bytes.length;
-    if (imageBytes > 8 * 1024 * 1024) throw new Error('压缩图片合计不能超过 8 MiB。');
-    uploads.push(file);
-  }
-  for (const original of originals) {
-    if (typeof original !== 'string' || !/\.(png|jpe?g|webp|gif)$/i.test(original)) throw new Error('原图路径无效。');
-  }
-  for (const file of [...originals.map(value => ({ path: value, name: path.basename(value) })), ...files]) {
-    const uploaded = await localFile(file, path.join(uploadsRoot, 'incoming'));
-    fileBytes += uploaded.bytes.length;
-    if (fileBytes > MAX_TOTAL_BYTES) throw new Error('文件合计不能超过 40 MiB。');
-    uploads.push(uploaded);
-  }
-  for (const file of uploads) {
-    if (/^image\/(?:png|jpeg|webp|gif)$/.test(file.mimeType)) {
-      const metadata = await sharp(file.bytes).metadata();
-      file.width = metadata.width; file.height = metadata.height;
-      if (!file.width || !file.height) throw new Error('无法读取 图片尺寸。');
-    }
-  }
-  if (uploads.filter(file => file.width).length > 4) throw new Error('每条消息最多 4 张图片。');
-  return uploads;
-}
+import fs from 'node:fs/promises';
+import { openAsBlob } from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import sharp from 'sharp';
+import media from '../shared/code-browser.cjs';
+import { validateInlineImage } from './message-images.mjs';
+import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_COUNT } from './file-upload-session.mjs';
+import { fileRevision } from './file-transfer-range.mjs';
+
+const mimeTypes = { pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
+  json: 'application/json', zip: 'application/zip', doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
+
+// Reuse the incoming-file contract without sending workstation bytes to the phone.
+export async function stageWorkstationMessageFile(file, uploadsRoot) {
+  const handle = await fs.open(file.path, 'r');
+  const session = createFileUploadSession(uploadsRoot);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
+    const validate = async () => {
+      if (fileRevision(await handle.stat()) !== file.revision || fileRevision(await fs.stat(file.path)) !== file.revision) {
+        throw new Error('电脑文件已变化，请重新添加。');
+      }
+    };
+    await validate();
+    const bytes = Buffer.alloc(FILE_CHUNK_BYTES);
+    const hash = crypto.createHash('sha256');
+    const readPart = async offset => {
+      const length = Math.min(bytes.length, stat.size - offset);
+      let count = 0;
+      while (count < length) {
+        const { bytesRead } = await handle.read(bytes, count, length - count, offset + count);
+        if (!bytesRead) throw new Error('电脑文件读取不完整，请重新添加。');
+        count += bytesRead;
+      }
+      return bytes.subarray(0, length);
+    };
+    for (let offset = 0; offset < stat.size; offset += FILE_CHUNK_BYTES) hash.update(await readPart(offset));
+    await validate();
+    const sha256 = hash.digest('hex');
+    const started = await session.receive({ type: 'start', fileKey: '0', name: file.name, size: stat.size, sha256 });
+    for (let offset = 0; offset < stat.size; offset += FILE_CHUNK_BYTES) {
+      await session.receive({ type: 'chunk', id: started.id, offset, data: await readPart(offset) });
+    }
+    await validate();
+    const result = await session.receive({ type: 'finish', id: started.id });
+    await session.receive({ type: 'commit' });
+    return { ...result, mediaKind: media.mediaKind(file),
+      mimeType: media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream' };
+  } finally { await handle.close(); await session.close(); }
+}
+
+async function localFile(file, directory) {
+  if (typeof file?.path !== 'string' || typeof file.name !== 'string' || !file.name || /[\r\n\0]/.test(file.name)) {
+    throw new Error('附件信息无效，请重新选择。');
+  }
+  const root = await fs.realpath(directory), resolved = await fs.realpath(file.path);
+  if (path.relative(root, path.dirname(resolved)) !== '') throw new Error('附件必须来自本次工作站上传目录。');
+  const handle = await fs.open(resolved, 'r');
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size < 1) throw new Error('附件为空。');
+    const bytes = await openAsBlob(resolved);
+    if (bytes.size !== stat.size) throw new Error('附件在读取时发生变化，请重新上传。');
+    const mimeType = media.mediaMime(file) || mimeTypes[path.extname(file.name).slice(1).toLowerCase()] || 'application/octet-stream';
+    if (!/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/i.test(mimeType)) throw new Error('附件类型无效。');
+    return { name: file.name, mimeType, bytes, path: resolved };
+  } finally { await handle.close(); }
+}
+
+export async function readMessageUploads(body, uploadsRoot) {
+  const images = body.images ?? [], originals = body.originalImages ?? [], files = body.files ?? [];
+  if (![images, originals, files].every(Array.isArray) || images.length + originals.length > 4 || files.length + originals.length > MAX_FILE_COUNT) {
+    throw new Error('每条消息最多 4 张图片、4 个文件。');
+  }
+  const uploads = [];
+  let imageBytes = 0;
+  for (const image of images) {
+    let file;
+    if (typeof image === 'string' && image.startsWith('data:')) {
+      validateInlineImage(image);
+      const mimeType = image.slice(5, image.indexOf(';'));
+      file = { name: `image.${mimeType.split('/')[1]}`, mimeType, bytes: Buffer.from(image.slice(image.indexOf(',') + 1), 'base64') };
+    } else {
+      if (typeof image !== 'string' || !/^[a-f0-9]{64}$/.test(image)) throw new Error('图片标识无效。');
+      let extension = 'webp';
+      try { await fs.access(path.join(uploadsRoot, `${image}.webp`)); }
+      catch (error) { if (error.code !== 'ENOENT') throw error; extension = 'png'; }
+      file = await localFile({ path: path.join(uploadsRoot, `${image}.${extension}`), name: `image.${extension}` }, uploadsRoot);
+    }
+    imageBytes += file.bytes.size ?? file.bytes.length;
+    if (imageBytes > 8 * 1024 * 1024) throw new Error('压缩图片合计不能超过 8 MiB。');
+    uploads.push(file);
+  }
+  for (const original of originals) {
+    if (typeof original !== 'string' || !/\.(png|jpe?g|webp|gif)$/i.test(original)) throw new Error('原图路径无效。');
+  }
+  for (const file of [...originals.map(value => ({ path: value, name: path.basename(value) })), ...files]) {
+    const uploaded = await localFile(file, path.join(uploadsRoot, 'incoming'));
+    uploads.push(uploaded);
+  }
+  for (const file of uploads) {
+    if (/^image\/(?:png|jpeg|webp|gif)$/.test(file.mimeType)) {
+      const metadata = await sharp(file.path || file.bytes).metadata();
+      file.width = metadata.width; file.height = metadata.height;
+      if (!file.width || !file.height) throw new Error('无法读取 图片尺寸。');
+    }
+  }
+  if (uploads.filter(file => file.width).length > 4) throw new Error('每条消息最多 4 张图片。');
+  return uploads;
+}

package/dist/src/runtime-discovery.mjs

@@ -3,8 +3,8 @@ import { discoverCodex, resolveCodexRuntime, runtimeFingerprint, runtimeInstalla
 // Advisory discovery is independent of execution health. Failure here must never
 // disable an already running app-server or cause an automatic process restart.
 export class RuntimeDiscovery {
-  constructor({ stateRoot, host, url, interval = 60000 }) {
-    Object.assign(this, { stateRoot, host, url, interval });
+  constructor({ stateRoot, host, url, interval = 60000, diagnose = () => {} }) {
+    Object.assign(this, { stateRoot, host, url, interval, diagnose });
     this.state = {};
   }
   start() { this.stopped = false; void this.tick(); }
@@ -13,19 +13,29 @@ export class RuntimeDiscovery {
     const errors = [];
     try {
       const candidates = discoverCodex();
-      const signature = JSON.stringify([await runtimeInstallationFingerprint(), candidates.map(candidate => {
+      const installation = await runtimeInstallationFingerprint();
+      const fingerprints = candidates.map(candidate => {
         try { return [candidate.executable, runtimeFingerprint(candidate.executable)]; }
         catch (error) { return [candidate.executable, error.message]; }
-      })]);
+      });
+      const signature = JSON.stringify([installation, fingerprints]);
+      if (signature !== this.diagnosticCandidateSignature) {
+        this.diagnosticCandidateSignature = signature;
+        this.diagnose('runtime-candidates', { installation, candidates: candidates.map((candidate, index) => ({
+          executable: candidate.executable, source: candidate.source, fingerprint: fingerprints[index][1] })) });
+      }
       if (signature !== this.signature) {
-        await resolveCodexRuntime(this.stateRoot, { refresh: true });
+        const selected = await resolveCodexRuntime(this.stateRoot, { refresh: true });
         this.signature = signature;
+        this.diagnose('runtime-selected', { version: selected.version, source: selected.source,
+          executable: selected.executable, runningKernelPreserved: true });
       }
     } catch (error) { errors.push(error.message); }
     try {
       if (this.host.desktopIntegration === false) {
         this.state = { desktop: { state: 'unsupported', integrationSupported: false }, checkedAt: new Date().toISOString() };
         if (errors.length) this.state.discoveryError = errors.join('\n');
+        this.diagnoseState();
         return this.state;
       }
       const desktop = await this.host.inspect();
@@ -38,8 +48,18 @@ export class RuntimeDiscovery {
       this.state = { checkedAt: new Date().toISOString() };
     }
     if (errors.length) this.state.discoveryError = errors.join('\n');
+    this.diagnoseState();
     return this.state;
   }
+  diagnoseState() {
+    const details = { desktop: this.state.desktop || null,
+      desktopRestartRecommended: this.state.desktopRestartRecommended === true,
+      discoveryError: this.state.discoveryError || null, runningKernelPreserved: true };
+    const signature = JSON.stringify(details);
+    if (signature === this.diagnosticStateSignature) return;
+    this.diagnosticStateSignature = signature;
+    this.diagnose('runtime-discovery', details);
+  }
   async tick() {
     await this.sample();
     if (!this.stopped) { this.timer = setTimeout(() => this.tick(), this.interval); this.timer.unref?.(); }

package/dist/src/self-relay/connector.mjs

@@ -3,7 +3,7 @@ import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
 import WebSocket from 'ws';
 import { decode, loopbackUrl, relayAddress, send } from './wire.mjs';
-import { routedFileBytes, parseFileBytes } from './file-wire.mjs';
+import { routedFileBytes, parseFileBytes, sendFileFrame } from './file-wire.mjs';
 import { attachRtcFile } from './rtc-file-bridge.mjs';
 import { createP2pProbe, validProbeSignal } from './p2p-probe.mjs';
 import { createWindowsRouteHelper } from './windows-route-helper.mjs';
@@ -217,23 +217,26 @@ export function connectBridgeRelay({ relayUrl, hostKey, bridgeUrl, bridgeToken,
         const message = decode(bytes, binary);
         if (message.type === 'file-host-ready') return;
         if (message.type === 'file-open') {
+          if (typeof message.clientId !== 'string' || !/^[\w-]{16,128}$/.test(message.clientId)) throw new Error('Invalid file client identity');
           const connection = bridgeConnection?.() || { url: bridgeUrl, token: bridgeToken };
           const url = new URL(connection.url); url.pathname = '/api/file-transfer';
           loopbackUrl(url.href, '/api/file-transfer');
           const socket = new WebSocket(url.href, { maxPayload: 512 * 1024, perMessageDeflate: false });
           fileLocals.set(message.session, socket);
-          socket.on('open', () => send(socket, { type: 'auth', token: connection.token, purpose: message.purpose }));
+          socket.on('open', () => send(socket, { type: 'auth', token: connection.token, purpose: message.purpose,
+            uploadSessionId: message.uploadSessionId, resumeUpload: message.resumeUpload,
+            relayClientId: message.clientId, fileRelay: true }));
           socket.on('error', error => events.emit('diagnostic', `Local file receiver: ${error.message}`));
           socket.on('close', () => {
             if (fileLocals.get(message.session) !== socket) return;
             fileLocals.delete(message.session);
-            send(receiver, { type: 'file-close', session: message.session });
+            sendFileFrame(receiver, { type: 'file-close', session: message.session });
           });
           socket.on('message', (data, isBinary) => {
             if (fileLocals.get(message.session) !== socket) return socket.terminate();
-            if (receiver.readyState !== WebSocket.OPEN || receiver.bufferedAmount > 1024 * 1024) return socket.close(1013, 'File receiver too slow');
-            if (isBinary) receiver.send(routedFileBytes(message.session, data));
-            else send(receiver, { type: 'file-frame', session: message.session, payload: data.toString() });
+            if (receiver.readyState !== WebSocket.OPEN) return socket.close(1011, 'File receiver unavailable');
+            if (isBinary) sendFileFrame(receiver, routedFileBytes(message.session, data));
+            else sendFileFrame(receiver, { type: 'file-frame', session: message.session, payload: data.toString() });
           });
         } else if (message.type === 'file-frame') {
           const socket = fileLocals.get(message.session);

package/dist/src/self-relay/file-wire.mjs

@@ -11,3 +11,66 @@ export function parseFileBytes(bytes) {
   if (!/^[a-f0-9-]{36}$/.test(session)) throw new Error('Invalid file session');
   return { session, data: bytes.subarray(36) };
 }
+
+const senders = new WeakMap();
+// A workstation multiplexes up to eight three-chunk windows. Keep that burst
+// bounded without dropping every transfer when one shared socket gets busy.
+export function sendFileFrame(socket, data, { bytesPerSecond = 0, session = data?.session } = {}) {
+  if (!socket || socket.readyState !== socket.OPEN) return false;
+  let state = senders.get(socket);
+  if (!state) {
+    state = { queue: [], bytes: 0, active: false, nextAt: 0, timer: null, closed: false, bytesPerSecond };
+    senders.set(socket, state);
+    socket.once('close', () => {
+      state.closed = true; clearTimeout(state.timer); state.queue.length = 0; state.bytes = 0;
+    });
+  }
+  if (state.closeAfter) return false;
+  const payload = typeof data === 'string' || Buffer.isBuffer(data) ? data : JSON.stringify(data);
+  const size = Buffer.byteLength(payload);
+  if (size > 512 * 1024 || state.bytes + size > 8 * 1024 * 1024 || state.queue.length >= 128) {
+    socket.close(1013, 'File receiver too slow'); return false;
+  }
+  state.queue.push({ payload, size, session }); state.bytes += size;
+  const pump = () => {
+    if (state.active || state.closed || socket.readyState !== socket.OPEN) return;
+    if (!state.queue.length) {
+      if (state.closeAfter) socket.close(state.closeAfter.code, state.closeAfter.reason);
+      return;
+    }
+    const wait = state.nextAt - performance.now();
+    if (wait > 1) {
+      if (!state.timer) state.timer = setTimeout(() => { state.timer = null; pump(); }, wait);
+      return;
+    }
+    const frame = state.queue.shift(); state.active = true;
+    if (state.bytesPerSecond) state.nextAt = performance.now() + frame.size * 1000 / state.bytesPerSecond;
+    socket.send(frame.payload, error => {
+      if (state.closed) return;
+      state.bytes -= frame.size; state.active = false;
+      if (error) { socket.close(1011, 'File delivery failed'); return; }
+      pump();
+    });
+  };
+  state.pump = pump;
+  pump();
+  return true;
+}
+
+// Preserve an error/ack already queued before ending this file connection.
+// Revocation and account expiry deliberately use immediate socket.close instead.
+export function closeFileSocket(socket, code, reason) {
+  const state = senders.get(socket);
+  if (!state) { socket.close(code, reason); return; }
+  state.closeAfter = { code, reason };
+  state.pump();
+}
+
+export function discardFileSession(socket, session) {
+  const state = senders.get(socket);
+  if (!state) return;
+  state.queue = state.queue.filter(frame => {
+    if (frame.session !== session) return true;
+    state.bytes -= frame.size; return false;
+  });
+}

package/dist/src/self-relay/server.mjs

@@ -9,7 +9,7 @@ import { deviceStore, validId } from './device-store.mjs';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { WebSocketServer } from 'ws';
 import { secret, digest, matches, validSecret, send, decode } from './wire.mjs';
-import { routedFileBytes, parseFileBytes } from './file-wire.mjs';
+import { routedFileBytes, parseFileBytes, sendFileFrame, closeFileSocket, discardFileSession } from './file-wire.mjs';
 import { readDebugAllowlist, debugAllowed } from './debug-allowlist.mjs';
 import { validProbeSignal } from './p2p-probe.mjs';
 import { MAX_ADMIN_REQUEST_BYTES, relayAdminState } from './admin-state.mjs';
@@ -137,7 +137,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
       observer?.ws.close(4401, 'Device authorization revoked');
       for (const [key, upload] of room.uploadClients || []) if (upload.clientId === message.id) {
         room.uploadClients.delete(key);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session: upload.session });
+        if (room.uploadHost) {
+          discardFileSession(room.uploadHost, upload.session);
+          send(room.uploadHost, { type: 'file-close', session: upload.session });
+        }
         upload.ws.close(4401, 'Device authorization revoked');
       }
       for (const [socket, id] of room.deviceManagers || []) if (id === message.id) {
@@ -245,7 +248,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         for (const [clientId, upload] of room.uploadClients) {
           if (upload.userId !== userId) continue;
           room.uploadClients.delete(clientId);
-          if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session: upload.session });
+          if (room.uploadHost) {
+            discardFileSession(room.uploadHost, upload.session);
+            send(room.uploadHost, { type: 'file-close', session: upload.session });
+          }
           upload.ws.close(4431, 'Account cancelled');
         }
       }
@@ -438,7 +444,10 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         if (room.host) send(room.host, { type: 'detach', session });
       } else if (role === 'file-client' && room?.uploadClients.get(session)?.ws === ws) {
         room.uploadClients.delete(session);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session });
+        if (room.uploadHost) {
+          discardFileSession(room.uploadHost, session);
+          send(room.uploadHost, { type: 'file-close', session });
+        }
       }
       ws.close(4431, 'Account session invalid');
     }
@@ -491,7 +500,7 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
         for (const client of room.uploadClients?.values() || []) client.ws.close(code === 4432 ? 4432 : 4410, code === 4432 ? 'File receiver inbound queue limit exceeded' : 'File receiver offline');
       } else if (role === 'file-client' && room?.uploadClients?.get(session)?.ws === ws) {
         room.uploadClients.delete(session);
-        if (room.uploadHost) send(room.uploadHost, { type: 'file-close', session });
+        if (room.uploadHost) sendFileFrame(room.uploadHost, { type: 'file-close', session }, { bytesPerSecond: 4 * 1024 * 1024 });
       }
     });
     let messageTail = Promise.resolve();
@@ -533,13 +542,11 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
             const frame = parseFileBytes(bytes);
             const client = room.uploadClients.get(frame.session);
             if (!client || client.ws.readyState !== ws.OPEN) return;
-            if (client.ws.bufferedAmount > 1024 * 1024) return client.ws.close(1013, 'File receiver too slow');
-            client.ws.send(frame.data); return;
+            sendFileFrame(client.ws, frame.data, { bytesPerSecond: 1024 * 1024 }); return;
           }
           if (role === 'file-client' && room.uploadClients?.get(session)?.ws === ws) {
             if (room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
-            if (room.uploadHost.bufferedAmount > 1024 * 1024) return fail(1013, 'File receiver too slow');
-            room.uploadHost.send(routedFileBytes(session, bytes)); return;
+            sendFileFrame(room.uploadHost, routedFileBytes(session, bytes), { bytesPerSecond: 4 * 1024 * 1024, session }); return;
           }
           return fail(1008, 'Invalid binary frame');
         }
@@ -577,16 +584,31 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
                 !matches(message.credential, client.hash)) return fail();
             room.uploadClients ||= new Map();
             if (!['upload', 'download'].includes(message.purpose)) return fail(1008, 'Invalid file purpose');
-            const same = [...room.uploadClients.values()].filter(item => item.clientId === message.clientId && item.purpose === message.purpose);
-            const all = [...rooms.values()].flatMap(item => [...(item.uploadClients?.values() || [])]);
+            if (message.purpose === 'upload' && (typeof message.uploadSessionId !== 'string' ||
+                !/^[a-f0-9-]{36}$/.test(message.uploadSessionId) || typeof message.resumeUpload !== 'boolean')) {
+              return fail(1008, 'Invalid upload session');
+            }
+            if (!await recordConnection(room, message.clientId, new Date().toISOString(), deviceInfo(message))) return fail(4401, 'Device authorization revoked');
+            if (ws.readyState !== ws.OPEN || !accountConnection.valid()) return;
+            if (room.host?.readyState !== ws.OPEN || room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
+            if (room.status !== 'active' || !room.clients.some(item => item.id === message.clientId && matches(message.credential, item.hash))) return fail(4401, 'Device authorization revoked');
+            const replacing = message.purpose === 'upload' ? [...room.uploadClients.values()].filter(item =>
+              item.clientId === message.clientId && item.uploadSessionId === message.uploadSessionId) : [];
+            const same = [...room.uploadClients.values()].filter(item => item.clientId === message.clientId && item.purpose === message.purpose && !replacing.includes(item));
+            const all = [...rooms.values()].flatMap(item => [...(item.uploadClients?.values() || [])]).filter(item => !replacing.includes(item));
             if (same.length >= (message.purpose === 'upload' ? 1 : 3) ||
                 all.length >= 8 || (message.purpose === 'upload' && all.filter(item => item.purpose === 'upload').length >= 2)) {
               return fail(4429, 'Too many file transfers');
             }
+            for (const old of replacing) {
+              room.uploadClients.delete(old.session);
+              sendFileFrame(room.uploadHost, { type: 'file-close', session: old.session }, { bytesPerSecond: 4 * 1024 * 1024 });
+              old.ws.close(4409, 'Upload connection replaced');
+            }
             role = 'file-client'; clientId = message.clientId; session = randomUUID(); clearTimeout(authTimer);
-            if (!await recordConnection(room, clientId, new Date().toISOString(), deviceInfo(message))) return fail(4401, 'Device authorization revoked');
-            room.uploadClients.set(session, { ws, session, clientId, userId, purpose: message.purpose });
-            send(room.uploadHost, { type: 'file-open', session, purpose: message.purpose }); return;
+            room.uploadClients.set(session, { ws, session, clientId, userId, purpose: message.purpose, uploadSessionId: message.uploadSessionId });
+            sendFileFrame(room.uploadHost, { type: 'file-open', session, purpose: message.purpose, clientId,
+              uploadSessionId: message.uploadSessionId, resumeUpload: message.resumeUpload }, { bytesPerSecond: 4 * 1024 * 1024 }); return;
           }
           if (message.type === 'host') {
             const durable = message.deviceId !== undefined;
@@ -881,7 +903,13 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
               connection.ws.close(4401, 'Device authorization revoked');
             }
             room.connections.clear();
-            for (const client of room.uploadClients?.values() || []) client.ws.close(4401, 'Device authorization revoked');
+            for (const client of room.uploadClients?.values() || []) {
+              if (room.uploadHost) {
+                discardFileSession(room.uploadHost, client.session);
+                send(room.uploadHost, { type: 'file-close', session: client.session });
+              }
+              client.ws.close(4401, 'Device authorization revoked');
+            }
             room.uploadClients?.clear();
             for (const observer of room.observers.values()) observer.ws.close(4401, 'Device authorization revoked');
             room.observers.clear();
@@ -909,14 +937,13 @@ export async function startSelfRelay({ port = 0, hostKey = secret(), pairingTtlM
           const client = room.uploadClients.get(message.session);
           if (!client) return;
           if (message.type === 'file-frame' && typeof message.payload === 'string' && message.payload.length <= 512 * 1024) {
-            if (client.ws.bufferedAmount > 1024 * 1024) return client.ws.close(1013, 'File receiver too slow');
-            send(client.ws, { type: 'file-frame', payload: message.payload });
-          } else if (message.type === 'file-close') client.ws.close(1011, 'File receiver unavailable');
+            sendFileFrame(client.ws, { type: 'file-frame', payload: message.payload }, { bytesPerSecond: 1024 * 1024 });
+          } else if (message.type === 'file-close') closeFileSocket(client.ws, 1011, 'File receiver unavailable');
           else fail(1008, 'Invalid file frame');
         } else if (role === 'file-client' && room.uploadClients?.get(session)?.ws === ws) {
           if (message.type !== 'file-frame' || typeof message.payload !== 'string' || message.payload.length > 512 * 1024) return fail(1008, 'Invalid file frame');
-          if (room.uploadHost?.bufferedAmount > 1024 * 1024) return fail(1013, 'File receiver too slow');
-          send(room.uploadHost, { type: 'file-frame', session, payload: message.payload });
+          if (room.uploadHost?.readyState !== ws.OPEN) return fail(4410, 'File receiver offline');
+          sendFileFrame(room.uploadHost, { type: 'file-frame', session, payload: message.payload }, { bytesPerSecond: 4 * 1024 * 1024 });
         } else if (role === 'observer' && room.observers.get(clientId)?.ws === ws && message.type === 'official-computer') {
           const computer = normalizeOfficialComputer(message);
           await commit(room, { officialComputer: computer });