@remcp/runtime 0.2.139 → 0.2.141

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.2.141 — 2026-10-02
+
+- Linux `display_inventory` capability discovery now uses the same real backend resolver as execution instead of treating every Wayland session as supported.
+- wlroots compositors gain a native `wlr-randr` parser for connector metadata, logical position/size, scale, transform, pixel mode and refresh rate; the fallback chain is Mutter → wlr-randr → xrandr.
+- Unsupported Wayland sessions without one of those working backends stop advertising `display_inventory`, and dynamic capability polling can add/remove the tool through `tools/list_changed`.
+- Live GNOME Wayland verification still returns the ASUS eDP-1 through Mutter with the 83-tool desktop surface unchanged.
+
+## 0.2.140 — 2026-10-02
+
+- Windows `create_archive` / `extract_archive` are enabled when the native inbox `tar.exe` (libarchive/bsdtar) backend is available.
+- Windows ZIP creation/extraction uses the same validated tar backend as tar-family archives, preserving traversal, link/special-file, expanded-size, staging, post-extraction, and atomic-commit safety checks.
+- Archive member names are normalized to portable forward slashes before backend invocation.
+- `read_binary` now sizes each returned base64 chunk against the live output cap so the JSON envelope remains parseable under reduced per-call limits; `nextOffsetBytes` reflects the actual returned prefix.
+- Public Windows release CI exercises tar.gz, ZIP, and option-like filename round trips. Fully capable Windows now advertises all 83 runtime tools.
+
 ## 0.2.139 — 2026-10-02
 
 - `create_archive` and `extract_archive` are now advertised on macOS in addition to Linux.

package/README.md

@@ -84,7 +84,7 @@ Desktop capabilities additionally require an active graphical session (`DISPLAY`
 headless hosts do not advertise window/UI/input/clipboard/display/screenshot/launch/open/reveal/notification
 operations merely because desktop helper binaries happen to be installed. The universal `computer_snapshot`
 remains available on those hosts but skips unavailable desktop probes instead of reporting synthetic backend
-errors. On Linux, `screenshot_region` is advertised only when the current session has a real matching capture
+errors. Linux `display_inventory` follows the real monitor backend chain (GNOME Mutter DisplayConfig → `wlr-randr` → `xrandr`) and is hidden on Wayland when none of those backends can return a display. On Linux, `screenshot_region` is advertised only when the current session has a real matching capture
 backend (Wayland grim/GNOME/portal path or X11 ImageMagick), not merely because `ffmpeg` is installed.
 
 The generated hosted reference covers the current **10 hosted production definitions**, all model-visible

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remcp/runtime",
-  "version": "0.2.139",
+  "version": "0.2.141",
   "description": "First-party ReMCP local device runtime: filesystem, terminal, computer-use, browser, diagnostics and document tools over MCP.",
   "type": "module",
   "license": "MIT",

package/src/catalog.mjs

@@ -1,4 +1,4 @@
-import { fileToolHandlers } from './tools/files.mjs';
+import { archiveBackendAvailable, fileToolHandlers } from './tools/files.mjs';
 import { searchToolHandlers } from './tools/search.mjs';
 import { terminalToolHandlers } from './tools/terminal.mjs';
 import { systemToolHandlers } from './tools/system.mjs';
@@ -830,12 +830,18 @@ export const toolDefinitions = [
   },
 ];
 
-export function coreToolSupported(definition, { platform = process.platform } = {}) {
-  return !['create_archive', 'extract_archive'].includes(definition.name) || ['linux', 'darwin'].includes(platform);
+export function coreToolSupported(definition, {
+  platform = process.platform,
+  archiveAvailable = platform === 'win32' ? archiveBackendAvailable({ platform }) : true,
+} = {}) {
+  if (!['create_archive', 'extract_archive'].includes(definition.name)) return true;
+  if (platform === 'linux' || platform === 'darwin') return true;
+  return platform === 'win32' && archiveAvailable === true;
 }
 
 export function supportedCoreTools() {
-  return toolDefinitions.filter(coreToolSupported);
+  const archiveAvailable = process.platform === 'win32' ? archiveBackendAvailable({ platform:process.platform }) : true;
+  return toolDefinitions.filter(definition => coreToolSupported(definition, { platform:process.platform, archiveAvailable }));
 }
 
 export function advertisedTools() {

package/src/extended/catalog.mjs

@@ -9,7 +9,7 @@ import { isWaylandSession } from '../screenshot-portal.mjs';
 import { waylandPortalCandidate } from '../wayland-remote-desktop.mjs';
 import { commandExists, desktopSessionAvailable, runFile } from './common.mjs';
 import { desktopHandlers } from './desktop.mjs';
-import { regionScreenshotBackends } from './desktop-linux.mjs';
+import { displayInventoryAvailable, regionScreenshotBackends } from './desktop-linux.mjs';
 import { diagnosticHandlers, gnomeScreencastSupported, recordScreenAvailable } from './diagnostics.mjs';
 import { documentHandlers } from './documents.mjs';
 
@@ -760,6 +760,7 @@ export async function capabilitySnapshot() {
   const portalCandidate = wayland && waylandPortalCandidate();
   const portalInput = portalCandidate;
   const x11Input = linux && desktopSession && !wayland && (commandExists('wdotool') || commandExists('xdotool'));
+  const displayInventoryReady = linux && desktopSession ? await displayInventoryAvailable() : false;
   const browserCdp = browserRemoteEnabled() && await browserControlAvailable(undefined, 500);
   const documentCapabilities = documentCapabilitySnapshot();
   return {
@@ -770,7 +771,7 @@ export async function capabilitySnapshot() {
     pointer: win || mac || (desktopSession && (portalInput || x11Input)),
     drag: win || mac || (desktopSession && (portalInput || x11Input)),
     clipboard: win || mac || (desktopSession && (commandExists('wl-paste') || commandExists('xclip') || commandExists('xsel'))),
-    displays: win || mac || (desktopSession && ((wayland && linux) || commandExists('wlr-randr') || commandExists('xrandr'))),
+    displays: win || mac || displayInventoryReady,
     screen_region: win || mac || (desktopSession && regionScreenshotBackends({ wayland, portalCandidate }).length > 0),
     notifications: win || mac || (desktopSession && commandExists('notify-send')),
     browser_cdp: browserCdp,

package/src/extended/desktop-linux.mjs

@@ -1445,24 +1445,165 @@ async function mutterDisplayInventory() {
   }
 }
 
-export async function displayInventory() {
-  const mutter = await mutterDisplayInventory();
-  if (mutter) return jsonResult(mutter);
-  if (!commandExists('xrandr')) unavailable('Display inventory', 'GNOME Mutter DisplayConfig or xrandr is required');
-  const { stdout } = await runFile('xrandr', ['--query'], { label: 'display inventory' });
-  let scale = Number(process.env.GDK_SCALE || process.env.QT_SCALE_FACTOR || 0);
+export function parseWlrRandrOutput(stdout) {
+  const rows = [];
+  let current = null;
+
+  const finish = () => {
+    if (!current || current.enabled === false) return;
+    const mode = current.currentMode || current.firstMode;
+    if (!mode) return;
+    const scale = Number.isFinite(current.scale) && current.scale > 0 ? current.scale : 1;
+    const rotated = /(?:^|\D)(?:90|270)(?:\D|$)/.test(current.transform || '');
+    const pixelWidth = mode.width;
+    const pixelHeight = mode.height;
+    rows.push({
+      name:current.name,
+      display_name:current.description || current.model || current.name,
+      primary:false,
+      x:Number.isFinite(current.x) ? current.x : null,
+      y:Number.isFinite(current.y) ? current.y : null,
+      width:Math.round((rotated ? pixelHeight : pixelWidth) / scale),
+      height:Math.round((rotated ? pixelWidth : pixelHeight) / scale),
+      pixel_width:pixelWidth,
+      pixel_height:pixelHeight,
+      scale,
+      refresh_hz:mode.refresh_hz,
+      transform:current.transform || 'normal',
+      builtin:/^(?:eDP|LVDS|DSI)-/i.test(current.name),
+      vendor:current.make || null,
+      product:current.model || null,
+      serial:current.serial || null,
+      backend:'wlr-randr',
+    });
+  };
+
+  for (const rawLine of String(stdout || '').split(/\r?\n/)) {
+    if (rawLine && !/^\s/.test(rawLine)) {
+      finish();
+      const header = rawLine.match(/^(\S+)(?:\s+"([^"]*)")?\s*$/);
+      current = header ? {
+        name:header[1],
+        description:header[2] || '',
+        enabled:true,
+        scale:1,
+        transform:'normal',
+        currentMode:null,
+        firstMode:null,
+      } : null;
+      continue;
+    }
+    if (!current) continue;
+    const line = rawLine.trim();
+    let match;
+    if ((match = line.match(/^Enabled:\s*(yes|no)$/i))) current.enabled = match[1].toLowerCase() === 'yes';
+    else if ((match = line.match(/^Position:\s*(-?\d+)\s*,\s*(-?\d+)$/i))) {
+      current.x = Number(match[1]);
+      current.y = Number(match[2]);
+    } else if ((match = line.match(/^Scale:\s*(\d+(?:\.\d+)?)$/i))) current.scale = Number(match[1]);
+    else if ((match = line.match(/^Transform:\s*(.+)$/i))) current.transform = match[1].trim();
+    else if ((match = line.match(/^Make:\s*(.*)$/i))) current.make = match[1].trim();
+    else if ((match = line.match(/^Model:\s*(.*)$/i))) current.model = match[1].trim();
+    else if ((match = line.match(/^Serial:\s*(.*)$/i))) current.serial = match[1].trim();
+    else if ((match = line.match(/^(\d+)x(\d+)\s+px,\s*([\d.]+)\s+Hz(?:\s+\(([^)]*)\))?/i))) {
+      const mode = { width:Number(match[1]), height:Number(match[2]), refresh_hz:Number(match[3]) };
+      current.firstMode ||= mode;
+      if (/\bcurrent\b/i.test(match[4] || '')) current.currentMode = mode;
+    }
+  }
+  finish();
+  return rows;
+}
+
+export function parseXrandrDisplayOutput(stdout, scale = 1) {
+  const rows = [];
+  for (const line of String(stdout || '').split(/\r?\n/)) {
+    const match = line.match(/^(\S+) connected( primary)?(?: (\d+)x(\d+)\+(-?\d+)\+(-?\d+))?/);
+    if (match) rows.push({
+      name:match[1],
+      display_name:match[1],
+      primary:Boolean(match[2]),
+      width:match[3]?Number(match[3]):null,
+      height:match[4]?Number(match[4]):null,
+      pixel_width:match[3]?Number(match[3]):null,
+      pixel_height:match[4]?Number(match[4]):null,
+      x:match[5]?Number(match[5]):null,
+      y:match[6]?Number(match[6]):null,
+      scale,
+      backend:'xrandr',
+    });
+  }
+  return rows;
+}
+
+async function xrandrDisplayScale({ commandExistsFn = commandExists, runFileFn = runFile, env = process.env } = {}) {
+  let scale = Number(env.GDK_SCALE || env.QT_SCALE_FACTOR || 0);
   if (!Number.isFinite(scale) || scale <= 0) scale = 0;
-  if (!scale && commandExists('gsettings')) {
-    const probe = await runFile('gsettings', ['get','org.gnome.desktop.interface','scaling-factor'], { label:'display scale', allowFailure:true, timeout:1500 });
+  if (!scale && commandExistsFn('gsettings')) {
+    const probe = await runFileFn('gsettings', ['get','org.gnome.desktop.interface','scaling-factor'], { label:'display scale', allowFailure:true, timeout:1500 });
     const parsed = Number(String(probe.stdout || '').match(/(\d+(?:\.\d+)?)/)?.[1]);
     if (Number.isFinite(parsed) && parsed > 0) scale = parsed;
   }
-  if (!scale) scale = 1;
-  const rows = [];
-  for (const line of stdout.split('\n')) {
-    const match = line.match(/^(\S+) connected( primary)?(?: (\d+)x(\d+)\+(-?\d+)\+(-?\d+))?/);
-    if (match) rows.push({ name:match[1], display_name:match[1], primary:Boolean(match[2]), width:match[3]?Number(match[3]):null, height:match[4]?Number(match[4]):null, pixel_width:match[3]?Number(match[3]):null, pixel_height:match[4]?Number(match[4]):null, x:match[5]?Number(match[5]):null, y:match[6]?Number(match[6]):null, scale, backend:'xrandr' });
+  return scale || 1;
+}
+
+export async function resolveLinuxDisplayInventory({
+  wayland = isWaylandSession(),
+  mutterProbe = mutterDisplayInventory,
+  commandExistsFn = commandExists,
+  runFileFn = runFile,
+  env = process.env,
+} = {}) {
+  if (wayland) {
+    const mutter = await mutterProbe().catch(() => null);
+    if (Array.isArray(mutter) && mutter.length) return mutter;
+
+    if (commandExistsFn('wlr-randr')) {
+      const result = await runFileFn('wlr-randr', [], { label:'display inventory', allowFailure:true, timeout:2500, maxBuffer:4*1024*1024 });
+      if (result.code === 0) {
+        const rows = parseWlrRandrOutput(result.stdout);
+        if (rows.length) return rows;
+      }
+    }
   }
+
+  if (commandExistsFn('xrandr')) {
+    const result = await runFileFn('xrandr', ['--query'], { label:'display inventory', allowFailure:true, timeout:2500, maxBuffer:4*1024*1024 });
+    if (result.code === 0) {
+      const scale = await xrandrDisplayScale({ commandExistsFn, runFileFn, env });
+      const rows = parseXrandrDisplayOutput(result.stdout, scale);
+      if (rows.length) return rows;
+    }
+  }
+  return null;
+}
+
+let displayCapabilityCache = { value:false, expiresAt:0, pending:null };
+
+export async function displayInventoryAvailable(options) {
+  if (options && Object.keys(options).length) {
+    return Boolean((await resolveLinuxDisplayInventory(options))?.length);
+  }
+  const now = Date.now();
+  if (displayCapabilityCache.expiresAt > now) return displayCapabilityCache.value;
+  if (displayCapabilityCache.pending) return displayCapabilityCache.pending;
+  const pending = resolveLinuxDisplayInventory()
+    .then(rows => {
+      const value = Boolean(rows?.length);
+      displayCapabilityCache = { value, expiresAt:Date.now() + 5000, pending:null };
+      return value;
+    })
+    .catch(() => {
+      displayCapabilityCache = { value:false, expiresAt:Date.now() + 5000, pending:null };
+      return false;
+    });
+  displayCapabilityCache.pending = pending;
+  return pending;
+}
+
+export async function displayInventory() {
+  const rows = await resolveLinuxDisplayInventory();
+  if (!rows?.length) unavailable('Display inventory', 'GNOME Mutter DisplayConfig, wlr-randr or xrandr is required');
   return jsonResult(rows);
 }
 

package/src/tools/files.mjs

@@ -12,7 +12,7 @@ import { describeFilesystemFailure } from '../permissions.mjs';
 import { capturePortalScreenshot, isWaylandSession } from '../screenshot-portal.mjs';
 import { applyHunks, parseUnifiedDiff } from '../patch.mjs';
 import { countEvent, recordEvent } from '../telemetry.mjs';
-import { clampInteger, decodeText, displayPath, fail, globToRegExp, image, isInsideRoot, looksBinary, multi, pageLines, resolveSafePath, splitLines, text, throwIfCancelled } from '../util.mjs';
+import { clampInteger, decodeText, displayPath, fail, fitsOutput, globToRegExp, image, isInsideRoot, looksBinary, multi, pageLines, resolveSafePath, splitLines, text, throwIfCancelled } from '../util.mjs';
 
 const MAX_INLINE_FILE_BYTES = 20 * 1024 * 1024;
 // An image travels base64-encoded, which costs a third more bytes. The agent's stdio transport holds
@@ -785,16 +785,33 @@ export async function readBinaryTool(args) {
   try {
     const buffer = Buffer.alloc(end - start);
     if (buffer.length) await handle.read(buffer, 0, buffer.length, start);
-    const payload = JSON.stringify({
-      path: displayPath(absolute),
-      size: info.size,
-      offsetBytes: start,
-      lengthBytes: buffer.length,
-      nextOffsetBytes: end < info.size ? end : null,
-      complete: end >= info.size,
-      encoding: 'base64',
-      data: buffer.toString('base64'),
-    });
+    const renderPayload = lengthBytes => {
+      const actualEnd = start + lengthBytes;
+      return JSON.stringify({
+        path: displayPath(absolute),
+        size: info.size,
+        offsetBytes: start,
+        lengthBytes,
+        nextOffsetBytes: actualEnd < info.size ? actualEnd : null,
+        complete: actualEnd >= info.size,
+        encoding: 'base64',
+        data: buffer.subarray(0, lengthBytes).toString('base64'),
+      });
+    };
+    let returnedLength = buffer.length;
+    let payload = renderPayload(returnedLength);
+    if (!fitsOutput(payload)) {
+      let low = 0;
+      let high = returnedLength;
+      while (low < high) {
+        const candidate = Math.ceil((low + high) / 2);
+        if (fitsOutput(renderPayload(candidate))) low = candidate;
+        else high = candidate - 1;
+      }
+      returnedLength = low;
+      payload = renderPayload(returnedLength);
+      if (!fitsOutput(payload)) fail('Runtime output limit is too small to return read_binary metadata');
+    }
     return text(payload);
   } finally {
     await opened.close();
@@ -1775,14 +1792,31 @@ async function moveArchiveFile(source, destination) {
   }
 }
 
-function archiveTool() {
-  const probe = (name, versionArgs = ['--version']) => {
-    const result = spawnSync(name, versionArgs, { encoding: 'utf8' });
-    return !result.error && result.status === 0 ? name : null;
-  };
+function archiveCommandProbe(name, versionArgs = ['--version']) {
+  const result = spawnSync(name, versionArgs, { encoding: 'utf8' });
+  return !result.error && result.status === 0 ? name : null;
+}
+
+function archiveTool({ platform = process.platform, probe = archiveCommandProbe } = {}) {
+  const tarName = platform === 'win32' ? 'tar.exe' : 'tar';
+  // Windows ships libarchive/bsdtar as tar.exe. It can create/read ZIP as well as tar-family
+  // archives, so keeping one backend avoids introducing a second extraction/safety path.
+  if (platform === 'win32') return { tar: probe(tarName), zip:null, unzip:null };
   // Info-ZIP unzip (the default on Debian/Ubuntu) treats --version as an invalid combination and
   // exits 10 even though the binary is healthy. Its portable version probe is -v.
-  return { tar: probe('tar'), zip: probe('zip'), unzip: probe('unzip', ['-v']) };
+  return { tar: probe(tarName), zip: probe('zip'), unzip: probe('unzip', ['-v']) };
+}
+
+export function archiveBackendAvailable({ platform = process.platform, probe = archiveCommandProbe } = {}) {
+  if (platform === 'win32') return Boolean(archiveTool({ platform, probe }).tar);
+  return platform === 'linux' || platform === 'darwin';
+}
+
+export function zipArchiveBackendAvailable({ platform = process.platform, probe = archiveCommandProbe } = {}) {
+  const tools = archiveTool({ platform, probe });
+  if (platform === 'win32') return Boolean(tools.tar);
+  if (platform === 'linux' || platform === 'darwin') return Boolean(tools.zip && tools.unzip);
+  return false;
 }
 
 export async function createArchiveTool(args, extra = {}) {
@@ -1801,7 +1835,10 @@ export async function createArchiveTool(args, extra = {}) {
   const baseDir = path.dirname(resolved[0]);
   const names = resolved.map(entry => path.relative(baseDir, entry));
   if (names.some(name => !name || name.startsWith('..') || path.isAbsolute(name))) fail('Archive sources must share one parent directory');
-  const archiveNames = names.map(name => name.startsWith('-') ? `./${name}` : name);
+  const archiveNames = names.map(name => {
+    const portable = name.split(path.sep).join('/');
+    return portable.startsWith('-') ? `./${portable}` : portable;
+  });
   const suffix = format === 'zip' ? '.zip' : format === 'tar' ? '.tar' : '.tar.gz';
   const stagingDirectory = await mkdtemp(path.join(os.tmpdir(), 'remcp-archive-'));
   if (resolved.some(entry => !path.relative(entry, stagingDirectory).startsWith('..') && !path.isAbsolute(path.relative(entry, stagingDirectory)))) {
@@ -1822,9 +1859,15 @@ export async function createArchiveTool(args, extra = {}) {
        await copyTreeContents(resolved[index], snapshotPath, snapshotState);
      }
      if (format === 'zip') {
-       if (!tools.zip) fail('zip is not installed on this device; use format "tar.gz"');
-       const result = spawnSync(tools.zip, ['-r', '-q', '-y', staging, '--', ...archiveNames], { cwd: snapshotRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 16 * 1024 * 1024 });
-      if (result.status !== 0) fail(`zip failed: ${(result.stderr || result.stdout || '').trim() || `exit ${result.status}`}`);
+       if (process.platform === 'win32') {
+         if (!tools.tar) fail('Windows archive backend is unavailable: tar.exe is required');
+         const result = spawnSync(tools.tar, ['-a', '-c', '-f', staging, '--', ...archiveNames], { cwd: snapshotRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 16 * 1024 * 1024 });
+         if (result.status !== 0) fail(`tar.exe ZIP creation failed: ${(result.stderr || result.stdout || '').trim() || `exit ${result.status}`}`);
+       } else {
+         if (!tools.zip) fail('zip is not installed on this device; use format "tar.gz"');
+         const result = spawnSync(tools.zip, ['-r', '-q', '-y', staging, '--', ...archiveNames], { cwd: snapshotRoot, encoding: 'utf8', timeout: 120_000, maxBuffer: 16 * 1024 * 1024 });
+         if (result.status !== 0) fail(`zip failed: ${(result.stderr || result.stdout || '').trim() || `exit ${result.status}`}`);
+       }
     } else if (format === 'tar' || format === 'tar.gz' || format === 'tgz') {
       if (!tools.tar) fail('tar is not installed on this device');
       const flags = format === 'tar' ? '-cf' : '-czf';
@@ -1880,7 +1923,7 @@ export async function extractArchiveTool(args) {
     await recoverExtractionArtifacts(parent, destination, backupPrefix);
     const existingDestination = await lstat(destination).catch(() => null);
     if (existingDestination?.isSymbolicLink() || (existingDestination && !existingDestination.isDirectory())) fail('Archive destination is not a safe directory');
-    if (format === 'zip') {
+    if (format === 'zip' && process.platform !== 'win32') {
       if (!tools.unzip) fail('unzip is not installed on this device');
       const listing = spawnSync(tools.unzip, ['-Z', '-1', archiveSnapshot], { encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
       if (listing.error || listing.status !== 0) fail(`Could not inspect ZIP archive: ${(listing.stderr || listing.error?.message || `exit ${listing.status}`).trim()}`);
@@ -1895,7 +1938,7 @@ export async function extractArchiveTool(args) {
       const result = spawnSync(tools.unzip, ['-o', '-q', archiveSnapshot, '-d', staging], { encoding: 'utf8', timeout: 120_000, maxBuffer: 16 * 1024 * 1024 });
       if (result.status !== 0) fail(`unzip failed: ${(result.stderr || result.stdout || '').trim() || `exit ${result.status}`}`);
     } else {
-      if (!tools.tar) fail('tar is not installed on this device');
+      if (!tools.tar) fail(process.platform === 'win32' ? 'Windows archive backend is unavailable: tar.exe is required' : 'tar is not installed on this device');
       const listFlags = format === 'tar.gz' ? '-tzf' : format === 'tar.bz2' ? '-tjf' : format === 'tar.xz' ? '-tJf' : '-tf';
       const listing = spawnSync(tools.tar, [listFlags, archiveSnapshot], { encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024 });
       if (listing.error || listing.status !== 0) fail(`Could not inspect archive: ${(listing.stderr || listing.error?.message || `exit ${listing.status}`).trim()}`);

package/src/util.mjs

@@ -136,10 +136,16 @@ function frameBytes(text) {
   return Buffer.byteLength(JSON.stringify(String(text)), 'utf8');
 }
 
+export function fitsOutput(text, maxBytes) {
+  const limit = maxBytes || liveConfig('maxOutputBytes');
+  const value = String(text);
+  return Buffer.byteLength(value, 'utf8') <= limit && frameBytes(value) <= limit;
+}
+
 export function truncate(text, maxBytes) {
   const limit = maxBytes || liveConfig('maxOutputBytes');
   const value = String(text);
-  if (Buffer.byteLength(value, 'utf8') <= limit && frameBytes(value) <= limit) return value;
+  if (fitsOutput(value, limit)) return value;
   // Shrink until the escaped frame fits, so the escaped size is what the caller gets is bounded.
   let size = Math.min(Buffer.byteLength(value, 'utf8'), limit);
   let rendered = '';