apex-dev 3.8.0 → 3.10.3

package/dist/index.js

@@ -29,8 +29,8 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
-// node_modules/@opentui/react/chunk-eecw9x2f.js
-var init_chunk_eecw9x2f = () => {};
+// node_modules/@opentui/react/chunk-2mx7fq49.js
+var init_chunk_2mx7fq49 = () => {};
 
 // node_modules/react/cjs/react.production.js
 var exports_react_production = {};
@@ -24044,11 +24044,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
   });
 });
 
-// node_modules/@opentui/react/chunk-pm1hna8x.js
-var exports_chunk_pm1hna8x = {};
+// node_modules/@opentui/react/chunk-bdqvmfwv.js
+var exports_chunk_bdqvmfwv = {};
 var import_react_devtools_core, g;
-var init_chunk_pm1hna8x = __esm(async () => {
-  init_chunk_eecw9x2f();
+var init_chunk_bdqvmfwv = __esm(async () => {
+  init_chunk_2mx7fq49();
   import_react_devtools_core = __toESM(require_backend(), 1);
   g = globalThis;
   if (typeof g.WebSocket === "undefined") {
@@ -24714,11 +24714,11 @@ var require_shims = __commonJS((exports) => {
     throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new OpenAI({ fetch })` or polyfill the global, `globalThis.fetch = fetch`");
   }
   function makeReadableStream(...args) {
-    const ReadableStream = globalThis.ReadableStream;
-    if (typeof ReadableStream === "undefined") {
+    const ReadableStream2 = globalThis.ReadableStream;
+    if (typeof ReadableStream2 === "undefined") {
       throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");
     }
-    return new ReadableStream(...args);
+    return new ReadableStream2(...args);
   }
   function ReadableStreamFrom(iterable) {
     let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
@@ -31786,7 +31786,8 @@ Rules:
 2. Be specific and actionable \u2014 code examples and exact details over generic advice.
 3. If results don't contain the answer, say so clearly and share what you know from training data.
 4. Prefer recent/authoritative sources. Note when information may be outdated.
-5. Keep answers concise but thorough \u2014 developers are your audience.`;
+5. Keep answers concise but thorough \u2014 developers are your audience.
+6. Do NOT use <think> tags or internal reasoning blocks in your response. Output your answer directly.`;
   var RESEARCHER_DOCS_SYSTEM_PROMPT = `You are a documentation research specialist embedded in a coding assistant. You receive documentation search results and synthesize them into a precise, practical answer.
 
 Rules:
@@ -31794,7 +31795,8 @@ Rules:
 2. Include code examples that can be used directly \u2014 prefer showing code over describing it.
 3. Note version-specific behavior when relevant.
 4. Highlight common pitfalls, gotchas, and deprecation warnings.
-5. If the docs don't cover the question, say so and provide your best guidance from training data.`;
+5. If the docs don't cover the question, say so and provide your best guidance from training data.
+6. Do NOT use <think> tags or internal reasoning blocks in your response. Output your answer directly.`;
   var GENERAL_AGENT_SYSTEM_PROMPT = `You are a general-purpose coding agent. You receive file contents and conversation context, then produce a thorough, actionable response.
 
 Your strengths:
@@ -31804,8 +31806,8 @@ Your strengths:
 
 Be direct and comprehensive. Provide actual solutions, not descriptions of what to do. If you identify issues or risks, flag them clearly with severity.`;
   var nvidiaClient = new OpenAI({
-    apiKey: process.env.NVIDIA_API_KEY || "",
-    baseURL: "https://integrate.api.nvidia.com/v1"
+    apiKey: process.env.APEX_API_KEY || "local-proxy",
+    baseURL: process.env.APEX_API_URL || "https://apex-api-ten.vercel.app/v1"
   });
   var session = {
     conversationHistory: [],
@@ -32419,6 +32421,73 @@ var require_tools = __commonJS((exports, module2) => {
   module2.exports = { toolDefs };
 });
 
+// src/thinking.js
+var require_thinking = __commonJS((exports, module2) => {
+  function parseThinkBlocks(text) {
+    const thinkRegex = /<think>([\s\S]*?)(?:<\/think>|think>)/g;
+    const thoughts = [];
+    let match;
+    while ((match = thinkRegex.exec(text)) !== null) {
+      const content = match[1].trim();
+      if (content)
+        thoughts.push(content);
+    }
+    const cleaned = text.replace(/<think>[\s\S]*?(?:<\/think>|think>)/g, "").trim();
+    return { thoughts, content: cleaned };
+  }
+  function findThinkClose(text) {
+    const fullClose = text.indexOf("</think>");
+    if (fullClose !== -1)
+      return { pos: fullClose, len: 8 };
+    let searchFrom = 0;
+    while (searchFrom < text.length) {
+      const idx = text.indexOf("think>", searchFrom);
+      if (idx === -1)
+        break;
+      if (idx === 0 || text[idx - 1] !== "<")
+        return { pos: idx, len: 6 };
+      searchFrom = idx + 6;
+    }
+    return null;
+  }
+  function stripStrayCloseTag(text) {
+    return text.replace(/<\/think>/g, "").replace(/(?<!<)think>/g, "");
+  }
+  function splitAtPartialTag(text) {
+    const prefixes = [
+      "</think>",
+      "</think",
+      "</thin",
+      "</thi",
+      "</th",
+      "</t",
+      "</",
+      "<think>",
+      "<think",
+      "<thin",
+      "<thi",
+      "<th",
+      "<t",
+      "<"
+    ];
+    for (const prefix of prefixes) {
+      if (text.endsWith(prefix)) {
+        if (prefix === "</think>" || prefix === "think>") {
+          return { safe: text.slice(0, -prefix.length), pending: "" };
+        }
+        return { safe: text.slice(0, -prefix.length), pending: prefix };
+      }
+    }
+    return { safe: text, pending: "" };
+  }
+  module2.exports = {
+    parseThinkBlocks,
+    findThinkClose,
+    stripStrayCloseTag,
+    splitAtPartialTag
+  };
+});
+
 // src/toolExecutors.js
 var require_toolExecutors = __commonJS((exports, module2) => {
   var fs2 = __require("fs");
@@ -32451,6 +32520,7 @@ var require_toolExecutors = __commonJS((exports, module2) => {
     resolvePath,
     sleep
   } = require_config();
+  var { parseThinkBlocks } = require_thinking();
   async function streamCompletion(params, onStream) {
     for (let attempt = 0;attempt <= 2; attempt++) {
       let content = "";
@@ -32458,21 +32528,39 @@ var require_toolExecutors = __commonJS((exports, module2) => {
       try {
         if (onStream) {
           const stream = await nvidiaClient.chat.completions.create({ ...params, stream: true });
+          let displayContent = "";
           for await (const chunk of stream) {
             const delta = chunk.choices?.[0]?.delta;
             if (delta?.content) {
               content += delta.content;
-              onStream(content || reasoning);
+              const lastOpen = content.lastIndexOf("<think>");
+              const lastClose = content.lastIndexOf("</think>");
+              if (lastOpen <= lastClose || lastOpen === -1) {
+                displayContent = parseThinkBlocks(content).content;
+              }
+              onStream(displayContent || reasoning);
             }
             if (delta?.reasoning_content) {
               reasoning += delta.reasoning_content;
-              onStream(content || reasoning);
+              onStream(displayContent || reasoning);
             }
           }
-          return content || reasoning || "";
+          let { content: cleaned } = parseThinkBlocks(content);
+          const unclosedIdx = cleaned.lastIndexOf("<think>");
+          if (unclosedIdx !== -1 && cleaned.indexOf("</think>", unclosedIdx) === -1) {
+            cleaned = cleaned.slice(0, unclosedIdx).trim();
+          }
+          return cleaned || reasoning || "";
         } else {
           const response = await nvidiaClient.chat.completions.create(params);
-          return response.choices[0]?.message?.content || response.choices[0]?.message?.reasoning_content || "";
+          const rawContent = response.choices[0]?.message?.content || "";
+          const rawReasoning = response.choices[0]?.message?.reasoning_content || "";
+          let { content: cleaned } = parseThinkBlocks(rawContent);
+          const unclosedIdx = cleaned.lastIndexOf("<think>");
+          if (unclosedIdx !== -1 && cleaned.indexOf("</think>", unclosedIdx) === -1) {
+            cleaned = cleaned.slice(0, unclosedIdx).trim();
+          }
+          return cleaned || rawReasoning || "";
         }
       } catch (err) {
         if (err.status === 404 && params.model !== NVIDIA_MODEL && attempt < 2) {
@@ -33671,73 +33759,6 @@ var require_utils3 = __commonJS((exports, module2) => {
   module2.exports = { toolDetailStr };
 });
 
-// src/thinking.js
-var require_thinking = __commonJS((exports, module2) => {
-  function parseThinkBlocks(text) {
-    const thinkRegex = /<think>([\s\S]*?)(?:<\/think>|think>)/g;
-    const thoughts = [];
-    let match;
-    while ((match = thinkRegex.exec(text)) !== null) {
-      const content = match[1].trim();
-      if (content)
-        thoughts.push(content);
-    }
-    const cleaned = text.replace(/<think>[\s\S]*?(?:<\/think>|think>)/g, "").trim();
-    return { thoughts, content: cleaned };
-  }
-  function findThinkClose(text) {
-    const fullClose = text.indexOf("</think>");
-    if (fullClose !== -1)
-      return { pos: fullClose, len: 8 };
-    let searchFrom = 0;
-    while (searchFrom < text.length) {
-      const idx = text.indexOf("think>", searchFrom);
-      if (idx === -1)
-        break;
-      if (idx === 0 || text[idx - 1] !== "<")
-        return { pos: idx, len: 6 };
-      searchFrom = idx + 6;
-    }
-    return null;
-  }
-  function stripStrayCloseTag(text) {
-    return text.replace(/<\/think>/g, "").replace(/(?<!<)think>/g, "");
-  }
-  function splitAtPartialTag(text) {
-    const prefixes = [
-      "</think>",
-      "</think",
-      "</thin",
-      "</thi",
-      "</th",
-      "</t",
-      "</",
-      "<think>",
-      "<think",
-      "<thin",
-      "<thi",
-      "<th",
-      "<t",
-      "<"
-    ];
-    for (const prefix of prefixes) {
-      if (text.endsWith(prefix)) {
-        if (prefix === "</think>" || prefix === "think>") {
-          return { safe: text.slice(0, -prefix.length), pending: "" };
-        }
-        return { safe: text.slice(0, -prefix.length), pending: prefix };
-      }
-    }
-    return { safe: text, pending: "" };
-  }
-  module2.exports = {
-    parseThinkBlocks,
-    findThinkClose,
-    stripStrayCloseTag,
-    splitAtPartialTag
-  };
-});
-
 // src/agent.js
 var require_agent = __commonJS((exports, module2) => {
   var {
@@ -34267,7 +34288,101 @@ var require_jsx_runtime = __commonJS((exports, module2) => {
   } else {}
 });
 
-// node_modules/@opentui/core/index-a215gqtt.js
+// src/server.js
+var require_server = __commonJS((exports, module2) => {
+  var OpenAI = require_openai();
+  var NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+  var PORT = process.env.APEX_SERVER_PORT || 3579;
+  var serverInstance = null;
+  async function startServer() {
+    if (serverInstance)
+      return serverInstance;
+    const apiKey = process.env.NVIDIA_API_KEY || "";
+    const upstream = new OpenAI({ apiKey, baseURL: NVIDIA_BASE_URL });
+    serverInstance = Bun.serve({
+      port: PORT,
+      async fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/health") {
+          return new Response(JSON.stringify({ status: "ok" }), {
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+          try {
+            const body = await req.json();
+            const isStream = body.stream === true;
+            if (isStream) {
+              const stream = await upstream.chat.completions.create(body);
+              const encoder2 = new TextEncoder;
+              const readable = new ReadableStream({
+                async start(controller) {
+                  try {
+                    for await (const chunk of stream) {
+                      controller.enqueue(encoder2.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+                    }
+                    controller.enqueue(encoder2.encode(`data: [DONE]
+
+`));
+                    controller.close();
+                  } catch (err) {
+                    controller.enqueue(encoder2.encode(`data: ${JSON.stringify({ error: err.message })}
+
+`));
+                    controller.close();
+                  }
+                }
+              });
+              return new Response(readable, {
+                headers: {
+                  "Content-Type": "text/event-stream",
+                  "Cache-Control": "no-cache",
+                  Connection: "keep-alive"
+                }
+              });
+            }
+            const result = await upstream.chat.completions.create(body);
+            return new Response(JSON.stringify(result), {
+              headers: { "Content-Type": "application/json" }
+            });
+          } catch (err) {
+            const status = err.status || 500;
+            return new Response(JSON.stringify({ error: { message: err.message, status } }), {
+              status,
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+        }
+        if (url.pathname === "/v1/models" && req.method === "GET") {
+          try {
+            const models = await upstream.models.list();
+            return new Response(JSON.stringify(models), {
+              headers: { "Content-Type": "application/json" }
+            });
+          } catch (err) {
+            return new Response(JSON.stringify({ error: err.message }), {
+              status: 500,
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+        }
+        return new Response("Not Found", { status: 404 });
+      }
+    });
+    return serverInstance;
+  }
+  function getServerURL() {
+    return `http://localhost:${PORT}/v1`;
+  }
+  function getPort() {
+    return PORT;
+  }
+  module2.exports = { startServer, getServerURL, getPort };
+});
+
+// node_modules/@opentui/core/index-qr7b6cvh.js
 import { Buffer as Buffer2 } from "buffer";
 import { EventEmitter } from "events";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -34308,7 +34423,7 @@ var highlights_default5 = "./highlights-hk7bwhj4.scm";
 // node_modules/@opentui/core/assets/zig/tree-sitter-zig.wasm
 var tree_sitter_zig_default = "./tree-sitter-zig-e78zbjpm.wasm";
 
-// node_modules/@opentui/core/index-a215gqtt.js
+// node_modules/@opentui/core/index-qr7b6cvh.js
 import { resolve as resolve2, isAbsolute, parse } from "path";
 import { existsSync } from "fs";
 import { basename, join } from "path";
@@ -34332,13 +34447,17 @@ import { Writable } from "stream";
 import { EventEmitter as EventEmitter7 } from "events";
 import { EventEmitter as EventEmitter9 } from "events";
 var __defProp2 = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export2 = (target, all) => {
   for (var name in all)
     __defProp2(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var exports_src = {};
@@ -53747,604 +53866,6 @@ class LineNumberRenderable extends Renderable {
     }
   }
 }
-
-class Diff {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = undefined;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = undefined;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
-    };
-    if (callback) {
-      (function exec() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(undefined);
-          }
-          if (!execEditLength()) {
-            exec();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
-    }
-  }
-  addToPath(path2, added, removed, oldPosInc, options) {
-    const last = path2.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path2.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path2.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
-    }
-  }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
-    }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-    }
-    basePath.oldPos = oldPos;
-    return newPos;
-  }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
-    }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0;i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
-    }
-    return ret;
-  }
-  castInput(value, options) {
-    return value;
-  }
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
-  }
-  postProcess(changeObjects, options) {
-    return changeObjects;
-  }
-  get useLongestToken() {
-    return false;
-  }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (;componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
-        } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
-        }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
-    }
-    return components;
-  }
-}
-
-class CharacterDiff extends Diff {
-}
-var characterDiff = new CharacterDiff;
-function longestCommonPrefix(str1, str2) {
-  let i;
-  for (i = 0;i < str1.length && i < str2.length; i++) {
-    if (str1[i] != str2[i]) {
-      return str1.slice(0, i);
-    }
-  }
-  return str1.slice(0, i);
-}
-function longestCommonSuffix(str1, str2) {
-  let i;
-  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
-    return "";
-  }
-  for (i = 0;i < str1.length && i < str2.length; i++) {
-    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
-      return str1.slice(-i);
-    }
-  }
-  return str1.slice(-i);
-}
-function replacePrefix(string, oldPrefix, newPrefix) {
-  if (string.slice(0, oldPrefix.length) != oldPrefix) {
-    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
-  }
-  return newPrefix + string.slice(oldPrefix.length);
-}
-function replaceSuffix(string, oldSuffix, newSuffix) {
-  if (!oldSuffix) {
-    return string + newSuffix;
-  }
-  if (string.slice(-oldSuffix.length) != oldSuffix) {
-    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
-  }
-  return string.slice(0, -oldSuffix.length) + newSuffix;
-}
-function removePrefix(string, oldPrefix) {
-  return replacePrefix(string, oldPrefix, "");
-}
-function removeSuffix(string, oldSuffix) {
-  return replaceSuffix(string, oldSuffix, "");
-}
-function maximumOverlap(string1, string2) {
-  return string2.slice(0, overlapCount(string1, string2));
-}
-function overlapCount(a, b) {
-  let startA = 0;
-  if (a.length > b.length) {
-    startA = a.length - b.length;
-  }
-  let endB = b.length;
-  if (a.length < b.length) {
-    endB = a.length;
-  }
-  const map = Array(endB);
-  let k = 0;
-  map[0] = 0;
-  for (let j = 1;j < endB; j++) {
-    if (b[j] == b[k]) {
-      map[j] = map[k];
-    } else {
-      map[j] = k;
-    }
-    while (k > 0 && b[j] != b[k]) {
-      k = map[k];
-    }
-    if (b[j] == b[k]) {
-      k++;
-    }
-  }
-  k = 0;
-  for (let i = startA;i < a.length; i++) {
-    while (k > 0 && a[i] != b[k]) {
-      k = map[k];
-    }
-    if (a[i] == b[k]) {
-      k++;
-    }
-  }
-  return k;
-}
-function trailingWs(string) {
-  let i;
-  for (i = string.length - 1;i >= 0; i--) {
-    if (!string[i].match(/\s/)) {
-      break;
-    }
-  }
-  return string.substring(i + 1);
-}
-function leadingWs(string) {
-  const match = string.match(/^\s*/);
-  return match ? match[0] : "";
-}
-var extendedWordChars = "a-zA-Z0-9_\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
-var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
-
-class WordDiff extends Diff {
-  equals(left, right, options) {
-    if (options.ignoreCase) {
-      left = left.toLowerCase();
-      right = right.toLowerCase();
-    }
-    return left.trim() === right.trim();
-  }
-  tokenize(value, options = {}) {
-    let parts;
-    if (options.intlSegmenter) {
-      const segmenter = options.intlSegmenter;
-      if (segmenter.resolvedOptions().granularity != "word") {
-        throw new Error('The segmenter passed must have a granularity of "word"');
-      }
-      parts = Array.from(segmenter.segment(value), (segment) => segment.segment);
-    } else {
-      parts = value.match(tokenizeIncludingWhitespace) || [];
-    }
-    const tokens = [];
-    let prevPart = null;
-    parts.forEach((part) => {
-      if (/\s/.test(part)) {
-        if (prevPart == null) {
-          tokens.push(part);
-        } else {
-          tokens.push(tokens.pop() + part);
-        }
-      } else if (prevPart != null && /\s/.test(prevPart)) {
-        if (tokens[tokens.length - 1] == prevPart) {
-          tokens.push(tokens.pop() + part);
-        } else {
-          tokens.push(prevPart + part);
-        }
-      } else {
-        tokens.push(part);
-      }
-      prevPart = part;
-    });
-    return tokens;
-  }
-  join(tokens) {
-    return tokens.map((token, i) => {
-      if (i == 0) {
-        return token;
-      } else {
-        return token.replace(/^\s+/, "");
-      }
-    }).join("");
-  }
-  postProcess(changes, options) {
-    if (!changes || options.oneChangePerToken) {
-      return changes;
-    }
-    let lastKeep = null;
-    let insertion = null;
-    let deletion = null;
-    changes.forEach((change) => {
-      if (change.added) {
-        insertion = change;
-      } else if (change.removed) {
-        deletion = change;
-      } else {
-        if (insertion || deletion) {
-          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
-        }
-        lastKeep = change;
-        insertion = null;
-        deletion = null;
-      }
-    });
-    if (insertion || deletion) {
-      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-    }
-    return changes;
-  }
-}
-var wordDiff = new WordDiff;
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
-  if (deletion && insertion) {
-    const oldWsPrefix = leadingWs(deletion.value);
-    const oldWsSuffix = trailingWs(deletion.value);
-    const newWsPrefix = leadingWs(insertion.value);
-    const newWsSuffix = trailingWs(insertion.value);
-    if (startKeep) {
-      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-      deletion.value = removePrefix(deletion.value, commonWsPrefix);
-      insertion.value = removePrefix(insertion.value, commonWsPrefix);
-    }
-    if (endKeep) {
-      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-    }
-  } else if (insertion) {
-    if (startKeep) {
-      const ws = leadingWs(insertion.value);
-      insertion.value = insertion.value.substring(ws.length);
-    }
-    if (endKeep) {
-      const ws = leadingWs(endKeep.value);
-      endKeep.value = endKeep.value.substring(ws.length);
-    }
-  } else if (startKeep && endKeep) {
-    const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
-    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-    deletion.value = removePrefix(deletion.value, newWsStart);
-    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-    deletion.value = removeSuffix(deletion.value, newWsEnd);
-    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-  } else if (endKeep) {
-    const endKeepWsPrefix = leadingWs(endKeep.value);
-    const deletionWsSuffix = trailingWs(deletion.value);
-    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
-    deletion.value = removeSuffix(deletion.value, overlap);
-  } else if (startKeep) {
-    const startKeepWsSuffix = trailingWs(startKeep.value);
-    const deletionWsPrefix = leadingWs(deletion.value);
-    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
-    deletion.value = removePrefix(deletion.value, overlap);
-  }
-}
-
-class WordsWithSpaceDiff extends Diff {
-  tokenize(value) {
-    const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
-    return value.match(regex) || [];
-  }
-}
-var wordsWithSpaceDiff = new WordsWithSpaceDiff;
-
-class LineDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes(`
-`)) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes(`
-`)) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith(`
-`)) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith(`
-`)) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
-  }
-}
-var lineDiff = new LineDiff;
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, `
-`);
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0;i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
-    } else {
-      retLines.push(line);
-    }
-  }
-  return retLines;
-}
-function isSentenceEndPunct(char) {
-  return char == "." || char == "!" || char == "?";
-}
-
-class SentenceDiff extends Diff {
-  tokenize(value) {
-    var _a;
-    const result = [];
-    let tokenStartI = 0;
-    for (let i = 0;i < value.length; i++) {
-      if (i == value.length - 1) {
-        result.push(value.slice(tokenStartI));
-        break;
-      }
-      if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
-        result.push(value.slice(tokenStartI, i + 1));
-        i = tokenStartI = i + 1;
-        while ((_a = value[i + 1]) === null || _a === undefined ? undefined : _a.match(/\s/)) {
-          i++;
-        }
-        result.push(value.slice(tokenStartI, i + 1));
-        tokenStartI = i + 1;
-      }
-    }
-    return result;
-  }
-}
-var sentenceDiff = new SentenceDiff;
-
-class CssDiff extends Diff {
-  tokenize(value) {
-    return value.split(/([{}:;,]|\s+)/);
-  }
-}
-var cssDiff = new CssDiff;
-
-class JsonDiff extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
-  }
-  get useLongestToken() {
-    return true;
-  }
-  castInput(value, options) {
-    const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
-    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
-  }
-  equals(left, right, options) {
-    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
-  }
-}
-var jsonDiff = new JsonDiff;
-function canonicalize(obj, stack, replacementStack, replacer, key) {
-  stack = stack || [];
-  replacementStack = replacementStack || [];
-  if (replacer) {
-    obj = replacer(key === undefined ? "" : key, obj);
-  }
-  let i;
-  for (i = 0;i < stack.length; i += 1) {
-    if (stack[i] === obj) {
-      return replacementStack[i];
-    }
-  }
-  let canonicalizedObj;
-  if (Object.prototype.toString.call(obj) === "[object Array]") {
-    stack.push(obj);
-    canonicalizedObj = new Array(obj.length);
-    replacementStack.push(canonicalizedObj);
-    for (i = 0;i < obj.length; i += 1) {
-      canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
-    }
-    stack.pop();
-    replacementStack.pop();
-    return canonicalizedObj;
-  }
-  if (obj && obj.toJSON) {
-    obj = obj.toJSON();
-  }
-  if (typeof obj === "object" && obj !== null) {
-    stack.push(obj);
-    canonicalizedObj = {};
-    replacementStack.push(canonicalizedObj);
-    const sortedKeys = [];
-    let key2;
-    for (key2 in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
-        sortedKeys.push(key2);
-      }
-    }
-    sortedKeys.sort();
-    for (i = 0;i < sortedKeys.length; i += 1) {
-      key2 = sortedKeys[i];
-      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
-    }
-    stack.pop();
-    replacementStack.pop();
-  } else {
-    canonicalizedObj = obj;
-  }
-  return canonicalizedObj;
-}
-
-class ArrayDiff extends Diff {
-  tokenize(value) {
-    return value.slice();
-  }
-  join(value) {
-    return value;
-  }
-  removeEmpty(value) {
-    return value;
-  }
-}
-var arrayDiff = new ArrayDiff;
 function parsePatch(uniDiff) {
   const diffstr = uniDiff.split(/\n/), list = [];
   let i = 0;
@@ -56757,6 +56278,7 @@ class TextTableRenderable extends Renderable {
   _content;
   _wrapMode;
   _columnWidthMode;
+  _columnFitter;
   _cellPadding;
   _showBorders;
   _border;
@@ -56784,8 +56306,9 @@ class TextTableRenderable extends Renderable {
   _cachedMeasureWidth = undefined;
   _defaultOptions = {
     content: [],
-    wrapMode: "none",
-    columnWidthMode: "content",
+    wrapMode: "word",
+    columnWidthMode: "full",
+    columnFitter: "proportional",
     cellPadding: 0,
     showBorders: true,
     border: true,
@@ -56802,10 +56325,11 @@ class TextTableRenderable extends Renderable {
     attributes: 0
   };
   constructor(ctx, options = {}) {
-    super(ctx, { ...options, buffered: true });
+    super(ctx, { ...options, flexShrink: options.flexShrink ?? 0, buffered: true });
     this._content = options.content ?? this._defaultOptions.content;
     this._wrapMode = options.wrapMode ?? this._defaultOptions.wrapMode;
     this._columnWidthMode = options.columnWidthMode ?? this._defaultOptions.columnWidthMode;
+    this._columnFitter = this.resolveColumnFitter(options.columnFitter);
     this._cellPadding = this.resolveCellPadding(options.cellPadding);
     this._showBorders = options.showBorders ?? this._defaultOptions.showBorders;
     this._border = options.border ?? this._defaultOptions.border;
@@ -56854,6 +56378,16 @@ class TextTableRenderable extends Renderable {
     this._columnWidthMode = value;
     this.invalidateLayoutAndRaster();
   }
+  get columnFitter() {
+    return this._columnFitter;
+  }
+  set columnFitter(value) {
+    const next = this.resolveColumnFitter(value);
+    if (this._columnFitter === next)
+      return;
+    this._columnFitter = next;
+    this.invalidateLayoutAndRaster();
+  }
   get cellPadding() {
     return this._cellPadding;
   }
@@ -57007,7 +56541,7 @@ class TextTableRenderable extends Renderable {
     super.destroySelf();
   }
   setupMeasureFunc() {
-    const measureFunc = (width, widthMode, height, heightMode) => {
+    const measureFunc = (width, widthMode, _height, _heightMode) => {
       const hasWidthConstraint = widthMode !== MeasureMode.Undefined && Number.isFinite(width);
       const rawWidthConstraint = hasWidthConstraint ? Math.max(1, Math.floor(width)) : undefined;
       const widthConstraint = this.resolveLayoutWidthConstraint(rawWidthConstraint);
@@ -57019,9 +56553,6 @@ class TextTableRenderable extends Renderable {
       if (widthMode === MeasureMode.AtMost && rawWidthConstraint !== undefined && this._positionType !== "absolute") {
         measuredWidth = Math.min(rawWidthConstraint, measuredWidth);
       }
-      if (heightMode === MeasureMode.AtMost && Number.isFinite(height) && this._positionType !== "absolute") {
-        measuredHeight = Math.min(Math.max(1, Math.floor(height)), measuredHeight);
-      }
       return {
         width: measuredWidth,
         height: measuredHeight
@@ -57193,6 +56724,9 @@ class TextTableRenderable extends Renderable {
       tableHeight: (rowOffsets[rowOffsets.length - 1] ?? 0) + 1
     };
   }
+  isFullWidthMode() {
+    return this._columnWidthMode === "full";
+  }
   computeColumnWidths(maxTableWidth, borderLayout) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const intrinsicWidths = new Array(this._columnCount).fill(1 + horizontalPadding);
@@ -57215,7 +56749,7 @@ class TextTableRenderable extends Renderable {
       return intrinsicWidths;
     }
     if (currentWidth < maxContentWidth) {
-      if (this._columnWidthMode === "fill") {
+      if (this.isFullWidthMode()) {
         return this.expandColumnWidths(intrinsicWidths, maxContentWidth);
       }
       return intrinsicWidths;
@@ -57245,6 +56779,12 @@ class TextTableRenderable extends Renderable {
     return expanded;
   }
   fitColumnWidths(widths, targetContentWidth) {
+    if (this._columnFitter === "balanced") {
+      return this.fitColumnWidthsBalanced(widths, targetContentWidth);
+    }
+    return this.fitColumnWidthsProportional(widths, targetContentWidth);
+  }
+  fitColumnWidthsProportional(widths, targetContentWidth) {
     const minWidth = 1 + this.getHorizontalCellPadding();
     const hardMinWidths = new Array(widths.length).fill(minWidth);
     const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
@@ -57295,6 +56835,80 @@ class TextTableRenderable extends Renderable {
     }
     return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - integerShrink[idx]));
   }
+  fitColumnWidthsBalanced(widths, targetContentWidth) {
+    const minWidth = 1 + this.getHorizontalCellPadding();
+    const hardMinWidths = new Array(widths.length).fill(minWidth);
+    const baseWidths = widths.map((width) => Math.max(1, Math.floor(width)));
+    const totalBaseWidth = baseWidths.reduce((sum, width) => sum + width, 0);
+    const columns = baseWidths.length;
+    if (columns === 0 || totalBaseWidth <= targetContentWidth) {
+      return baseWidths;
+    }
+    const evenShare = Math.max(minWidth, Math.floor(targetContentWidth / columns));
+    const preferredMinWidths = baseWidths.map((width) => Math.min(width, evenShare));
+    const preferredMinTotal = preferredMinWidths.reduce((sum, width) => sum + width, 0);
+    const floorWidths = preferredMinTotal <= targetContentWidth ? preferredMinWidths : hardMinWidths;
+    const floorTotal = floorWidths.reduce((sum, width) => sum + width, 0);
+    const clampedTarget = Math.max(floorTotal, targetContentWidth);
+    if (totalBaseWidth <= clampedTarget) {
+      return baseWidths;
+    }
+    const shrinkable = baseWidths.map((width, idx) => width - floorWidths[idx]);
+    const totalShrinkable = shrinkable.reduce((sum, value) => sum + value, 0);
+    if (totalShrinkable <= 0) {
+      return [...floorWidths];
+    }
+    const targetShrink = totalBaseWidth - clampedTarget;
+    const shrink = this.allocateShrinkByWeight(shrinkable, targetShrink, "sqrt");
+    return baseWidths.map((width, idx) => Math.max(floorWidths[idx], width - shrink[idx]));
+  }
+  allocateShrinkByWeight(shrinkable, targetShrink, mode) {
+    const shrink = new Array(shrinkable.length).fill(0);
+    if (targetShrink <= 0) {
+      return shrink;
+    }
+    const weights = shrinkable.map((value) => {
+      if (value <= 0) {
+        return 0;
+      }
+      return mode === "sqrt" ? Math.sqrt(value) : value;
+    });
+    const totalWeight = weights.reduce((sum, value) => sum + value, 0);
+    if (totalWeight <= 0) {
+      return shrink;
+    }
+    const fractions = new Array(shrinkable.length).fill(0);
+    let usedShrink = 0;
+    for (let idx = 0;idx < shrinkable.length; idx++) {
+      if (shrinkable[idx] <= 0 || weights[idx] <= 0)
+        continue;
+      const exact = weights[idx] / totalWeight * targetShrink;
+      const whole = Math.min(shrinkable[idx], Math.floor(exact));
+      shrink[idx] = whole;
+      fractions[idx] = exact - whole;
+      usedShrink += whole;
+    }
+    let remainingShrink = targetShrink - usedShrink;
+    while (remainingShrink > 0) {
+      let bestIdx = -1;
+      let bestFraction = -1;
+      for (let idx = 0;idx < shrinkable.length; idx++) {
+        if (shrinkable[idx] - shrink[idx] <= 0)
+          continue;
+        if (bestIdx === -1 || fractions[idx] > bestFraction || fractions[idx] === bestFraction && shrinkable[idx] > shrinkable[bestIdx]) {
+          bestIdx = idx;
+          bestFraction = fractions[idx];
+        }
+      }
+      if (bestIdx === -1) {
+        break;
+      }
+      shrink[bestIdx] += 1;
+      fractions[bestIdx] = 0;
+      remainingShrink -= 1;
+    }
+    return shrink;
+  }
   computeRowHeights(columnWidths) {
     const horizontalPadding = this.getHorizontalCellPadding();
     const verticalPadding = this.getVerticalCellPadding();
@@ -57618,7 +57232,7 @@ class TextTableRenderable extends Renderable {
     if (width === undefined || !Number.isFinite(width) || width <= 0) {
       return;
     }
-    if (this._wrapMode !== "none" || this._columnWidthMode === "fill") {
+    if (this._wrapMode !== "none" || this.isFullWidthMode()) {
       return Math.max(1, Math.floor(width));
     }
     return;
@@ -57629,6 +57243,12 @@ class TextTableRenderable extends Renderable {
   getVerticalCellPadding() {
     return this._cellPadding * 2;
   }
+  resolveColumnFitter(value) {
+    if (value === undefined) {
+      return this._defaultOptions.columnFitter;
+    }
+    return value === "balanced" ? "balanced" : "proportional";
+  }
   resolveCellPadding(value) {
     if (value === undefined || !Number.isFinite(value)) {
       return this._defaultOptions.cellPadding;
@@ -59404,8 +59024,9 @@ class MarkdownRenderable extends Renderable {
   resolveTableRenderableOptions() {
     const borders = this._tableOptions?.borders ?? true;
     return {
-      columnWidthMode: this._tableOptions?.widthMode ?? "content",
-      wrapMode: this._tableOptions?.wrapMode ?? "none",
+      columnWidthMode: this._tableOptions?.widthMode ?? "full",
+      columnFitter: this._tableOptions?.columnFitter ?? "proportional",
+      wrapMode: this._tableOptions?.wrapMode ?? "word",
       cellPadding: this._tableOptions?.cellPadding ?? 0,
       border: borders,
       outerBorder: this._tableOptions?.outerBorder ?? borders,
@@ -59417,6 +59038,7 @@ class MarkdownRenderable extends Renderable {
   }
   applyTableRenderableOptions(tableRenderable, options) {
     tableRenderable.columnWidthMode = options.columnWidthMode;
+    tableRenderable.columnFitter = options.columnFitter;
     tableRenderable.wrapMode = options.wrapMode;
     tableRenderable.cellPadding = options.cellPadding;
     tableRenderable.border = options.border;
@@ -59447,6 +59069,7 @@ class MarkdownRenderable extends Renderable {
       width: "100%",
       marginBottom,
       columnWidthMode: options.columnWidthMode,
+      columnFitter: options.columnFitter,
       wrapMode: options.wrapMode,
       cellPadding: options.cellPadding,
       border: options.border,
@@ -60306,6 +59929,34 @@ class ContentRenderable extends BoxRenderable {
     return this.getChildrenSortedByPrimaryAxis().map((child) => child.num);
   }
 }
+var SCROLLBOX_PADDING_KEYS = [
+  "padding",
+  "paddingX",
+  "paddingY",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft"
+];
+function pickScrollBoxPadding(options) {
+  if (!options)
+    return {};
+  const picked = {};
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    const value = options[key];
+    if (value !== undefined) {
+      picked[key] = value;
+    }
+  }
+  return picked;
+}
+function stripScrollBoxPadding(options) {
+  const sanitized = { ...options };
+  for (const key of SCROLLBOX_PADDING_KEYS) {
+    delete sanitized[key];
+  }
+  return sanitized;
+}
 
 class ScrollBoxRenderable extends BoxRenderable {
   static idCounter = 0;
@@ -60453,27 +60104,38 @@ class ScrollBoxRenderable extends BoxRenderable {
       this._isApplyingStickyScroll = wasApplyingStickyScroll;
     }
   }
-  constructor(ctx, {
-    wrapperOptions,
-    viewportOptions,
-    contentOptions,
-    rootOptions,
-    scrollbarOptions,
-    verticalScrollbarOptions,
-    horizontalScrollbarOptions,
-    stickyScroll = false,
-    stickyStart,
-    scrollX = false,
-    scrollY = true,
-    scrollAcceleration,
-    viewportCulling = true,
-    ...options
-  }) {
+  constructor(ctx, options) {
+    const {
+      wrapperOptions,
+      viewportOptions,
+      contentOptions,
+      rootOptions,
+      scrollbarOptions,
+      verticalScrollbarOptions,
+      horizontalScrollbarOptions,
+      stickyScroll = false,
+      stickyStart,
+      scrollX = false,
+      scrollY = true,
+      scrollAcceleration,
+      viewportCulling = true,
+      ...rootBoxOptions
+    } = options;
+    const forwardedContentPadding = {
+      ...pickScrollBoxPadding(rootBoxOptions),
+      ...pickScrollBoxPadding(rootOptions)
+    };
+    const sanitizedRootBoxOptions = stripScrollBoxPadding(rootBoxOptions);
+    const sanitizedRootOptions = rootOptions ? stripScrollBoxPadding(rootOptions) : undefined;
+    const mergedContentOptions = {
+      ...forwardedContentPadding,
+      ...contentOptions
+    };
     super(ctx, {
       flexDirection: "row",
       alignItems: "stretch",
-      ...options,
-      ...rootOptions
+      ...sanitizedRootBoxOptions,
+      ...sanitizedRootOptions
     });
     this.internalId = ScrollBoxRenderable.idCounter++;
     this._stickyScroll = stickyScroll;
@@ -60505,7 +60167,7 @@ class ScrollBoxRenderable extends BoxRenderable {
       onSizeChange: () => {
         this.recalculateBarProps();
       },
-      ...contentOptions,
+      ...mergedContentOptions,
       id: `scroll-box-content-${this.internalId}`
     });
     this.viewport.add(this.content);
@@ -60821,6 +60483,34 @@ class ScrollBoxRenderable extends BoxRenderable {
       this.requestRender();
     });
   }
+  set padding(value) {
+    this.content.padding = value;
+    this.requestRender();
+  }
+  set paddingX(value) {
+    this.content.paddingX = value;
+    this.requestRender();
+  }
+  set paddingY(value) {
+    this.content.paddingY = value;
+    this.requestRender();
+  }
+  set paddingTop(value) {
+    this.content.paddingTop = value;
+    this.requestRender();
+  }
+  set paddingRight(value) {
+    this.content.paddingRight = value;
+    this.requestRender();
+  }
+  set paddingBottom(value) {
+    this.content.paddingBottom = value;
+    this.requestRender();
+  }
+  set paddingLeft(value) {
+    this.content.paddingLeft = value;
+    this.requestRender();
+  }
   set rootOptions(options) {
     Object.assign(this, options);
     this.requestRender();
@@ -61582,8 +61272,8 @@ class TabSelectRenderable extends Renderable {
   }
 }
 
-// node_modules/@opentui/react/chunk-9gg102mq.js
-init_chunk_eecw9x2f();
+// node_modules/@opentui/react/chunk-7v2hbtna.js
+init_chunk_2mx7fq49();
 var import_react = __toESM(require_react(), 1);
 var import_react2 = __toESM(require_react(), 1);
 var import_react3 = __toESM(require_react(), 1);
@@ -61710,7 +61400,7 @@ class ErrorBoundary extends import_react3.default.Component {
 }
 var package_default = {
   name: "@opentui/react",
-  version: "0.1.83",
+  version: "0.1.84",
   description: "React renderer for building terminal user interfaces using OpenTUI core",
   license: "MIT",
   repository: {
@@ -62045,7 +61735,7 @@ var hostConfig = {
 var reconciler = import_react_reconciler.default(hostConfig);
 if (process.env["DEV"] === "true") {
   try {
-    await init_chunk_pm1hna8x().then(() => exports_chunk_pm1hna8x);
+    await init_chunk_bdqvmfwv().then(() => exports_chunk_bdqvmfwv);
   } catch (error) {
     if (error.code === "ERR_MODULE_NOT_FOUND") {
       console.warn(`
@@ -62090,7 +61780,7 @@ function createRoot(renderer) {
 }
 
 // node_modules/@opentui/react/index.js
-init_chunk_eecw9x2f();
+init_chunk_2mx7fq49();
 var import_react5 = __toESM(require_react(), 1);
 var import_react6 = __toESM(require_react(), 1);
 var import_react7 = __toESM(require_react(), 1);
@@ -63078,6 +62768,10 @@ function App() {
 // index.jsx
 var jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
 async function main2() {
+  if (process.env.APEX_LOCAL_SERVER === "1") {
+    const { startServer } = await Promise.resolve().then(() => __toESM(require_server(), 1));
+    await startServer();
+  }
   const renderer = await createCliRenderer({
     useAlternateScreen: true,
     exitOnCtrlC: false,