@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/shared/code-browser.cjs

@@ -0,0 +1,159 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeBrowserProtocol = factory();
+})(globalThis, function () {
+  const maxBytes = 1024 * 1024, maxEntries = 4000, maxLines = 20000;
+  const maxFileBytes = 20 * 1024 * 1024, imageChunkBytes = 3 * 1024 * 1024;
+  const mediaTypes = { jpg:'image/jpeg', jpeg:'image/jpeg', png:'image/png', webp:'image/webp', gif:'image/gif', bmp:'image/bmp', heic:'image/heic', heif:'image/heif', avif:'image/avif', tif:'image/tiff', tiff:'image/tiff', svg:'image/svg+xml', ico:'image/x-icon', mp4:'video/mp4', m4v:'video/mp4', mov:'video/quicktime', webm:'video/webm', mkv:'video/x-matroska', avi:'video/x-msvideo', '3gp':'video/3gpp', '3g2':'video/3gpp2', mpg:'video/mpeg', mpeg:'video/mpeg', m2ts:'video/mp2t', flv:'video/x-flv', wmv:'video/x-ms-wmv' };
+  const mediaMime = file => file.mimeType || (/^(image|video)\//.test(file.type || '') ? file.type : '') || mediaTypes[(file.name || file.path || '').split('.').at(-1).toLowerCase()] || '';
+  const mediaKind = file => file.mediaKind || (/^image\//.test(mediaMime(file)) ? 'image' : /^video\//.test(mediaMime(file)) ? 'video' : '');
+  function imageMime(bytes) {
+    const ascii = (start, count) => String.fromCharCode(...bytes.slice(start, start + count));
+    if (bytes[0] === 137 && ascii(1, 3) === 'PNG' && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return 'image/png';
+    if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return 'image/jpeg';
+    if (['GIF87a', 'GIF89a'].includes(ascii(0, 6))) return 'image/gif';
+    if (ascii(0, 4) === 'RIFF' && ascii(8, 4) === 'WEBP') return 'image/webp';
+    fail('不支持此图片格式，当前支持 PNG、JPEG、GIF、WebP。', 415);
+  }
+  function fail(message, statusCode = 400) { throw Object.assign(new Error(message), { statusCode }); }
+  function canonical(value) {
+    return String(value || '').replaceAll('\\', '/').replace(/\/+$/, '');
+  }
+  function key(value) {
+    const p = canonical(value);
+    return /^[a-z]:\//i.test(p) || p.startsWith('//') ? p.toLowerCase() : p;
+  }
+  function inside(base, candidate) {
+    const a = key(base), b = key(candidate);
+    return b === a || b.startsWith(a + '/');
+  }
+  function relative(base, candidate) {
+    if (!inside(base, candidate)) return null;
+    return canonical(candidate).slice(canonical(base).length).replace(/^\//, '');
+  }
+  function child(base, value = '') {
+    if (typeof value !== 'string' || /[\\:\x00-\x1f]/.test(value) || value.startsWith('/') ||
+        value.split('/').some(p => p === '..' || p === '.' || (p && /[. ]$/.test(p)))) fail('无效的项目相对路径。');
+    return canonical(base) + (value ? '/' + value : '') || '/';
+  }
+  async function context(rpc, query) {
+    const threadId = query.get('threadId'), projectId = query.get('projectId');
+    let thread, project;
+    if (threadId) ({ thread } = await rpc('thread/read', { threadId, includeTurns: false }));
+    const id = thread?.projectId || (!threadId && projectId);
+    if (id && id !== '__unassigned__') ({ project } = await rpc('project/read', { projectId: id }));
+    const roots = [];
+    const add = (p, source) => {
+      if (typeof p !== 'string' || !p || roots.some(r => key(r.path) === key(p))) return;
+      roots.push({ path: p, source });
+    };
+    for (const r of project?.roots || []) add(r.path, '项目');
+    const environments = thread?.environments || [];
+    const local = environments.find(e => e.environmentId === 'local');
+    if (environments.length && !local) fail('当前会话使用远程执行环境，暂不支持本机文件浏览。', 409);
+    const cwd = local?.cwd || thread?.cwd || '';
+    // Runtime access roots include tool output directories, not project membership.
+    if (!project && cwd) add(cwd, '工作目录');
+    if (!roots.length) fail('请先选择一个项目或对话。', 404);
+    return { roots, cwd, projectName: project?.name || '', threadId };
+  }
+  function selectedRoot(context, query) {
+    const root = context.roots.find(r => key(r.path) === key(query.get('root')));
+    if (!root) fail('目录不属于当前项目或会话，请刷新后重试。', 403);
+    return root.path;
+  }
+  function directory(result) {
+    if (!Array.isArray(result.entries)) fail('工作站没有返回目录条目。', 502);
+    if (result.entries.length > maxEntries) fail('此目录超过 4000 项，暂不支持浏览。', 413);
+    const entries = result.entries.map(e => {
+      if (!e.fileName || /[/\\:\x00-\x1f]/.test(e.fileName) || ['.', '..'].includes(e.fileName)) fail('目录条目名称无效。', 502);
+      return { name: e.fileName, directory: e.isDirectory === true, file: e.isFile === true };
+    });
+    entries.sort((a, b) => Number(b.directory) - Number(a.directory) || a.name.localeCompare(b.name));
+    return { entries };
+  }
+  function decode(bytes) {
+    if (bytes.length > maxBytes) fail('文件超过只读预览上限（1 MiB）。', 413);
+    let encoding = 'utf-8';
+    if (bytes[0] === 255 && bytes[1] === 254) encoding = 'utf-16le';
+    else if (bytes[0] === 254 && bytes[1] === 255) encoding = 'utf-16be';
+    let text;
+    try { text = new TextDecoder(encoding, { fatal: true }).decode(bytes); }
+    catch { fail('此文件不是可识别的 UTF-8/UTF-16 文本，暂不支持预览。', 415); }
+    if (/[\x00-\x08\x0e-\x1f]/.test(text)) fail('此文件包含二进制内容，暂不支持文本预览。', 415);
+    if (text.split('\n').length > maxLines) fail('文件超过 20000 行，暂不支持预览。', 413);
+    return { text, encoding, size: bytes.length };
+  }
+  function fromBase64(value) {
+    if (typeof value !== 'string') fail('工作站没有返回文件内容。', 502);
+    if (value.length > Math.ceil(maxBytes / 3) * 4) fail('文件超过只读预览上限（1 MiB）。', 413);
+    const { encoding, size } = decode(Uint8Array.from(atob(value), c => c.charCodeAt(0)));
+    return { dataBase64: value, encoding, size };
+  }
+  function diffLines(text) {
+    let old = 0, newer = 0, oldLeft = 0, newLeft = 0;
+    return text.replace(/\r\n/g, '\n').split('\n').map(text => {
+      const row = { text, old: '', newer: '', kind: '' };
+      const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(text);
+      if (hunk) {
+        old = Number(hunk[1]); oldLeft = Number(hunk[2] ?? 1);
+        newer = Number(hunk[3]); newLeft = Number(hunk[4] ?? 1); row.kind = 'hunk';
+      } else if (text.startsWith('+') && newLeft > 0) {
+        row.newer = newer++; newLeft--; row.kind = 'add';
+      } else if (text.startsWith('-') && oldLeft > 0) {
+        row.old = old++; oldLeft--; row.kind = 'remove';
+      } else if (text.startsWith(' ') && oldLeft > 0 && newLeft > 0) {
+        row.old = old++; row.newer = newer++; oldLeft--; newLeft--;
+      } else if (!text.startsWith('\\')) { oldLeft = 0; newLeft = 0; }
+      return row;
+    });
+  }
+  async function change(rpc, query) {
+    const threadId = query.get('threadId'), turnId = query.get('turnId');
+    const itemId = query.get('itemId'), path = query.get('path');
+    if (!threadId || !turnId || !itemId || !path) fail('缺少文件修改记录的定位信息。');
+    let cursor;
+    do {
+      // Only an explicit detail click reads raw items, within the selected turn.
+      const page = await rpc('thread/items/list', { threadId, turnId, limit: 100,
+        sortDirection: 'desc', ...(cursor ? { cursor } : {}) });
+      const item = page.data?.find(entry => entry.turnId === turnId && entry.item?.id === itemId)?.item;
+      if (item) {
+        const file = item.type === 'fileChange' && item.changes?.find(value => value.path === path);
+        if (!file) fail('这条修改记录中没有该文件。', 404);
+        const diff = typeof file.diff === 'string' ? file.diff : file.diff?.text;
+        if (typeof diff !== 'string') fail('此条目未提供真实 diff。', 404);
+        if (new TextEncoder().encode(diff).length > maxBytes || diff.split('\n').length > maxLines) fail('此项 diff 超过预览上限。', 413);
+        return { diff, turnId };
+      }
+      if (page.nextCursor && page.nextCursor === cursor) fail('修改记录分页位置未推进。', 502);
+      cursor = page.nextCursor;
+    } while (cursor);
+    fail('未找到这条文件修改记录。', 404);
+  }
+  async function changes(rpc, query) {
+    const threadId = query.get('threadId');
+    if (!threadId) fail('请先选择对话以查看修改记录。');
+    const cursor = query.get('cursor');
+    const page = await rpc('thread/items/list', { threadId, limit: 20, sortDirection: 'desc', ...(cursor ? { cursor } : {}) });
+    const changes = []; let diffBytes = 0;
+    for (const entry of page.data || []) {
+      if (entry.item?.type !== 'fileChange') continue;
+      for (const change of entry.item.changes || []) {
+        const diff = typeof change.diff === 'string' ? change.diff : change.diff?.text;
+        const bytes = typeof diff === 'string' ? new TextEncoder().encode(diff).length : 0;
+        const tooLarge = typeof diff === 'string' && (bytes + diffBytes > maxBytes || diff.split('\n').length > maxLines);
+        if (!tooLarge) diffBytes += bytes;
+        changes.push({ path: change.path, kind: change.kind, turnId: entry.turnId, itemId: entry.item.id,
+          diff: tooLarge ? null : diff ?? null, error: tooLarge ? '此项 diff 超过预览上限。' : '' });
+      }
+    }
+    // Return an explicit page even when it has no file changes. Never scan a whole thread implicitly.
+    return { changes, nextCursor: page.nextCursor || null, scope: '对话文件修改记录（按操作展示）' };
+  }
+  function isTextFile(name) {
+    const base = String(name || '').replaceAll('\\', '/').split('/').at(-1);
+    return !base.includes('.') || (base.startsWith('.') && !base.slice(1).includes('.')) || /\.(txt|log|md|markdown|rst|csv|tsv|json5?|jsonl|ipynb|ya?ml|toml|ini|cfg|conf|config|xml|xaml|svg|html?|css|scss|less|[cm]?js|jsx|ts|tsx|ets|py|rs|go|java|kt|kts|c|cc|cpp|cxx|h|hpp|cs|swift|m|mm|sh|bash|zsh|ps1|bat|cmd|sql|r|rb|php|vue|svelte|gradle|properties|cmake|make|diff|patch)$/i.test(base);
+  }
+  return { isTextFile, maxBytes, maxEntries, maxLines, maxFileBytes, mediaMime, mediaKind, imageChunkBytes, imageMime, fail, key, inside, relative, child, context, selectedRoot, directory, decode, fromBase64, diffLines, change, changes };
+});

package/dist/shared/file-changes.cjs

@@ -0,0 +1,31 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexFileChanges = factory();
+})(globalThis, function () {
+  function lineCounts(change) {
+    const diff = typeof change.diff === 'string' ? change.diff : change.diff?.text;
+    if (typeof diff !== 'string') return { added: change.lineCounts?.added || 0, removed: change.lineCounts?.removed || 0 };
+    const kind = typeof change.kind === 'string' ? change.kind : change.kind?.type;
+    if (kind === 'add' || kind === 'delete') {
+      // app-server sends the full file content, not a unified diff, for add/delete.
+      const lines = diff ? diff.split('\n').length - Number(diff.endsWith('\n')) : 0;
+      return { added: kind === 'add' ? lines : 0, removed: kind === 'delete' ? lines : 0 };
+    }
+    let added = 0, removed = 0, oldLeft = 0, newLeft = 0;
+    for (const line of diff.split(/\r?\n/)) {
+      const hunk = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(line);
+      if (hunk) { oldLeft = Number(hunk[1] ?? 1); newLeft = Number(hunk[2] ?? 1); }
+      else if (line.startsWith('+') && newLeft > 0) { added++; newLeft--; }
+      else if (line.startsWith('-') && oldLeft > 0) { removed++; oldLeft--; }
+      else if (line.startsWith(' ') && oldLeft > 0 && newLeft > 0) { oldLeft--; newLeft--; }
+      else if (!line.startsWith('\\')) { oldLeft = 0; newLeft = 0; }
+    }
+    return { added, removed };
+  }
+  function summarize(changes) {
+    return (Array.isArray(changes) ? changes : []).map(change => ({
+      path: change.path, kind: change.kind, lineCounts: lineCounts(change),
+    }));
+  }
+  return { lineCounts, summarize };
+});

package/dist/shared/file-citations.cjs

@@ -0,0 +1,117 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else root.CodexFileCitations = api;
+})(globalThis, function () {
+  const prefix = ':codex-file-citation{';
+
+  function parse(source, start) {
+    if (!source.startsWith(prefix, start)) return null;
+    const attributes = Object.create(null);
+    let position = start + prefix.length;
+    while (position < source.length) {
+      while (/[ \t]/.test(source[position] || '')) position++;
+      if (source[position] === '}') return { attributes, end: position + 1 };
+      const key = /^[A-Za-z_][\w-]*/.exec(source.slice(position));
+      if (!key) return null;
+      position += key[0].length;
+      const afterKey = position;
+      while (/[ \t]/.test(source[position] || '')) position++;
+      let value = '';
+      const assigned = source[position] === '=';
+      if (assigned) {
+        position++;
+        while (/[ \t]/.test(source[position] || '')) position++;
+        const quote = source[position];
+        if (quote === '"' || quote === "'") {
+          position++;
+          while (position < source.length && source[position] !== quote) {
+            if (/[\r\n]/.test(source[position])) return null;
+            if (source[position] === '\\' && source[position + 1] === quote) position++;
+            value += source[position++];
+          }
+          if (source[position++] !== quote) return null;
+        } else {
+          const match = /^[^\s{}"']+/.exec(source.slice(position));
+          if (!match) return null;
+          value = match[0];
+          position += value.length;
+        }
+      }
+      attributes[key[0]] = value;
+      if ((assigned || position === afterKey) && source[position] !== '}' && !/[ \t]/.test(source[position] || '')) return null;
+    }
+    return null;
+  }
+
+  function positiveLine(value) {
+    const line = /^\d+$/.test(value || '') ? Number(value) : 0;
+    return Number.isSafeInteger(line) && line > 0 ? line : null;
+  }
+
+  function localReference(source) {
+    if (typeof source !== 'string' || /[\x00-\x1f]/.test(source)) return null;
+    let reference = source, fragment = '';
+    if (/^file:/i.test(reference)) {
+      if (!/^file:\//i.test(reference)) return null;
+      let url;
+      try { url = new URL(reference); } catch { return null; }
+      // A file URL names the connected host's local filesystem, not a network share.
+      if ((url.hostname && url.hostname.toLowerCase() !== 'localhost') || url.search) return null;
+      reference = url.pathname;
+      fragment = url.hash;
+    } else {
+      const anchor = reference.match(/#L\d+(?:C\d+)?(?:-L\d+)?$/i);
+      if (anchor) { fragment = anchor[0]; reference = reference.slice(0, anchor.index); }
+    }
+    const position = reference.match(/:(\d+)(?::(\d+))?$/);
+    if (position) reference = reference.slice(0, position.index);
+    const anchor = /^#L(\d+)(?:C(\d+))?(?:-L(\d+))?$/i.exec(fragment);
+    if (fragment && !anchor) return null;
+    const line = positiveLine(anchor?.[1] ?? position?.[1]);
+    const column = positiveLine(anchor ? anchor[2] : position?.[2]);
+    const end = positiveLine(anchor?.[3]);
+    // Decode only URL syntax, once; preserve encoded punctuation in actual filenames.
+    try { reference = decodeURIComponent(reference); } catch { return null; }
+    reference = reference.replace(/^\/(?=[a-z]:[\\/])/i, '');
+    if (reference.replaceAll('\\', '/').startsWith('//')) return null;
+    if (/[\x00-\x1f]/.test(reference) || !/^(?:[a-z]:[\\/]|\/(?!\/))/i.test(reference)) return null;
+    return { path: reference, line, column, end: line && end >= line ? end : null };
+  }
+
+  function install(markdown) {
+    const validateLink = markdown.validateLink.bind(markdown);
+    markdown.validateLink = value => /^file:/i.test(value) ? localReference(value) !== null : validateLink(value);
+    markdown.inline.ruler.before('text', 'codex_file_citation', (state, silent) => {
+      if (!state.env?.allowFileCitations || state.linkLevel > 0) return false;
+      const result = parse(state.src, state.pos);
+      const attributes = result?.attributes;
+      const path = attributes?.path?.trim();
+      if (!path || /[\0\r\n]/.test(path)) return false;
+      const fileUrl = /^file:/i.test(path) ? localReference(path) : null;
+      const local = fileUrl !== null || /^(?:[a-z]:[\\/]|\/(?!\/))/i.test(path);
+      if (!local && !/^https?:\/\//i.test(path)) return false;
+      const filePath = fileUrl?.path || path;
+      const line = local ? positiveLine(attributes.lineRangeStart ?? attributes.line_range_start ?? fileUrl?.line) : null;
+      const end = local ? positiveLine(attributes.lineRangeEnd ?? attributes.line_range_end ?? fileUrl?.end) : null;
+      // A citation path is a literal filename; location belongs to its own fields.
+      const reference = local ? encodeURI(filePath).replace(/[:?#]/g, encodeURIComponent) + (line ? `:${line}` : '') : path;
+      const href = markdown.normalizeLink(reference);
+      if (!markdown.validateLink(href)) return false;
+      if (!silent) {
+        const link = state.push('link_open', 'a', 1);
+        link.attrSet('href', href);
+        link.attrSet('title', path);
+        link.meta = { fileCitation: { path: filePath, line, end: line && end >= line ? end : null, purpose: attributes.purpose } };
+        const label = state.push('text', '', 0);
+        label.content = local ? filePath.split(/[\\/]/).filter(Boolean).at(-1) || filePath
+          : attributes.label || attributes.title || path;
+        state.push('link_close', 'a', -1);
+      }
+      state.pos = result.end;
+      return true;
+    });
+  }
+
+  return Object.freeze({ install, localReference });
+});

package/dist/shared/file-mentions.cjs

@@ -0,0 +1,92 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  else root.CodexFileMentions = api;
+})(globalThis, function () {
+  const heading = '# Files mentioned by the user:';
+  const pastedHeading = '# Files pasted by the user:';
+  const request = '## My request:';
+
+  function stripBrowserContext(value) {
+    const context = /^\s*<in-app-browser-context\b[^>]*>[\s\S]*?<\/in-app-browser-context>\s*/;
+    if (!context.test(value)) return value;
+    return value.replace(context, '').replace(/^## My request:[ \t]*(?:\r?\n|$)/, '').trim();
+  }
+
+  function parse(value) {
+    const source = stripBrowserContext(typeof value === 'string' ? value : '');
+    const firstHeading = [heading, pastedHeading].find(value => source.startsWith(value));
+    if (!firstHeading) return { text: source, files: [] };
+    const marker = source.indexOf(`\n${request}`, firstHeading.length);
+    if (marker < 0) return { text: source, files: [] };
+    const files = [];
+    let pasted = firstHeading === pastedHeading;
+    for (const line of source.slice(firstHeading.length, marker).split(/\r?\n/)) {
+      if (line === heading || line === pastedHeading) { pasted = line === pastedHeading; continue; }
+      if (line.startsWith('Uploaded file: ')) {
+        try {
+          const value = JSON.parse(line.slice('Uploaded file: '.length));
+          const fileId = /^sediment:\/\/([A-Za-z0-9_-]{1,256})$/.exec(value.pointer)?.[1];
+          if (fileId && typeof value.fileName === 'string' && value.fileName) files.push({ type: 'file', name: value.fileName, fileId });
+        } catch { /* Leave unrecognized text untouched when no attachment was parsed. */ }
+        continue;
+      }
+      const media = /^<!-- code-relax-media:(.+) -->$/.exec(line);
+      if (media && files.length) {
+        try { Object.assign(files.at(-1), mediaMetadata(JSON.parse(media[1]))); } catch {}
+        continue;
+      }
+      if (!pasted && line.trim() === 'Image attachment: true' && files.length) {
+        files.at(-1).isImageAttachment = true;
+        continue;
+      }
+      const match = /^## (.+): ((?:[A-Za-z]:[\\/]|\/)[^\r\n]+)$/.exec(line);
+      if (!match) continue;
+      let name = match[1];
+      if (name.startsWith('"')) {
+        try { name = JSON.parse(name); } catch { continue; }
+      }
+      if (typeof name !== 'string' || !name) continue;
+      files.push({ type: 'file', name: pasted ? match[2].split(/[\\/]/).at(-1) : name, path: match[2] });
+    }
+    if (!files.length) return { text: source, files: [] };
+    return { text: stripBrowserContext(source.slice(marker + request.length + 1).trim()), files };
+  }
+
+  function wrap(prompt, files) {
+    if (!files?.length) return prompt;
+    return `${heading}\n${files.map(file => {
+      const media = mediaMetadata(file);
+      return `\n## ${JSON.stringify(file.name)}: ${file.path}\n${media.mediaKind ? `<!-- code-relax-media:${JSON.stringify(media).replace(/</g, '\\u003c').replace(/>/g, '\\u003e')} -->\n` : ''}`;
+    }).join('')}\n${request}\n${prompt || '请查看上述文件。'}`;
+  }
+
+  function mediaMetadata(value) {
+    if (!value || !['image', 'video'].includes(value.mediaKind)) return {};
+    const result = { mediaKind: value.mediaKind };
+    for (const field of ['sha256', 'previewSha256']) if (/^[a-f0-9]{64}$/.test(value[field] || '')) result[field] = value[field];
+    if (typeof value.previewPath === 'string' && /^(?:[A-Za-z]:[\\/]|\/(?!\/))[^\r\n]+$/.test(value.previewPath)) result.previewPath = value.previewPath;
+    if (/^(?:image|video)\/[a-z0-9.+-]+$/i.test(value.mimeType || '')) result.mimeType = value.mimeType;
+    for (const field of ['size', 'duration']) if (Number.isFinite(value[field]) && value[field] > 0) result[field] = value[field];
+    return result;
+  }
+
+  // Formats accepted as native Codex image inputs; other files remain file references.
+  function isNativeImage(file) {
+    return file?.mediaKind === 'image' && /\.(png|jpe?g|webp|gif)$/i.test(file.name || file.path || '');
+  }
+  function attachment(file) {
+    return isNativeImage(file) ? { type: 'image', name: file.name, remotePath: file.path,
+      originalUpload: true, localImageId: file.sha256, localThumbnailId: file.previewSha256 }
+      : { ...file, type: 'file' };
+  }
+  function originalInputs(body) {
+    const paths = body.originalImages || [];
+    if (!Array.isArray(paths) || paths.length + (body.images || []).length > 4
+      || paths.some(value => typeof value !== 'string' || !/^(?:[A-Za-z]:[\\/]|\/(?!\/))[^\r\n]+\.(png|jpe?g|webp|gif)$/i.test(value))) {
+      throw new Error('原图路径无效或每条消息图片超过 4 张');
+    }
+    return paths.map(path => ({ type: 'localImage', path }));
+  }
+  return Object.freeze({ parse, wrap, mediaMetadata, isNativeImage, attachment, originalInputs });
+});

package/dist/shared/message-delivery.cjs

@@ -0,0 +1,100 @@
+(function (root, factory) {
+  const value = factory();
+  if (typeof module === 'object' && module.exports) module.exports = value;
+  else root.CodexMessageDelivery = value;
+})(globalThis, function () {
+  function rejectedBeforeSubmission(error) {
+    return error?.rpcCode === -32602 || error?.rpcCode === -32600
+      || error?.rpcCode != null && /^(no active turn to steer|expected active turn id `)/i.test(error.message || '');
+  }
+
+  // A UI/request deadline must not discard a later authoritative write receipt.
+  function retainLateResult(pending, error) {
+    const reject = pending.reject;
+    error.deliveryResult = new Promise((resolve, reject) => {
+      pending.resolve = resolve; pending.reject = reject;
+    });
+    error.deliveryResult.catch(() => {});
+    reject(error);
+  }
+
+  class Store {
+    constructor() { this.entries = new Map(); }
+    key(scope, clientId) { return JSON.stringify([scope, clientId]); }
+    status(scope, clientId) {
+      const entry = this.entries.get(this.key(scope, clientId));
+      return entry ? { state: entry.state, ...(entry.result ? { result: entry.result } : {}),
+        ...(entry.error ? { error: entry.error.message } : {}) } : { state: 'unknown' };
+    }
+    async reconcile(scope, clientId, inspect) {
+      const key = this.key(scope, clientId);
+      let entry = this.entries.get(key);
+      if (entry?.state === 'accepted' || entry?.state === 'not_sent') return this.status(scope, clientId);
+      if (entry?.checking) return entry.checking;
+      if (!entry) {
+        // Fence a request which never arrived before checking history. A delayed
+        // transport frame with this admission must not execute after a replacement.
+        entry = { state: 'unknown', fenced: true };
+        this.entries.set(key, entry);
+      }
+      const target = entry;
+      target.checking = (async () => {
+        if (target.work) await target.work.catch(() => {});
+        if (target.lateWork) await target.lateWork;
+        if (target.state === 'accepted' || target.state === 'not_sent') return this.status(scope, clientId);
+        const result = await inspect();
+        target.state = result ? 'accepted' : 'not_sent';
+        target.fenced = true;
+        if (result) target.result = result;
+        delete target.error;
+        return this.status(scope, clientId);
+      })().finally(() => { delete target.checking; });
+      return target.checking;
+    }
+    submit(scope, clientId, operation) {
+      if (!/^[a-f0-9]{32}$/i.test(clientId || '')) return Promise.reject(Object.assign(new Error('消息确认标识无效'), { deliveryUnknown: false }));
+      const key = this.key(scope, clientId), previous = this.entries.get(key);
+      if (previous?.state === 'accepted') return Promise.resolve(previous.result);
+      if (previous?.fenced) return Promise.reject(Object.assign(new Error('原发送请求已结束，请使用新的发送标识'), { deliveryUnknown: false }));
+      if (previous?.state === 'sending') return previous.work;
+      if (previous?.state === 'unknown') return Promise.reject(Object.assign(new Error(previous.error?.message || '原发送结果仍未确认'), { deliveryUnknown: true }));
+      const entry = { state: 'sending' };
+      this.entries.set(key, entry);
+      entry.work = Promise.resolve().then(operation).then(result => {
+        entry.state = 'accepted'; entry.result = result; return result;
+      }, error => {
+        entry.state = error.deliveryUnknown === false || error.details?.deliveryUnknown === false ? 'not_sent' : 'unknown';
+        error.deliveryUnknown = entry.state !== 'not_sent';
+        if (error.deliveryResult) entry.lateWork = error.deliveryResult.then(result => {
+          entry.state = 'accepted'; entry.result = result; delete entry.error;
+        }, lateError => {
+          entry.state = rejectedBeforeSubmission(lateError) || lateError.deliveryUnknown === false ? 'not_sent' : 'unknown';
+          entry.error = lateError;
+        });
+        entry.error = error; throw error;
+      }).finally(() => { delete entry.work; });
+      return entry.work;
+    }
+  }
+  const normalizeId = value => String(value || '').replace(/-/g, '').toLowerCase();
+  async function findMessage(request, threadId, clientId, anchorItemId = '') {
+    let cursor;
+    const seen = new Set();
+    do {
+      const page = await request('thread/items/list', { threadId, limit: 100, sortDirection: 'desc', ...(cursor ? { cursor } : {}) });
+      if (!Array.isArray(page?.data)) throw new Error('发送核对失败：未取得权威历史');
+      for (const entry of page.data) {
+        const item = entry.item;
+        if (item?.type === 'userMessage' && normalizeId(item.clientId) === normalizeId(clientId)) {
+          return { data: { messageId: item.id, turnId: entry.turnId } };
+        }
+        if (anchorItemId && item?.id === anchorItemId) return null;
+      }
+      cursor = page.nextCursor;
+      if (cursor && seen.has(cursor)) throw new Error('发送核对失败：历史游标未推进');
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+    return null;
+  }
+  return Object.freeze({ Store, rejectedBeforeSubmission, retainLateResult, findMessage, normalizeId });
+});

package/dist/shared/p2p-data-channel.cjs

@@ -8,6 +8,28 @@
   const byteLength = value => new TextEncoder().encode(value).length;
 
   return class {
+    static IdleWatch = class {
+      constructor(send, failed) { this.send = send; this.failed = failed; this.serial = 0; this.closed = false; }
+      received() {
+        if (this.closed) return;
+        clearTimeout(this.timer); this.pending = undefined;
+        this.timer = setTimeout(() => {
+          this.pending = String(++this.serial);
+          this.timer = setTimeout(() => { this.close(); this.failed(); }, 15000);
+          try { this.send({ type: 'idle-ping', nonce: this.pending }); } catch { this.close(); this.failed(); }
+        }, 15000);
+        this.timer.unref?.();
+      }
+      accept(message) {
+        if (!['idle-ping', 'idle-pong'].includes(message.type)) return false;
+        if (typeof message.nonce !== 'string' || !/^[0-9]{1,12}$/.test(message.nonce)) throw new Error('Invalid idle probe');
+        if (message.type === 'idle-pong' && message.nonce !== this.pending) return true;
+        this.received();
+        if (message.type === 'idle-ping') this.send({ type: 'idle-pong', nonce: message.nonce });
+        return true;
+      }
+      close() { this.closed = true; clearTimeout(this.timer); this.pending = undefined; }
+    };
     constructor() { this.inbound = undefined; }
     create(payload, id) {
       if (typeof payload !== 'string' || !/^[a-f0-9]{32}-[0-9]{1,10}$/.test(id)) throw new Error('Invalid P2P payload');

package/dist/shared/p2p-diagnostics.cjs

@@ -23,6 +23,6 @@
       `;gathering=${known(this.gathering, ['new', 'in-progress', 'gathering', 'complete'])}` +
       `;local=${counts(this.local)};remote=${counts(this.remote)}` +
       `;open=${Number(this.open)};ping=${Number(this.ping)};pong=${Number(this.pong)}` +
-      `;error=${known(this.error, ['none', 'stun', 'description', 'candidate', 'channel', 'frame', 'peer', 'initialization', 'signal'])}`;
+      `;error=${known(this.error, ['none', 'stun', 'description', 'candidate', 'channel', 'frame', 'peer', 'initialization', 'signal', 'ice-policy'])}`;
   }
 });

package/dist/shared/p2p-file-channel.cjs

@@ -0,0 +1,87 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxFileChannel = factory();
+})(globalThis, function () {
+  const PART = 16 * 1024, MAX = 256 * 1024, LIMIT = 1024 * 1024;
+  // Socket-shaped adapter; one ordered RTC stream owns one file transaction.
+  return class FileChannel {
+    constructor(io) {
+      this.io = io; this.readyState = 0; this.listeners = new Map();
+      this.outbound = []; this.queued = 0; this.partial = null; this.timer = null;
+    }
+    get bufferedAmount() { return this.queued + this.io.buffered(); }
+    addEventListener(type, callback, options = {}) {
+      const list = this.listeners.get(type) || []; list.push({ callback, once: options.once }); this.listeners.set(type, list);
+    }
+    removeEventListener(type, callback) { this.listeners.set(type, (this.listeners.get(type) || []).filter(item => item.callback !== callback)); }
+    emit(type, details = {}) {
+      const event = { type, ...details };
+      this['on' + type]?.(event);
+      for (const item of [...(this.listeners.get(type) || [])]) {
+        if (item.once) this.removeEventListener(type, item.callback);
+        item.callback(event);
+      }
+    }
+    opened() { if (this.readyState !== 0) return; this.readyState = 1; this.emit('open'); this.pump(); }
+    send(value) {
+      if (this.readyState !== 1) throw new Error('文件直连已断开');
+      const binary = typeof value !== 'string';
+      const data = binary ? (value instanceof Uint8Array ? value : new Uint8Array(value)) : value;
+      const size = binary ? data.byteLength : new TextEncoder().encode(data).length;
+      if (!size || size > (binary ? MAX : PART) || this.bufferedAmount + size > LIMIT) throw new Error('文件直连分片或队列超限');
+      const negotiated = this.io.maxMessageSize?.();
+      const frameBytes = Number.isFinite(negotiated) && negotiated > 0 ? Math.min(PART, Math.max(1, Math.floor(negotiated))) : PART;
+      const frames = binary ? [JSON.stringify({ type: 'rtc-file-bytes', length: size })] : [];
+      if (binary) for (let i = 0; i < size; i += frameBytes) frames.push(data.slice(i, i + frameBytes));
+      else frames.push(data);
+      const sizes = frames.map(frame => typeof frame === 'string' ? new TextEncoder().encode(frame).length : frame.byteLength);
+      if (sizes.some(length => length > frameBytes)) throw new Error('文件传输消息超过协商上限');
+      const framedSize = sizes.reduce((total, length) => total + length, 0);
+      if (this.bufferedAmount + framedSize > LIMIT) throw new Error('文件直连队列超限');
+      this.outbound.push({ frames, sizes, index: 0 }); this.queued += framedSize; this.pump();
+    }
+    pump() {
+      if (this.readyState !== 1) return;
+      try {
+        while (this.outbound.length && this.io.buffered() < MAX) {
+          const item = this.outbound[0];
+          // libdatachannel returns false when it accepted the frame into its buffer.
+          // Only an exception rejects a send; replaying a buffered frame duplicates bytes.
+          this.io.send(item.frames[item.index]);
+          this.queued -= item.sizes[item.index];
+          if (++item.index === item.frames.length) this.outbound.shift();
+        }
+      } catch (error) { this.close(1011, `send-failed:${String(error?.name || 'Error').slice(0, 40)}`); }
+    }
+    waitForPartial() {
+      clearTimeout(this.timer);
+      this.timer = setTimeout(() => this.close(1008, 'partial-idle-timeout'), 30000);
+    }
+    receive(value) {
+      if (this.readyState !== 1) return;
+      try {
+        if (typeof value === 'string') {
+          if (this.partial || new TextEncoder().encode(value).length > PART) throw new Error();
+          const frame = JSON.parse(value);
+          if (frame.type !== 'rtc-file-bytes') { this.io.received?.(); this.emit('message', { data: value }); return; }
+          if (!Number.isSafeInteger(frame.length) || frame.length < 1 || frame.length > MAX) throw new Error();
+          this.io.received?.(); this.partial = { data: new Uint8Array(frame.length), offset: 0 };
+          this.waitForPartial(); return;
+        }
+        const bytes = value instanceof Uint8Array ? value : new Uint8Array(value), part = this.partial;
+        if (!part || bytes.length < 1 || bytes.length > Math.min(PART, part.data.length - part.offset)) throw new Error();
+        this.waitForPartial(); this.io.received?.(); part.data.set(bytes, part.offset); part.offset += bytes.length;
+        if (part.offset === part.data.length) {
+          this.partial = null; clearTimeout(this.timer); this.timer = null;
+          this.emit('message', { data: part.data.buffer });
+        }
+      } catch { this.close(1008, 'invalid-frame'); }
+    }
+    close(code = 1000, reason = '') {
+      if (this.readyState === 3) return;
+      this.readyState = 3; clearTimeout(this.timer); this.timer = null;
+      this.partial = null; this.outbound = []; this.queued = 0;
+      this.io.close(); this.emit('close', { code, reason });
+    }
+  };
+});

package/dist/shared/p2p-ice-policy.cjs

@@ -0,0 +1,22 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxIcePolicy = factory();
+})(globalThis, () => {
+  const directType = type => ['host', 'srflx', 'prflx'].includes(type);
+  const candidate = value => {
+    if (typeof value !== 'string' || value.length > 2048 || /[\r\n]/.test(value)) return false;
+    const fields = value.trim().split(/\s+/);
+    return /^(?:a=)?candidate:/.test(fields[0]) && fields[6] === 'typ' && directType(fields[7]);
+  };
+  return {
+    directType, candidate,
+    servers: values => Array.isArray(values) && values.length <= 4 && values.every(value => {
+      if (typeof value !== 'string' || !/^stun:[a-zA-Z0-9.-]+:[0-9]{1,5}$/.test(value)) return false;
+      const port = Number(value.split(':').at(-1));
+      return port > 0 && port <= 65535;
+    }),
+    sdp: value => typeof value === 'string' && value.length <= 65536 &&
+      value.split(/\r?\n/).filter(line => line.startsWith('a=candidate:')).every(candidate),
+    pair: (localType, remoteType) => directType(localType) && directType(remoteType),
+  };
+});