@selesai/code 0.10.1 → 0.11.0

package/dist/extensions/pi-tool-display/tests/user-message-box.test.ts

@@ -0,0 +1,908 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  extractUserMessageMarkdownState,
+} from "../src/user-message-box-markdown.ts";
+import {
+  patchUserMessageRenderPrototype,
+  type PatchableUserMessagePrototype,
+} from "../src/user-message-box-patch.ts";
+import {
+  patchNativeUserMessagePrototype,
+  shouldBypassUserMessageMarkdownRebuild,
+  createUserMessageMarkdownLineRenderer,
+} from "../src/user-message-box-renderer.ts";
+import {
+  addUserMessageVerticalPadding,
+  applyUserMessageBackground,
+  normalizeUserMessageContentLine,
+  normalizeUserMessageContentLines,
+  type UserMessageBackgroundTheme,
+} from "../src/user-message-box-utils.ts";
+
+// ===========================================================================
+// Issue #10: OSC 133 prompt marker stripping
+// Each variant: BEL-terminated (\x07) and ST-terminated (\x1b\\)
+// ===========================================================================
+
+test("osc133 strips BEL-terminated A marker from content", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("before\x1b]133;A\x07after"),
+    "beforeafter",
+  );
+});
+
+test("osc133 strips BEL-terminated B marker from content", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;B\x07middle"),
+    "middle",
+  );
+});
+
+test("osc133 strips BEL-terminated C marker from content", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("data\x1b]133;C\x07"),
+    "data",
+  );
+});
+
+test("osc133 strips BEL-terminated D marker from content", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;D\x07trailing"),
+    "trailing",
+  );
+});
+
+test("osc133 strips ST-terminated A marker", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("lead\x1b]133;A\x1b\\tail"),
+    "leadtail",
+  );
+});
+
+test("osc133 strips ST-terminated B marker", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;B\x1b\\inner"),
+    "inner",
+  );
+});
+
+test("osc133 strips ST-terminated C marker", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;C\x1b\\"),
+    "",
+  );
+});
+
+test("osc133 strips ST-terminated D marker", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;D\x1b\\data"),
+    "data",
+  );
+});
+
+test("osc133 strips multiple markers in a single line", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;A\x07hello\x1b]133;B\x07 world\x1b]133;C\x07"),
+    "hello world",
+  );
+});
+
+test("osc133 strips marker with optional semicolon-delimited parameters", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;A;url=https://example.com\x07text\x1b]133;B\x07"),
+    "text",
+  );
+});
+
+test("osc133 markers are stripped via applyUserMessageBackground path", () => {
+  assert.equal(
+    applyUserMessageBackground(undefined, "hello\x1b]133;A\x07"),
+    "hello",
+  );
+});
+
+test("osc133-only line is treated as visually empty", () => {
+  assert.equal(
+    normalizeUserMessageContentLine("\x1b]133;A\x07\x1b]133;B\x07"),
+    "",
+  );
+});
+
+// ===========================================================================
+// Nested Box → Markdown structures
+// ===========================================================================
+
+test("extract finds deeply nested markdown child at depth 10", () => {
+  const theme = { heading: () => "" };
+  let child: Record<string, unknown> = {
+    text: "deep markdown",
+    theme,
+  };
+  for (let i = 0; i < 10; i++) {
+    child = { children: [child] };
+  }
+  const extracted = extractUserMessageMarkdownState({ children: [child] });
+  assert.equal(extracted?.text, "deep markdown");
+  assert.equal(extracted?.theme, theme);
+});
+
+test("extract returns first markdown child via DFS (not last)", () => {
+  const themeA = { heading: () => "a" };
+  const themeB = { heading: () => "b" };
+  const extracted = extractUserMessageMarkdownState({
+    children: [
+      { text: "first", theme: themeA },
+      { text: "second", theme: themeB },
+    ],
+  });
+  assert.equal(extracted?.text, "first");
+  assert.equal(extracted?.theme, themeA);
+});
+
+test("extract returns undefined when no markdown child exists", () => {
+  const extracted = extractUserMessageMarkdownState({
+    children: [{ lines: 3 }, { other: "data" }],
+  });
+  assert.equal(extracted, undefined);
+});
+
+test("extract returns undefined when child has theme but no text string", () => {
+  const extracted = extractUserMessageMarkdownState({
+    children: [{ theme: { heading: () => "" } }],
+  });
+  assert.equal(extracted, undefined);
+});
+
+test("extract returns markdown when top-level value itself is markdown-like", () => {
+  const theme = { heading: () => "" };
+  const extracted = extractUserMessageMarkdownState({
+    text: "self markdown",
+    theme,
+  } as never);
+  assert.equal(extracted?.text, "self markdown");
+  assert.equal(extracted?.theme, theme);
+});
+
+// ===========================================================================
+// Malformed children on extractUserMessageMarkdownState
+// ===========================================================================
+
+test("extract handles null children gracefully", () => {
+  assert.equal(extractUserMessageMarkdownState({ children: null }), undefined);
+});
+
+test("extract handles undefined children (missing property) gracefully", () => {
+  assert.equal(extractUserMessageMarkdownState({}), undefined);
+});
+
+test("extract handles children as a plain string (non-array)", () => {
+  assert.equal(
+    extractUserMessageMarkdownState({ children: "not-an-array" as never }),
+    undefined,
+  );
+});
+
+test("extract handles children as a number", () => {
+  assert.equal(
+    extractUserMessageMarkdownState({ children: 42 as never }),
+    undefined,
+  );
+});
+
+test("extract handles array children containing only non-object items", () => {
+  assert.equal(
+    extractUserMessageMarkdownState({ children: [null, 42, "str", undefined, true] }),
+    undefined,
+  );
+});
+
+test("extract handles null top-level value", () => {
+  assert.equal(extractUserMessageMarkdownState(null as never), undefined);
+});
+
+test("extract handles undefined top-level value", () => {
+  assert.equal(extractUserMessageMarkdownState(undefined as never), undefined);
+});
+
+test("extract handles circular reference (stack overflow expected)", () => {
+  const circular: Record<string, unknown> = { children: [] };
+  circular.children = [circular];
+  // findMarkdownChild recurses without cycle detection, so this throws.
+  // In production the caller wraps extract in try/catch.
+  assert.throws(() => {
+    extractUserMessageMarkdownState(circular);
+  });
+});
+
+// ===========================================================================
+// defaultTextStyle bgColor sanitization
+// ===========================================================================
+
+test("extract strips bgColor but keeps other defaultTextStyle props", () => {
+  const extracted = extractUserMessageMarkdownState({
+    children: [{
+      text: "styled",
+      theme: {},
+      defaultTextStyle: { color: "red", bgColor: () => "", bold: true },
+    }],
+  });
+  assert.equal(extracted?.defaultTextStyle?.color, "red");
+  assert.equal(extracted?.defaultTextStyle?.bold, true);
+  assert.equal("bgColor" in (extracted?.defaultTextStyle ?? {}), false);
+});
+
+test("extract returns undefined defaultTextStyle when all props were bgColor-only", () => {
+  const extracted = extractUserMessageMarkdownState({
+    children: [{
+      text: "text",
+      theme: {},
+      defaultTextStyle: { bgColor: () => "" },
+    }],
+  });
+  assert.equal(extracted?.defaultTextStyle, undefined);
+});
+
+test("extract returns undefined defaultTextStyle when value is not a record", () => {
+  const extracted = extractUserMessageMarkdownState({
+    children: [{
+      text: "raw",
+      theme: {},
+      defaultTextStyle: "string" as never,
+    }],
+  });
+  assert.equal(extracted?.defaultTextStyle, undefined);
+});
+
+// ===========================================================================
+// applyUserMessageBackground with various theme objects
+// ===========================================================================
+
+test("applyBg on empty theme object returns sanitized text unchanged", () => {
+  const result = applyUserMessageBackground({}, "\x1b[31mred\x1b[0m");
+  // \x1b[0m → \x1b[39;22;23;24;25;27;28;29m (reset sans bg params)
+  assert.ok(result.includes("\x1b[31mred"));
+  assert.doesNotMatch(result, /\x1b\[0m/);
+});
+
+test("applyBg with empty string returns empty string", () => {
+  assert.equal(applyUserMessageBackground({ getBgAnsi: () => "\x1b[48;5;24m" }, ""), "");
+  assert.equal(applyUserMessageBackground(undefined, ""), "");
+});
+
+test("applyBg ignores getBgAnsi when it is not a function and falls to bg", () => {
+  const result = applyUserMessageBackground(
+    {
+      getBgAnsi: "not-a-fn" as never,
+      bg: (_color, text) => `wrapped(${text})`,
+    },
+    "hello",
+  );
+  assert.equal(result, "wrapped(hello)");
+});
+
+test("applyBg falls back to bg when getBgAnsi throws", () => {
+  const result = applyUserMessageBackground(
+    {
+      getBgAnsi: () => { throw new Error("oops"); },
+      bg: (_color, text) => `fallback(${text})`,
+    },
+    "hello",
+  );
+  assert.equal(result, "fallback(hello)");
+});
+
+test("applyBg returns sanitized text when both getBgAnsi and bg throw", () => {
+  const result = applyUserMessageBackground(
+    {
+      getBgAnsi: () => { throw new Error("e1"); },
+      bg: (_color, _text) => { throw new Error("e2"); },
+    },
+    "\x1b[32mtext",
+  );
+  assert.equal(result, "\x1b[32mtext");
+});
+
+test("applyBg returns sanitized text when theme has neither method", () => {
+  const result = applyUserMessageBackground(
+    { unrelated: true } as never,
+    "\x1b[33myellow\x1b[0m",
+  );
+  assert.ok(result.includes("\x1b[33myellow"));
+});
+
+test("applyBg passes userMessageBg constant to getBgAnsi", () => {
+  let capturedColor = "";
+  applyUserMessageBackground(
+    {
+      getBgAnsi: (color) => {
+        capturedColor = color;
+        return "\x1b[48;5;24m";
+      },
+    },
+    "test",
+  );
+  assert.equal(capturedColor, "userMessageBg");
+});
+
+test("applyBg passes userMessageBg constant to bg fallback", () => {
+  let capturedColor = "";
+  const result = applyUserMessageBackground(
+    {
+      bg: (color, text) => {
+        capturedColor = color;
+        return `[${color}]${text}`;
+      },
+    },
+    "text",
+  );
+  assert.equal(capturedColor, "userMessageBg");
+  assert.equal(result, "[userMessageBg]text");
+});
+
+// ===========================================================================
+// Background double-application prevention (Issue #8 / #3)
+// ===========================================================================
+
+test("applyBg strips internal SGR 49 and appends exactly one reset at end", () => {
+  const rendered = applyUserMessageBackground(
+    { getBgAnsi: () => "\x1b[48;5;24m" },
+    "\x1b[31mhello\x1b[49m",
+  );
+  const fortyNineMatches = rendered.match(/\x1b\[49m/g);
+  assert.equal(fortyNineMatches?.length ?? 0, 1);
+  assert.ok(rendered.endsWith("\x1b[49m"));
+});
+
+test("applyBg strips multiple SGR 49 occurrences, appends single reset", () => {
+  const rendered = applyUserMessageBackground(
+    { getBgAnsi: () => "\x1b[48;5;24m" },
+    "\x1b[49mstart\x1b[49m middle\x1b[49m",
+  );
+  const fortyNineMatches = rendered.match(/\x1b\[49m/g);
+  assert.equal(fortyNineMatches?.length ?? 0, 1);
+  assert.ok(rendered.endsWith("\x1b[49m"));
+});
+
+test("applyBg strips existing background SGR before applying new bg via getBgAnsi", () => {
+  const rendered = applyUserMessageBackground(
+    { getBgAnsi: () => "\x1b[48;5;24m" },
+    "\x1b[48;5;160mtext\x1b[49m",
+  );
+  // Original bg (48;5;160) stripped
+  assert.doesNotMatch(rendered, /\x1b\[48;5;160m/);
+  // New bg applied exactly once
+  const bg24Matches = rendered.match(/\x1b\[48;5;24m/g);
+  assert.equal(bg24Matches?.length ?? 0, 1);
+  // Reset appended exactly once
+  const fortyNineMatches = rendered.match(/\x1b\[49m/g);
+  assert.equal(fortyNineMatches?.length ?? 0, 1);
+  assert.ok(rendered.endsWith("\x1b[49m"));
+});
+
+test("applyBg via bg function does not double-wrap", () => {
+  const rendered = applyUserMessageBackground(
+    { bg: (_color, text) => `[bg]${text}[/bg]` },
+    "\x1b[48;5;24mhello",
+  );
+  assert.ok(rendered.startsWith("[bg]"));
+  assert.ok(rendered.includes("hello"));
+  // The SGR 48;5;24 is stripped by sanitizeAnsiForThemedOutput
+  assert.doesNotMatch(rendered, /\x1b\[48;5;24m/);
+});
+
+// ===========================================================================
+// normalizeUserMessageContentLines edge cases
+// ===========================================================================
+
+test("normalizeLines empty array returns empty array", () => {
+  assert.deepEqual(normalizeUserMessageContentLines([]), []);
+});
+
+test("normalizeLines trims leading and trailing whitespace-only lines", () => {
+  assert.deepEqual(
+    normalizeUserMessageContentLines(["   ", "content", "\t"]),
+    ["content"],
+  );
+});
+
+test("normalizeLines preserves interior empty lines", () => {
+  assert.deepEqual(
+    normalizeUserMessageContentLines(["start", "", "end"]),
+    ["start", "", "end"],
+  );
+});
+
+test("normalizeLines trims only edge lines, not interior whitespace", () => {
+  assert.deepEqual(
+    normalizeUserMessageContentLines(["", "  indented  ", "middle", ""]),
+    ["  indented  ", "middle"],
+  );
+});
+
+test("normalizeLines treats leading OSC133-only lines as visually empty and trims them", () => {
+  assert.deepEqual(
+    normalizeUserMessageContentLines([
+      "\x1b]133;A\x07\x1b]133;B\x07   ",
+      "actual",
+      "\x1b]133;C\x07\u001b[0m",
+    ]),
+    ["actual"],
+  );
+});
+
+test("normalizeLines handles array with all visually empty lines", () => {
+  assert.deepEqual(
+    normalizeUserMessageContentLines(["", "   ", "\x1b[0m"]),
+    [],
+  );
+});
+
+test("normalizeLines preserves lines with trailing spaces that are not edge lines", () => {
+  // Trailing spaces on interior lines are preserved
+  const result = normalizeUserMessageContentLines(["hello   ", "world"]);
+  assert.equal(result[0], "hello   ");
+  assert.equal(result[1], "world");
+});
+
+// ===========================================================================
+// normalizeUserMessageContentLine edge cases
+// ===========================================================================
+
+test("normalizeLine preserves tab characters", () => {
+  assert.equal(normalizeUserMessageContentLine("\thello\tworld"), "\thello\tworld");
+});
+
+test("normalizeLine preserves non-SGR control characters", () => {
+  assert.equal(normalizeUserMessageContentLine("a\x00b\x01c"), "a\x00b\x01c");
+});
+
+test("normalizeLine handles very long line without truncation", () => {
+  const longLine = "x".repeat(10000);
+  assert.equal(normalizeUserMessageContentLine(longLine), longLine);
+});
+
+test("normalizeLine handles very long line with ANSI sequences", () => {
+  const result = normalizeUserMessageContentLine(
+    "\x1b[31m" + "x".repeat(5000) + "\x1b[0m" + "y".repeat(5000),
+  );
+  // Content survives; SGR 0 is converted to reset params sans bg
+  assert.ok(result.includes("x".repeat(5000)));
+  assert.ok(result.includes("y".repeat(5000)));
+});
+
+test("normalizeLine returns empty for line with only SGR control sequences", () => {
+  assert.equal(normalizeUserMessageContentLine("\x1b[0m\x1b[31m\x1b[0m"), "");
+});
+
+test("normalizeLine returns empty for empty string", () => {
+  assert.equal(normalizeUserMessageContentLine(""), "");
+});
+
+test("normalizeLine returns empty for whitespace-only string", () => {
+  assert.equal(normalizeUserMessageContentLine("   \t  "), "");
+});
+
+test("normalizeLine preserves hyperlinks (OSC 8) while stripping OSC 133", () => {
+  const hyperlink = "\x1b]8;;https://example.com\x1b\\link\x1b]8;;\x1b\\";
+  const result = normalizeUserMessageContentLine(hyperlink);
+  // OSC 8 hyperlinks should be preserved, not stripped
+  assert.equal(result, hyperlink);
+});
+
+// ===========================================================================
+// addUserMessageVerticalPadding edge cases
+// ===========================================================================
+
+test("addPadding on empty array returns two empty padding lines", () => {
+  assert.deepEqual(addUserMessageVerticalPadding([]), ["", ""]);
+});
+
+test("addPadding on single line adds one blank line before and after", () => {
+  assert.deepEqual(addUserMessageVerticalPadding(["only"]), ["", "only", ""]);
+});
+
+test("addPadding on already-padded input adds another layer of padding", () => {
+  assert.deepEqual(
+    addUserMessageVerticalPadding(["", "content", ""]),
+    ["", "", "content", "", ""],
+  );
+});
+
+test("addPadding on multi-line input pads all sides equally", () => {
+  const result = addUserMessageVerticalPadding(["a", "b", "c"]);
+  assert.equal(result.length, 5);
+  assert.equal(result[0], "");
+  assert.equal(result[result.length - 1], "");
+  assert.deepEqual(result.slice(1, -1), ["a", "b", "c"]);
+});
+
+// ===========================================================================
+// patchUserMessageRenderPrototype version handling
+// ===========================================================================
+
+test("patchRenderPrototype skips when prototype.render is not a function", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: undefined as never,
+  };
+  patchUserMessageRenderPrototype(prototype, 7, (orig) => orig);
+  assert.equal(prototype.render, undefined);
+});
+
+test("patchRenderPrototype skips when already patched with same version", () => {
+  let buildCallCount = 0;
+  const originalRender = (width: number) => [`orig:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: originalRender,
+    __piUserMessageOriginalRender: originalRender,
+    __piUserMessageNativePatched: true,
+    __piUserMessagePatchVersion: 7,
+  };
+  patchUserMessageRenderPrototype(prototype, 7, (_orig) => {
+    buildCallCount++;
+    return (width) => [`patched:${width}`];
+  });
+  assert.equal(buildCallCount, 0);
+  assert.equal(prototype.render, originalRender);
+});
+
+test("patchRenderPrototype reapplies when version is different (upgrade)", () => {
+  const originalRender = (width: number) => [`orig:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => [`stale:${width}`],
+    __piUserMessageOriginalRender: originalRender,
+    __piUserMessageNativePatched: true,
+    __piUserMessagePatchVersion: 1,
+  };
+  patchUserMessageRenderPrototype(prototype, 7, (baseRender) => {
+    return function (this: unknown, width: number) {
+      return [`v7:${baseRender.call(this, width)}`];
+    };
+  });
+  assert.deepEqual(prototype.render(42), ["v7:orig:42"]);
+  assert.equal(prototype.__piUserMessagePatchVersion, 7);
+});
+
+test("patchRenderPrototype saves original render when __piUserMessageOriginalRender is absent", () => {
+  const originalRender = (width: number) => [`orig:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: originalRender,
+  };
+  patchUserMessageRenderPrototype(prototype, 7, (baseRender) => {
+    return function (this: unknown, width: number) {
+      return [`patched:${baseRender.call(this, width)}`];
+    };
+  });
+  assert.equal(prototype.__piUserMessageOriginalRender, originalRender);
+  assert.notEqual(prototype.render, originalRender);
+  assert.deepEqual(prototype.render(10), ["patched:orig:10"]);
+});
+
+test("patchRenderPrototype saves original and patches when same version but original undefined", () => {
+  const originalRender = (width: number) => [`r:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: originalRender,
+    __piUserMessageOriginalRender: undefined,
+    __piUserMessageNativePatched: true,
+    __piUserMessagePatchVersion: 5,
+  };
+  // Guard requires all three: patched + same version + original IS function.
+  // Since original is undefined, the function saves it and applies patch.
+  patchUserMessageRenderPrototype(prototype, 5, (baseRender) => {
+    return function (this: unknown, width: number) {
+      return [`patched:${baseRender.call(this, width)}`];
+    };
+  });
+  assert.equal(prototype.__piUserMessageOriginalRender, originalRender);
+  assert.deepEqual(prototype.render(10), ["patched:r:10"]);
+  assert.equal(prototype.__piUserMessagePatchVersion, 5);
+});
+
+test("patchRenderPrototype saves original and patches when version differs and original undefined", () => {
+  const originalRender = (width: number) => [`r:${width}`];
+  const prototype: PatchableUserMessagePrototype = {
+    render: originalRender,
+    __piUserMessageOriginalRender: undefined,
+    __piUserMessageNativePatched: true,
+    __piUserMessagePatchVersion: 5,
+  };
+  // Version differs (5 !== 7) so guard doesn't skip.
+  // Original is undefined, so the function saves it and applies patch.
+  patchUserMessageRenderPrototype(prototype, 7, (baseRender) => {
+    return function (this: unknown, width: number) {
+      return [`v7:${baseRender.call(this, width)}`];
+    };
+  });
+  assert.equal(prototype.__piUserMessageOriginalRender, originalRender);
+  assert.deepEqual(prototype.render(10), ["v7:r:10"]);
+  assert.equal(prototype.__piUserMessagePatchVersion, 7);
+});
+
+// ===========================================================================
+// patchNativeUserMessagePrototype: width threshold and enable guard
+// ===========================================================================
+
+test("nativeRender width < 8 bypasses native rendering", () => {
+  let capturedWidth: number | undefined;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => {
+      capturedWidth = width;
+      return [`orig:${width}`];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  assert.deepEqual(prototype.render(7), ["orig:7"]);
+  assert.equal(capturedWidth, 7);
+});
+
+test("nativeRender width exactly 8 triggers native rendering", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: () => ["content"],
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  const rendered = prototype.render(8);
+  assert.ok(rendered.some((line) => line.includes("╭")), "should have top border");
+  assert.ok(rendered.some((line) => line.includes("╰")), "should have bottom border");
+});
+
+test("nativeRender width 0 bypasses native rendering", () => {
+  let capturedWidth: number | undefined;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => {
+      capturedWidth = width;
+      return [`orig:${width}`];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  assert.deepEqual(prototype.render(0), ["orig:0"]);
+  assert.equal(capturedWidth, 0);
+});
+
+test("nativeRender negative width bypasses native rendering", () => {
+  let capturedWidth: number | undefined;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => {
+      capturedWidth = width;
+      return [`orig:${width}`];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  assert.deepEqual(prototype.render(-5), ["orig:0"]);
+  assert.equal(capturedWidth, 0);
+});
+
+test("nativeRender fractional width floors before threshold check", () => {
+  let capturedWidth: number | undefined;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => {
+      capturedWidth = width;
+      return [`orig:${width}`];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  // 7.5 floors to 7 → < 8 → bypass
+  assert.deepEqual(prototype.render(7.5), ["orig:7"]);
+  assert.equal(capturedWidth, 7);
+});
+
+test("nativeRender isEnabled false bypasses native rendering regardless of width", () => {
+  let capturedWidth: number | undefined;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (width: number) => {
+      capturedWidth = width;
+      return [`orig:${width}`];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => false);
+  assert.deepEqual(prototype.render(100), ["orig:100"]);
+  assert.equal(capturedWidth, 100);
+});
+
+test("nativeRender produces top margin spacer and border when enabled and width >= 8", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: () => ["user message body"],
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  const rendered = prototype.render(40);
+  assert.equal(rendered[0], "", "first line is top margin spacer");
+  assert.ok(rendered[1]?.includes("╭"), "second line has top border");
+  assert.ok(rendered.some((l) => l.includes("│")), "has content border lines");
+  assert.ok(rendered.some((l) => l.includes("╰")), "has bottom border");
+});
+
+test("nativeRender prototype without render function does not crash", () => {
+  const prototype: Partial<PatchableUserMessagePrototype> = {};
+  patchNativeUserMessagePrototype(
+    prototype as PatchableUserMessagePrototype,
+    () => undefined,
+    () => true,
+  );
+  assert.equal((prototype as PatchableUserMessagePrototype).render, undefined);
+});
+
+test("nativeRender invokes original for empty body content", () => {
+  let calledWith = -1;
+  const prototype: PatchableUserMessagePrototype = {
+    render: (w) => {
+      calledWith = w;
+      return [];
+    },
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+  prototype.render(8);
+  // original called with content-width = max(1, 8-2-1*2) = max(1, 4) = 4
+  assert.equal(calledWith, 4);
+});
+
+// ===========================================================================
+// shouldBypassUserMessageMarkdownRebuild edge cases
+// ===========================================================================
+
+test("bypass guard allows short text within limits", () => {
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({ text: "short", theme: {} }),
+    false,
+  );
+});
+
+test("bypass guard triggers on text over 100000 chars", () => {
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({
+      text: "x".repeat(100001),
+      theme: {},
+    }),
+    true,
+  );
+});
+
+test("bypass guard triggers when line count exceeds 2000", () => {
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({
+      text: `${"line\n".repeat(2000)}tail`,
+      theme: {},
+    }),
+    true,
+  );
+});
+
+test("bypass guard does NOT bypass exactly 2000 lines (threshold is > 2000)", () => {
+  // 1999 newlines = 2000 lines; guard checks > 2000, so 2000 should NOT bypass
+  assert.equal(
+    shouldBypassUserMessageMarkdownRebuild({
+      text: "a\n".repeat(1999) + "a",
+      theme: {},
+    }),
+    false,
+  );
+});
+
+// ===========================================================================
+// createUserMessageMarkdownLineRenderer cache behavior
+// ===========================================================================
+
+test("markdown line renderer cache hits on identical state and width", () => {
+  let rendererCreationCount = 0;
+  let renderCallCount = 0;
+  const renderMarkdown = createUserMessageMarkdownLineRenderer((state) => {
+    rendererCreationCount++;
+    return {
+      render(width: number) {
+        renderCallCount++;
+        return [`${state.text}:${width}`];
+      },
+    };
+  });
+
+  const instance = {};
+  const theme = { heading: () => "" };
+  const state = { text: "cached", theme, defaultTextStyle: { bold: true } };
+
+  assert.deepEqual(renderMarkdown(instance, state, 24), ["cached:24"]);
+  assert.deepEqual(renderMarkdown(instance, state, 24), ["cached:24"]);
+  assert.equal(rendererCreationCount, 1);
+  assert.equal(renderCallCount, 1);
+});
+
+test("markdown line renderer re-renders on width change with same renderer", () => {
+  let rendererCreationCount = 0;
+  let renderCallCount = 0;
+  const renderMarkdown = createUserMessageMarkdownLineRenderer((state) => {
+    rendererCreationCount++;
+    return {
+      render(width: number) {
+        renderCallCount++;
+        return [`${state.text}:${width}`];
+      },
+    };
+  });
+
+  const instance = {};
+  const theme = { heading: () => "" };
+  const state = { text: "width-test", theme };
+
+  assert.deepEqual(renderMarkdown(instance, state, 10), ["width-test:10"]);
+  assert.deepEqual(renderMarkdown(instance, state, 20), ["width-test:20"]);
+  assert.equal(rendererCreationCount, 1);
+  assert.equal(renderCallCount, 2);
+});
+
+test("markdown line renderer creates new renderer on state change", () => {
+  let rendererCreationCount = 0;
+  const renderMarkdown = createUserMessageMarkdownLineRenderer((state) => {
+    rendererCreationCount++;
+    return {
+      render(_width: number) {
+        return [`${state.text}`];
+      },
+    };
+  });
+
+  const instance = {};
+  const theme = { heading: () => "" };
+
+  assert.deepEqual(renderMarkdown(instance, { text: "a", theme }, 10), ["a"]);
+  assert.deepEqual(renderMarkdown(instance, { text: "b", theme }, 10), ["b"]);
+  assert.equal(rendererCreationCount, 2);
+});
+
+test("markdown line renderer uses separate cache per instance (WeakMap)", () => {
+  let rendererCreationCount = 0;
+  const renderMarkdown = createUserMessageMarkdownLineRenderer((state) => {
+    rendererCreationCount++;
+    return {
+      render(_width: number) {
+        return [`${state.text}`];
+      },
+    };
+  });
+
+  const instanceA = {};
+  const instanceB = {};
+  const theme = { heading: () => "" };
+  const state = { text: "shared", theme };
+
+  assert.deepEqual(renderMarkdown(instanceA, state, 10), ["shared"]);
+  assert.deepEqual(renderMarkdown(instanceB, state, 10), ["shared"]);
+  // Each instance gets its own cache entry, so two renderers created
+  assert.equal(rendererCreationCount, 2);
+});
+
+// ===========================================================================
+// End-to-end: patchNativeUserMessagePrototype with real theme
+// ===========================================================================
+
+test("nativeRender applies theme coloring via fg and bold", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: () => ["hello world"],
+  };
+  const theme = {
+    fg: (_color: string, text: string) => `[${_color}]${text}`,
+    bold: (text: string) => `*${text}*`,
+  };
+  patchNativeUserMessagePrototype(prototype, () => theme, () => true);
+
+  const rendered = prototype.render(30);
+  // Title should be bold + accent-colored
+  const titleLine = rendered.find((l) => l.includes("user")) ?? "";
+  assert.ok(titleLine.includes("* user *") || titleLine.includes("[accent]"));
+  // Border should be border-colored
+  const topBorder = rendered.find((l) => l.includes("╭")) ?? "";
+  assert.ok(topBorder.includes("[border]"));
+});
+
+test("nativeRender builds correct box structure with all required line types", () => {
+  const prototype: PatchableUserMessagePrototype = {
+    render: () => ["line one", "line two"],
+  };
+  patchNativeUserMessagePrototype(prototype, () => undefined, () => true);
+
+  const rendered = prototype.render(30);
+  // Structure: [spacer, top-border, padding, content-line, padding, content-line, padding, bottom-border]
+  // With vertical padding of 1, each content line gets padding on both sides:
+  // But actually, addUserMessageVerticalPadding adds 1 padding before and after ALL content:
+  // So: spacer(blank), top-border, blank, content1, content2, blank, bottom-border
+  // = 7 lines total
+  assert.ok(rendered.length >= 5);
+  assert.equal(rendered.filter((l) => l.includes("│")).length, 4); // 2 content + 2 padding
+  assert.equal(rendered.filter((l) => l.includes("╭") || l.includes("╰")).length, 2);
+});