@opengsd/gsd-pi 1.0.1 → 1.0.2

package/packages/native/dist/text/index.js

@@ -16,6 +16,87 @@ exports.visibleWidth = visibleWidth;
 const native_js_1 = require("../native.js");
 var types_js_1 = require("./types.js");
 Object.defineProperty(exports, "EllipsisKind", { enumerable: true, get: function () { return types_js_1.EllipsisKind; } });
+const ansiPattern = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function tabWidthOrDefault(tabWidth) {
+    return Math.min(16, Math.max(1, Math.floor(tabWidth ?? 3)));
+}
+function stripAnsi(text) {
+    return text.replace(ansiPattern, "");
+}
+function graphemeWidth(grapheme, tabWidth) {
+    if (grapheme === "\t")
+        return tabWidthOrDefault(tabWidth);
+    if (grapheme === "\n" || grapheme === "\r")
+        return 0;
+    const codePoint = grapheme.codePointAt(0) ?? 0;
+    if (codePoint === 0)
+        return 0;
+    if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0))
+        return 0;
+    if ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        (codePoint >= 0x2329 && codePoint <= 0x232a) ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff)) {
+        return 2;
+    }
+    return 1;
+}
+function fallbackVisibleWidth(text, tabWidth) {
+    let width = 0;
+    for (const { segment } of segmenter.segment(stripAnsi(text))) {
+        width += graphemeWidth(segment, tabWidth);
+    }
+    return width;
+}
+function fallbackSliceWithWidth(line, startCol, length, strict, tabWidth) {
+    const start = Math.max(0, Math.floor(startCol));
+    const end = start + Math.max(0, Math.floor(length));
+    let col = 0;
+    let text = "";
+    let width = 0;
+    for (const { segment } of segmenter.segment(stripAnsi(line))) {
+        const segmentWidth = graphemeWidth(segment, tabWidth);
+        const segmentStart = col;
+        const segmentEnd = col + segmentWidth;
+        col = segmentEnd;
+        if (segmentEnd <= start)
+            continue;
+        if (segmentStart >= end)
+            break;
+        if (strict && (segmentStart < start || segmentEnd > end))
+            continue;
+        text += segment;
+        width += segmentWidth;
+    }
+    return { text, width };
+}
+function fallbackTruncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth) {
+    const width = Math.max(0, Math.floor(maxWidth));
+    const plain = stripAnsi(text);
+    if (fallbackVisibleWidth(plain, tabWidth) <= width) {
+        return pad ? text + " ".repeat(Math.max(0, width - fallbackVisibleWidth(plain, tabWidth))) : text;
+    }
+    const ellipsis = ellipsisKind === 0 ? "\u2026" : ellipsisKind === 1 ? "..." : "";
+    const ellipsisWidth = fallbackVisibleWidth(ellipsis, tabWidth);
+    const budget = Math.max(0, width - ellipsisWidth);
+    const sliced = fallbackSliceWithWidth(plain, 0, budget, true, tabWidth).text + ellipsis;
+    return pad ? sliced + " ".repeat(Math.max(0, width - fallbackVisibleWidth(sliced, tabWidth))) : sliced;
+}
+function callNative(name, args, fallback) {
+    try {
+        return native_js_1.native[name](...args);
+    }
+    catch {
+        return fallback();
+    }
+}
 /**
  * Word-wrap text to a visible width, preserving ANSI escape codes across
  * line breaks.
@@ -25,7 +106,26 @@ Object.defineProperty(exports, "EllipsisKind", { enumerable: true, get: function
  * next line.
  */
 function wrapTextWithAnsi(text, width, tabWidth) {
-    return native_js_1.native.wrapTextWithAnsi(text, width, tabWidth);
+    return callNative("wrapTextWithAnsi", [text, width, tabWidth], () => {
+        const targetWidth = Math.max(1, Math.floor(width));
+        const lines = [];
+        for (const inputLine of stripAnsi(text).split("\n")) {
+            let remaining = inputLine;
+            if (remaining.length === 0) {
+                lines.push("");
+                continue;
+            }
+            while (fallbackVisibleWidth(remaining, tabWidth) > targetWidth) {
+                const slice = fallbackSliceWithWidth(remaining, 0, targetWidth, true, tabWidth).text;
+                const breakAt = Math.max(slice.lastIndexOf(" "), 0);
+                const line = breakAt > 0 ? slice.slice(0, breakAt) : slice;
+                lines.push(line);
+                remaining = remaining.slice(line.length).trimStart();
+            }
+            lines.push(remaining);
+        }
+        return lines;
+    });
 }
 /**
  * Truncate text to a visible width with an optional ellipsis.
@@ -37,7 +137,7 @@ function wrapTextWithAnsi(text, width, tabWidth) {
  * @param tabWidth   Tab stop width (default 3, range 1-16).
  */
 function truncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth) {
-    return native_js_1.native.truncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth);
+    return callNative("truncateToWidth", [text, maxWidth, ellipsisKind, pad, tabWidth], () => fallbackTruncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth));
 }
 /**
  * Slice a range of visible columns from a line.
@@ -46,7 +146,7 @@ function truncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth) {
  * wide characters that would exceed the range are excluded.
  */
 function sliceWithWidth(line, startCol, length, strict, tabWidth) {
-    return native_js_1.native.sliceWithWidth(line, startCol, length, strict, tabWidth);
+    return callNative("sliceWithWidth", [line, startCol, length, strict, tabWidth], () => fallbackSliceWithWidth(line, startCol, length, strict, tabWidth));
 }
 /**
  * Extract the before/after segments around an overlay region.
@@ -55,7 +155,16 @@ function sliceWithWidth(line, startCol, length, strict, tabWidth) {
  * the overlay truncates styled text.
  */
 function extractSegments(line, beforeEnd, afterStart, afterLen, strictAfter, tabWidth) {
-    return native_js_1.native.extractSegments(line, beforeEnd, afterStart, afterLen, strictAfter, tabWidth);
+    return callNative("extractSegments", [line, beforeEnd, afterStart, afterLen, strictAfter, tabWidth], () => {
+        const before = fallbackSliceWithWidth(line, 0, beforeEnd, true, tabWidth);
+        const after = fallbackSliceWithWidth(line, afterStart, afterLen, strictAfter, tabWidth);
+        return {
+            before: before.text,
+            beforeWidth: before.width,
+            after: after.text,
+            afterWidth: after.width,
+        };
+    });
 }
 /**
  * Strip ANSI escape sequences, remove control characters and lone
@@ -64,7 +173,10 @@ function extractSegments(line, beforeEnd, afterStart, afterLen, strictAfter, tab
  * Returns the original string when no changes are needed (zero-copy).
  */
 function sanitizeText(text) {
-    return native_js_1.native.sanitizeText(text);
+    return callNative("sanitizeText", [text], () => stripAnsi(text)
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "")
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, ""));
 }
 /**
  * Calculate visible width of text excluding ANSI escape sequences.
@@ -72,5 +184,5 @@ function sanitizeText(text) {
  * Tabs count as `tabWidth` cells (default 3).
  */
 function visibleWidth(text, tabWidth) {
-    return native_js_1.native.visibleWidth(text, tabWidth);
+    return callNative("visibleWidth", [text, tabWidth], () => fallbackVisibleWidth(text, tabWidth));
 }

package/packages/native/dist/xxhash/index.d.ts

@@ -12,8 +12,7 @@ export declare function xxHash32Fallback(input: string, seed: number): number;
  * Compute xxHash32 of a UTF-8 string.
  *
  * Uses the native Rust implementation when available; falls back to a
- * pure-JS implementation if the loaded native addon does not export
- * `xxHash32` (e.g. an older build).
+ * pure-JS implementation if the addon is missing or throws on call.
  *
  * @param input  The string to hash (encoded as UTF-8 internally).
  * @param seed   32-bit seed value.

package/packages/native/dist/xxhash/index.js

@@ -69,21 +69,21 @@ function xxHash32JS(input, seed) {
 function xxHash32Fallback(input, seed) {
     return xxHash32JS(input, seed);
 }
-// Resolve once at module load: prefer native, fall back to JS.
-const _xxHash32Impl = typeof native_js_1.native.xxHash32 === "function"
-    ? (input, seed) => native_js_1.native.xxHash32(input, seed)
-    : xxHash32JS;
 /**
  * Compute xxHash32 of a UTF-8 string.
  *
  * Uses the native Rust implementation when available; falls back to a
- * pure-JS implementation if the loaded native addon does not export
- * `xxHash32` (e.g. an older build).
+ * pure-JS implementation if the addon is missing or throws on call.
  *
  * @param input  The string to hash (encoded as UTF-8 internally).
  * @param seed   32-bit seed value.
  * @returns      32-bit unsigned hash.
  */
 function xxHash32(input, seed) {
-    return _xxHash32Impl(input, seed);
+    try {
+        return native_js_1.native.xxHash32(input, seed);
+    }
+    catch {
+        return xxHash32JS(input, seed);
+    }
 }

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/native",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Native Rust bindings for GSD — high-performance native modules via N-API",
   "type": "commonjs",
   "gsd": {

package/packages/native/src/__tests__/function-fallback.test.mjs

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("xxhash and grep helpers fall back to JS when native addon is unavailable", () => {
+  const script = `
+    const { xxHash32, xxHash32Fallback } = require("./dist/xxhash");
+    const { searchContent } = require("./dist/grep");
+    const input = "the quick brown fox jumps over the lazy dog";
+    const search = searchContent(Buffer.from("alpha\\nneedle-found-here\\ndelta"), {
+      pattern: "needle-found-here",
+    });
+    process.stdout.write(JSON.stringify({
+      hash: xxHash32(input, 0),
+      fallback: xxHash32Fallback(input, 0),
+      search,
+    }));
+  `;
+
+  const result = spawnSync(process.execPath, ["-e", script], {
+    cwd: packageRoot,
+    env: { ...process.env, GSD_NATIVE_DISABLE: "1" },
+    encoding: "utf8",
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  const output = JSON.parse(result.stdout);
+  assert.equal(output.hash, output.fallback);
+  assert.equal(output.search.matchCount, 1);
+  assert.equal(output.search.limitReached, false);
+  assert.equal(output.search.matches[0].lineNumber, 2);
+  assert.equal(output.search.matches[0].line, "needle-found-here");
+});

package/packages/native/src/__tests__/text-fallback.test.mjs

@@ -0,0 +1,44 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+test("text helpers fall back to JS when native addon is unavailable", () => {
+  const script = `
+    const text = require("./dist/text");
+    const result = {
+      visible: text.visibleWidth("\\x1b[31mhello\\x1b[0m"),
+      wide: text.visibleWidth("a世界"),
+      sanitized: text.sanitizeText("he\\x01llo\\r\\n"),
+      truncated: text.truncateToWidth("hello world", 6, text.EllipsisKind.Unicode, false),
+      slice: text.sliceWithWidth("hello world", 6, 5, false),
+      segments: text.extractSegments("hello world", 5, 6, 5, false),
+      wrapped: text.wrapTextWithAnsi("hello world", 5),
+    };
+    process.stdout.write(JSON.stringify(result));
+  `;
+
+  const result = spawnSync(process.execPath, ["-e", script], {
+    cwd: packageRoot,
+    env: { ...process.env, GSD_NATIVE_DISABLE: "1" },
+    encoding: "utf8",
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  const output = JSON.parse(result.stdout);
+  assert.equal(output.visible, 5);
+  assert.equal(output.wide, 5);
+  assert.equal(output.sanitized, "hello\n");
+  assert.equal(output.truncated, "hello…");
+  assert.deepEqual(output.slice, { text: "world", width: 5 });
+  assert.deepEqual(output.segments, {
+    before: "hello",
+    beforeWidth: 5,
+    after: "world",
+    afterWidth: 5,
+  });
+  assert.deepEqual(output.wrapped, ["hello", "world"]);
+});

package/packages/native/src/grep/index.ts

@@ -26,6 +26,39 @@ export type {
   SearchResult,
 };
 
+function searchContentFallback(
+  content: Buffer | Uint8Array,
+  options: SearchOptions,
+): SearchResult {
+  const text = Buffer.from(content).toString("utf8");
+  const lines = text.split("\n");
+  const flags = `${options.ignoreCase ? "i" : ""}${options.multiline ? "m" : ""}`;
+  const re = new RegExp(options.pattern, flags);
+  const maxCount = options.maxCount ?? Number.POSITIVE_INFINITY;
+  const matches: SearchMatch[] = [];
+  let matchCount = 0;
+  let limitReached = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (!re.test(line)) continue;
+    matchCount++;
+    if (matches.length < maxCount) {
+      matches.push({
+        lineNumber: i + 1,
+        line,
+        contextBefore: [],
+        contextAfter: [],
+        truncated: false,
+      });
+    } else {
+      limitReached = true;
+    }
+  }
+
+  return { matches, matchCount, limitReached };
+}
+
 /**
  * Search in-memory content for a regex pattern.
  *
@@ -35,7 +68,11 @@ export function searchContent(
   content: Buffer | Uint8Array,
   options: SearchOptions,
 ): SearchResult {
-  return native.search(content, options) as SearchResult;
+  try {
+    return native.search(content, options) as SearchResult;
+  } catch {
+    return searchContentFallback(content, options);
+  }
 }
 
 /**

package/packages/native/src/index.ts

@@ -93,6 +93,8 @@ export type { NativeImageHandle } from "./image/index.js";
 
 export { xxHash32, xxHash32Fallback } from "./xxhash/index.js";
 
+export { isNativeAddonLoaded } from "./native.js";
+
 export { ttsrCompileRules, ttsrCheckBuffer, ttsrFreeRules } from "./ttsr/index.js";
 export type { TtsrHandle, TtsrRuleInput } from "./ttsr/index.js";
 export {

package/packages/native/src/native.ts

@@ -33,33 +33,43 @@ let _loadedSuccessfully = false;
 function loadNative(): Record<string, unknown> {
   const errors: string[] = [];
 
-  // 1. Try the platform-specific npm optional dependency
-  const packageSuffix = platformPackageMap[platformTag];
-  if (packageSuffix) {
+  if (process.env.GSD_NATIVE_DISABLE === "1") {
+    errors.push("disabled by GSD_NATIVE_DISABLE=1");
+  } else {
+    // 1. Try the platform-specific npm optional dependency
+    const packageSuffix = platformPackageMap[platformTag];
+    if (packageSuffix) {
+      try {
+        const loaded = _require(`@opengsd/engine-${packageSuffix}`) as Record<string, unknown>;
+        _loadedSuccessfully = true;
+        return loaded;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(`@opengsd/engine-${packageSuffix}: ${message}`);
+      }
+    }
+
+    // 2. Try local release build (native/addon/gsd_engine.{platform}.node)
+    const releasePath = path.join(addonDir, `gsd_engine.${platformTag}.node`);
     try {
-      _loadedSuccessfully = true; return _require(`@opengsd/engine-${packageSuffix}`) as Record<string, unknown>;
+      const loaded = _require(releasePath) as Record<string, unknown>;
+      _loadedSuccessfully = true;
+      return loaded;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      errors.push(`@opengsd/engine-${packageSuffix}: ${message}`);
+      errors.push(`${releasePath}: ${message}`);
     }
-  }
 
-  // 2. Try local release build (native/addon/gsd_engine.{platform}.node)
-  const releasePath = path.join(addonDir, `gsd_engine.${platformTag}.node`);
-  try {
-    _loadedSuccessfully = true; return _require(releasePath) as Record<string, unknown>;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    errors.push(`${releasePath}: ${message}`);
-  }
-
-  // 3. Try local dev build (native/addon/gsd_engine.dev.node)
-  const devPath = path.join(addonDir, "gsd_engine.dev.node");
-  try {
-    _loadedSuccessfully = true; return _require(devPath) as Record<string, unknown>;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    errors.push(`${devPath}: ${message}`);
+    // 3. Try local dev build (native/addon/gsd_engine.dev.node)
+    const devPath = path.join(addonDir, "gsd_engine.dev.node");
+    try {
+      const loaded = _require(devPath) as Record<string, unknown>;
+      _loadedSuccessfully = true;
+      return loaded;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push(`${devPath}: ${message}`);
+    }
   }
 
   const details = errors.map((e) => `  - ${e}`).join("\n");
@@ -82,6 +92,11 @@ function loadNative(): Record<string, unknown> {
   });
 }
 
+/** True when a real `.node` addon was loaded (not the throw-on-call proxy). */
+export function isNativeAddonLoaded(): boolean {
+  return _loadedSuccessfully;
+}
+
 export const native = loadNative() as {
   search: (content: Buffer | Uint8Array, options: unknown) => unknown;
   grep: (options: unknown) => unknown;

package/packages/native/src/text/index.ts

@@ -11,6 +11,106 @@ import type { ExtractSegmentsResult, SliceResult } from "./types.js";
 export type { ExtractSegmentsResult, SliceResult };
 export { EllipsisKind } from "./types.js";
 
+const ansiPattern = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+function tabWidthOrDefault(tabWidth?: number): number {
+  return Math.min(16, Math.max(1, Math.floor(tabWidth ?? 3)));
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(ansiPattern, "");
+}
+
+function graphemeWidth(grapheme: string, tabWidth?: number): number {
+  if (grapheme === "\t") return tabWidthOrDefault(tabWidth);
+  if (grapheme === "\n" || grapheme === "\r") return 0;
+  const codePoint = grapheme.codePointAt(0) ?? 0;
+  if (codePoint === 0) return 0;
+  if (codePoint < 32 || (codePoint >= 0x7f && codePoint < 0xa0)) return 0;
+  if (
+    (codePoint >= 0x1100 && codePoint <= 0x115f) ||
+    (codePoint >= 0x2329 && codePoint <= 0x232a) ||
+    (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+    (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+    (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+    (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+    (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+    (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+    (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+    (codePoint >= 0x1f300 && codePoint <= 0x1faff)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+function fallbackVisibleWidth(text: string, tabWidth?: number): number {
+  let width = 0;
+  for (const { segment } of segmenter.segment(stripAnsi(text))) {
+    width += graphemeWidth(segment, tabWidth);
+  }
+  return width;
+}
+
+function fallbackSliceWithWidth(
+  line: string,
+  startCol: number,
+  length: number,
+  strict: boolean,
+  tabWidth?: number,
+): SliceResult {
+  const start = Math.max(0, Math.floor(startCol));
+  const end = start + Math.max(0, Math.floor(length));
+  let col = 0;
+  let text = "";
+  let width = 0;
+
+  for (const { segment } of segmenter.segment(stripAnsi(line))) {
+    const segmentWidth = graphemeWidth(segment, tabWidth);
+    const segmentStart = col;
+    const segmentEnd = col + segmentWidth;
+    col = segmentEnd;
+
+    if (segmentEnd <= start) continue;
+    if (segmentStart >= end) break;
+    if (strict && (segmentStart < start || segmentEnd > end)) continue;
+
+    text += segment;
+    width += segmentWidth;
+  }
+
+  return { text, width };
+}
+
+function fallbackTruncateToWidth(
+  text: string,
+  maxWidth: number,
+  ellipsisKind: number,
+  pad: boolean,
+  tabWidth?: number,
+): string {
+  const width = Math.max(0, Math.floor(maxWidth));
+  const plain = stripAnsi(text);
+  if (fallbackVisibleWidth(plain, tabWidth) <= width) {
+    return pad ? text + " ".repeat(Math.max(0, width - fallbackVisibleWidth(plain, tabWidth))) : text;
+  }
+
+  const ellipsis = ellipsisKind === 0 ? "\u2026" : ellipsisKind === 1 ? "..." : "";
+  const ellipsisWidth = fallbackVisibleWidth(ellipsis, tabWidth);
+  const budget = Math.max(0, width - ellipsisWidth);
+  const sliced = fallbackSliceWithWidth(plain, 0, budget, true, tabWidth).text + ellipsis;
+  return pad ? sliced + " ".repeat(Math.max(0, width - fallbackVisibleWidth(sliced, tabWidth))) : sliced;
+}
+
+function callNative<T>(name: string, args: unknown[], fallback: () => T): T {
+  try {
+    return (native as Record<string, Function>)[name](...args) as T;
+  } catch {
+    return fallback();
+  }
+}
+
 /**
  * Word-wrap text to a visible width, preserving ANSI escape codes across
  * line breaks.
@@ -24,11 +124,26 @@ export function wrapTextWithAnsi(
   width: number,
   tabWidth?: number,
 ): string[] {
-  return (native as Record<string, Function>).wrapTextWithAnsi(
-    text,
-    width,
-    tabWidth,
-  ) as string[];
+  return callNative("wrapTextWithAnsi", [text, width, tabWidth], () => {
+    const targetWidth = Math.max(1, Math.floor(width));
+    const lines: string[] = [];
+    for (const inputLine of stripAnsi(text).split("\n")) {
+      let remaining = inputLine;
+      if (remaining.length === 0) {
+        lines.push("");
+        continue;
+      }
+      while (fallbackVisibleWidth(remaining, tabWidth) > targetWidth) {
+        const slice = fallbackSliceWithWidth(remaining, 0, targetWidth, true, tabWidth).text;
+        const breakAt = Math.max(slice.lastIndexOf(" "), 0);
+        const line = breakAt > 0 ? slice.slice(0, breakAt) : slice;
+        lines.push(line);
+        remaining = remaining.slice(line.length).trimStart();
+      }
+      lines.push(remaining);
+    }
+    return lines;
+  });
 }
 
 /**
@@ -47,13 +162,9 @@ export function truncateToWidth(
   pad: boolean,
   tabWidth?: number,
 ): string {
-  return (native as Record<string, Function>).truncateToWidth(
-    text,
-    maxWidth,
-    ellipsisKind,
-    pad,
-    tabWidth,
-  ) as string;
+  return callNative("truncateToWidth", [text, maxWidth, ellipsisKind, pad, tabWidth], () =>
+    fallbackTruncateToWidth(text, maxWidth, ellipsisKind, pad, tabWidth),
+  );
 }
 
 /**
@@ -69,13 +180,9 @@ export function sliceWithWidth(
   strict: boolean,
   tabWidth?: number,
 ): SliceResult {
-  return (native as Record<string, Function>).sliceWithWidth(
-    line,
-    startCol,
-    length,
-    strict,
-    tabWidth,
-  ) as SliceResult;
+  return callNative("sliceWithWidth", [line, startCol, length, strict, tabWidth], () =>
+    fallbackSliceWithWidth(line, startCol, length, strict, tabWidth),
+  );
 }
 
 /**
@@ -92,14 +199,16 @@ export function extractSegments(
   strictAfter: boolean,
   tabWidth?: number,
 ): ExtractSegmentsResult {
-  return (native as Record<string, Function>).extractSegments(
-    line,
-    beforeEnd,
-    afterStart,
-    afterLen,
-    strictAfter,
-    tabWidth,
-  ) as ExtractSegmentsResult;
+  return callNative("extractSegments", [line, beforeEnd, afterStart, afterLen, strictAfter, tabWidth], () => {
+    const before = fallbackSliceWithWidth(line, 0, beforeEnd, true, tabWidth);
+    const after = fallbackSliceWithWidth(line, afterStart, afterLen, strictAfter, tabWidth);
+    return {
+      before: before.text,
+      beforeWidth: before.width,
+      after: after.text,
+      afterWidth: after.width,
+    };
+  });
 }
 
 /**
@@ -109,7 +218,12 @@ export function extractSegments(
  * Returns the original string when no changes are needed (zero-copy).
  */
 export function sanitizeText(text: string): string {
-  return (native as Record<string, Function>).sanitizeText(text) as string;
+  return callNative("sanitizeText", [text], () =>
+    stripAnsi(text)
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "")
+      .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, ""),
+  );
 }
 
 /**
@@ -118,8 +232,7 @@ export function sanitizeText(text: string): string {
  * Tabs count as `tabWidth` cells (default 3).
  */
 export function visibleWidth(text: string, tabWidth?: number): number {
-  return (native as Record<string, Function>).visibleWidth(
-    text,
-    tabWidth,
-  ) as number;
+  return callNative("visibleWidth", [text, tabWidth], () =>
+    fallbackVisibleWidth(text, tabWidth),
+  );
 }