@simonklee/opentui-tex 0.2.0

package/dist/math-layout.d.ts

@@ -0,0 +1,3 @@
+import type { MathBox, MathNode } from "./math-types.js";
+export declare function layoutMath(node: MathNode, displayMode: boolean): MathBox;
+export declare function boxToString(box: MathBox, widthMax: number, heightMax: number): string;

package/dist/math-parser.d.ts

@@ -0,0 +1,4 @@
+import type { MathNode } from "./math-types.js";
+export declare const MAX_NESTING_DEPTH = 256;
+export declare function parseMath(source: string): MathNode;
+export declare function parseMathIncomplete(source: string): MathNode;

package/dist/math-symbols.d.ts

@@ -0,0 +1,11 @@
+import type { AccentKind, SymbolRole } from "./math-types.js";
+export interface SymbolDefinition {
+    value: string;
+    role?: SymbolRole;
+}
+export declare const symbols: Readonly<Record<string, SymbolDefinition>>;
+export declare const operators: Readonly<Record<string, string>>;
+export declare const namedOperators: Set<string>;
+export declare const delimiters: Readonly<Record<string, string>>;
+export declare const accents: Readonly<Record<string, AccentKind>>;
+export declare const spacing: Readonly<Record<string, number>>;

package/dist/math-types.d.ts

@@ -0,0 +1,59 @@
+export type SymbolRole = "ordinary" | "binary" | "relation" | "operator" | "punctuation" | "opening" | "closing";
+export type MathEnvironment = "matrix" | "pmatrix" | "bmatrix" | "Bmatrix" | "vmatrix" | "Vmatrix" | "cases" | "aligned" | "align" | "gathered" | "gather" | "smallmatrix" | "array";
+export type AccentKind = "hat" | "widehat" | "bar" | "overline" | "underline" | "vec" | "tilde" | "dot" | "ddot";
+export type MathNode = {
+    type: "row";
+    body: MathNode[];
+} | {
+    type: "symbol";
+    value: string;
+    role?: SymbolRole;
+} | {
+    type: "text";
+    value: string;
+} | {
+    type: "space";
+    width: number;
+} | {
+    type: "fraction";
+    numerator: MathNode;
+    denominator: MathNode;
+    bar: boolean;
+} | {
+    type: "root";
+    body: MathNode;
+    index?: MathNode;
+} | {
+    type: "scripts";
+    base: MathNode;
+    superscript?: MathNode;
+    subscript?: MathNode;
+} | {
+    type: "delimited";
+    left: string;
+    body: MathNode;
+    right: string;
+} | {
+    type: "matrix";
+    rows: MathNode[][];
+    environment: MathEnvironment;
+} | {
+    type: "accent";
+    accent: AccentKind;
+    body: MathNode;
+} | {
+    type: "operator";
+    value: string;
+    limits: boolean;
+} | {
+    type: "overunder";
+    base: MathNode;
+    over?: MathNode;
+    under?: MathNode;
+};
+export interface MathBox {
+    width: number;
+    height: number;
+    baseline: number;
+    cells: Array<Array<string | undefined>>;
+}

package/dist/native/ffi.d.ts

@@ -0,0 +1,18 @@
+export type Pointer = number | bigint;
+type PointerArgument = Pointer | Uint8Array;
+export interface NativeSymbols {
+    texInit(): number;
+    texRender(source: PointerArgument, sourceLength: number, display: number, foreground: PointerArgument, background: PointerArgument): Pointer | null;
+    texResultStatus(handle: Pointer): number;
+    texResultPixels(handle: Pointer): Pointer | null;
+    texResultPixelsLength(handle: Pointer): number;
+    texResultWidth(handle: Pointer): number;
+    texResultHeight(handle: Pointer): number;
+    texResultDestroy(handle: Pointer): void;
+}
+interface NativeLibrary {
+    symbols: NativeSymbols;
+    toArrayBuffer(pointer: Pointer, length: number): ArrayBuffer;
+}
+export declare function openNativeLibrary(path: string): NativeLibrary;
+export {};

package/dist/native/native-renderer.d.ts

@@ -0,0 +1,15 @@
+import { NativeImage } from "@opentui/core";
+export declare class NativeTexRenderer {
+    private readonly cache;
+    private readonly queue;
+    private queueTimer;
+    private rendering;
+    private destroyed;
+    constructor();
+    renderAsync(formula: string, display: boolean, foreground: string, background: string, signal?: AbortSignal): Promise<NativeImage>;
+    destroy(): void;
+    private renderSync;
+    private getCached;
+    private scheduleQueue;
+    private discardAbortedJobs;
+}

package/dist/native/native-tex-backend.d.ts

@@ -0,0 +1,8 @@
+import type { TexBackend, TexRenderOutput, TexRenderRequest } from "../backend.js";
+import { NativeTexRenderer } from "./native-renderer.js";
+export declare class NativeTexBackend implements TexBackend {
+    private readonly renderer;
+    constructor(renderer?: NativeTexRenderer);
+    render(request: TexRenderRequest): Promise<TexRenderOutput>;
+    destroy(): void;
+}

package/dist/native/platform.d.ts

@@ -0,0 +1 @@
+export declare function resolveNativeLibrary(): Promise<string>;

package/dist/native.bun.js

@@ -0,0 +1,273 @@
+// @bun
+var __require = import.meta.require;
+
+// src/native/native-renderer.ts
+import { isMainThread } from "worker_threads";
+import { NativeImage } from "@opentui/core";
+
+// src/native/ffi.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function openNativeLibrary(path) {
+  if (globalThis.Bun) {
+    const ffi2 = require2("bun:ffi");
+    const { u8, u32, ptr, void: voidType } = ffi2.FFIType;
+    const library2 = ffi2.dlopen(path, {
+      texInit: { args: [], returns: u32 },
+      texRender: { args: [ptr, u32, u8, ptr, ptr], returns: ptr },
+      texResultStatus: { args: [ptr], returns: u32 },
+      texResultPixels: { args: [ptr], returns: ptr },
+      texResultPixelsLength: { args: [ptr], returns: u32 },
+      texResultWidth: { args: [ptr], returns: u32 },
+      texResultHeight: { args: [ptr], returns: u32 },
+      texResultDestroy: { args: [ptr], returns: voidType }
+    });
+    return {
+      symbols: library2.symbols,
+      toArrayBuffer: (pointer, length) => ffi2.toArrayBuffer(pointer, 0, length)
+    };
+  }
+  const ffi = require2("node:ffi");
+  const library = ffi.dlopen(path, {
+    texInit: { arguments: [], return: "u32" },
+    texRender: { arguments: ["pointer", "u32", "u8", "pointer", "pointer"], return: "pointer" },
+    texResultStatus: { arguments: ["pointer"], return: "u32" },
+    texResultPixels: { arguments: ["pointer"], return: "pointer" },
+    texResultPixelsLength: { arguments: ["pointer"], return: "u32" },
+    texResultWidth: { arguments: ["pointer"], return: "u32" },
+    texResultHeight: { arguments: ["pointer"], return: "u32" },
+    texResultDestroy: { arguments: ["pointer"], return: "void" }
+  });
+  return {
+    symbols: library.functions,
+    toArrayBuffer: (pointer, length) => ffi.toArrayBuffer(pointer, length, true)
+  };
+}
+
+// src/native/platform.ts
+function packagePath(loaded) {
+  return typeof loaded === "string" ? loaded : loaded.default;
+}
+function linuxLibc() {
+  const configured = process.env.OPENTUI_LIBC;
+  if (configured === "gnu" || configured === "glibc")
+    return "gnu";
+  if (configured === "musl")
+    return "musl";
+  if (configured)
+    throw new Error(`Unsupported OPENTUI_LIBC value: ${configured}`);
+  const report = process.report?.getReport();
+  return report?.header?.glibcVersionRuntime ? "gnu" : "musl";
+}
+async function resolveNativeLibrary() {
+  if (process.env.OPENTUI_LATEX_NATIVE_PATH)
+    return process.env.OPENTUI_LATEX_NATIVE_PATH;
+  const abi = process.platform === "linux" ? linuxLibc() : undefined;
+  const suffix = `${process.platform}-${process.arch}${abi === "musl" ? "-musl" : ""}`;
+  if (suffix === "darwin-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-darwin-x64"));
+  if (suffix === "darwin-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-darwin-arm64"));
+  if (suffix === "win32-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-win32-x64"));
+  if (suffix === "win32-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-win32-arm64"));
+  if (suffix === "linux-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-x64"));
+  if (suffix === "linux-x64-musl")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-x64-musl"));
+  if (suffix === "linux-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-arm64"));
+  if (suffix === "linux-arm64-musl")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-arm64-musl"));
+  throw new Error(`Unsupported native renderer platform: ${process.platform}-${process.arch}`);
+}
+
+// src/native/native-renderer.ts
+var CACHE_ENTRIES_MAX = 64;
+var QUEUE_ENTRIES_MAX = 128;
+var SOURCE_SIZE_MAX = 4096;
+var STATUS_MESSAGES = [
+  "ok",
+  "invalid native renderer argument",
+  "invalid TeX formula",
+  "invalid SVG output",
+  "rendered dimensions exceed limits",
+  "native renderer ran out of memory",
+  "internal native renderer error"
+];
+var nativePromise;
+async function getNative() {
+  nativePromise ??= resolveNativeLibrary().then((path) => {
+    const loaded = openNativeLibrary(path);
+    const status = loaded.symbols.texInit();
+    if (status !== 0)
+      throw new Error(STATUS_MESSAGES[status] ?? `Native renderer initialization failed with status ${status}`);
+    return loaded;
+  }).catch((error) => {
+    nativePromise = undefined;
+    throw error;
+  });
+  return nativePromise;
+}
+function rgb(hex) {
+  if (!/^#[0-9a-f]{6}$/i.test(hex))
+    throw new Error(`Invalid RGB color: ${hex}`);
+  return Uint8Array.of(Number.parseInt(hex.slice(1, 3), 16), Number.parseInt(hex.slice(3, 5), 16), Number.parseInt(hex.slice(5, 7), 16));
+}
+function copyResult(symbols, toArrayBuffer, handle) {
+  const status = symbols.texResultStatus(handle);
+  if (status !== 0)
+    throw new Error(STATUS_MESSAGES[status] ?? `Native renderer failed with status ${status}`);
+  const pixelsPointer = symbols.texResultPixels(handle);
+  const pixelsLength = symbols.texResultPixelsLength(handle);
+  const width = symbols.texResultWidth(handle);
+  const height = symbols.texResultHeight(handle);
+  if (!pixelsPointer || width === 0 || height === 0)
+    throw new Error("Native renderer returned an empty image");
+  const expectedLength = width * height * 4;
+  if (pixelsLength !== expectedLength)
+    throw new Error("Native renderer returned an invalid pixel length");
+  const pixels = new Uint8Array(toArrayBuffer(pixelsPointer, pixelsLength));
+  return NativeImage.fromRgba(pixels, width, height, width * 4);
+}
+
+class NativeTexRenderer {
+  cache = new Map;
+  queue = [];
+  queueTimer = null;
+  rendering = false;
+  destroyed = false;
+  constructor() {
+    if (!isMainThread)
+      throw new Error("NativeTexRenderer is single-threaded and must be loaded on the main thread");
+  }
+  async renderAsync(formula, display, foreground, background, signal) {
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    if (signal?.aborted)
+      throw signal.reason ?? new Error("Native render cancelled");
+    const key = `${display ? "D" : "I"}\x00${foreground}\x00${background}\x00${formula}`;
+    const cached = this.getCached(key);
+    if (cached)
+      return cached;
+    this.discardAbortedJobs();
+    if (this.queue.length >= QUEUE_ENTRIES_MAX)
+      throw new Error(`Native render queue exceeds ${QUEUE_ENTRIES_MAX} formulas`);
+    const promise = new Promise((resolve, reject) => {
+      this.queue.push({ formula, display, foreground, background, signal, resolve, reject });
+    });
+    this.scheduleQueue();
+    return promise;
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    if (this.queueTimer)
+      clearTimeout(this.queueTimer);
+    this.queueTimer = null;
+    for (const job of this.queue.splice(0))
+      job.reject(new Error("Native renderer is destroyed"));
+    for (const image of this.cache.values())
+      image.dispose();
+    this.cache.clear();
+  }
+  async renderSync(formula, display, foreground, background, signal) {
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    const key = `${display ? "D" : "I"}\x00${foreground}\x00${background}\x00${formula}`;
+    const cached = this.getCached(key);
+    if (cached)
+      return cached;
+    const source = new TextEncoder().encode(formula);
+    if (source.byteLength === 0 || source.byteLength > SOURCE_SIZE_MAX)
+      throw new Error(`Formula must contain between 1 and ${SOURCE_SIZE_MAX} UTF-8 bytes`);
+    const foregroundRgb = rgb(foreground);
+    const backgroundRgb = rgb(background);
+    const library = await getNative();
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    if (signal?.aborted)
+      throw signal.reason ?? new Error("Native render cancelled");
+    const handle = library.symbols.texRender(source, source.byteLength, display ? 1 : 0, foregroundRgb, backgroundRgb);
+    if (!handle)
+      throw new Error("Native renderer could not allocate a result");
+    let image;
+    try {
+      image = copyResult(library.symbols, library.toArrayBuffer, handle);
+    } finally {
+      library.symbols.texResultDestroy(handle);
+    }
+    if (this.destroyed || signal?.aborted) {
+      image.dispose();
+      if (this.destroyed)
+        throw new Error("Native renderer is destroyed");
+      throw signal?.reason ?? new Error("Native render cancelled");
+    }
+    this.cache.set(key, image);
+    if (this.cache.size > CACHE_ENTRIES_MAX) {
+      const [oldest, evicted] = this.cache.entries().next().value;
+      this.cache.delete(oldest);
+      evicted.dispose();
+    }
+    return image.retain();
+  }
+  getCached(key) {
+    const image = this.cache.get(key);
+    if (!image)
+      return null;
+    this.cache.delete(key);
+    this.cache.set(key, image);
+    return image.retain();
+  }
+  scheduleQueue() {
+    if (this.queueTimer || this.rendering || this.queue.length === 0)
+      return;
+    this.queueTimer = setTimeout(() => {
+      this.queueTimer = null;
+      const job = this.queue.shift();
+      if (!job)
+        return;
+      if (job.signal?.aborted)
+        job.reject(job.signal.reason ?? new Error("Native render cancelled"));
+      else {
+        this.rendering = true;
+        this.renderSync(job.formula, job.display, job.foreground, job.background, job.signal).then(job.resolve, job.reject).finally(() => {
+          this.rendering = false;
+          this.scheduleQueue();
+        });
+        return;
+      }
+      this.scheduleQueue();
+    }, 0);
+  }
+  discardAbortedJobs() {
+    for (let index = this.queue.length - 1;index >= 0; index -= 1) {
+      const job = this.queue[index];
+      if (!job.signal?.aborted)
+        continue;
+      this.queue.splice(index, 1);
+      job.reject(job.signal.reason ?? new Error("Native render cancelled"));
+    }
+  }
+}
+
+// src/native/native-tex-backend.ts
+class NativeTexBackend {
+  renderer;
+  constructor(renderer = new NativeTexRenderer) {
+    this.renderer = renderer;
+  }
+  async render(request) {
+    const image = await this.renderer.renderAsync(request.formula, request.display, request.foreground, request.background, request.signal);
+    return { kind: "image", image };
+  }
+  destroy() {
+    this.renderer.destroy();
+  }
+}
+export {
+  NativeTexRenderer,
+  NativeTexBackend
+};

package/dist/native.d.ts

@@ -0,0 +1,2 @@
+export { NativeTexBackend } from "./native/native-tex-backend.js";
+export { NativeTexRenderer } from "./native/native-renderer.js";

package/dist/native.js

@@ -0,0 +1,273 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/native/native-renderer.ts
+import { isMainThread } from "node:worker_threads";
+import { NativeImage } from "@opentui/core";
+
+// src/native/ffi.ts
+import { createRequire as createRequire2 } from "node:module";
+var require2 = createRequire2(import.meta.url);
+function openNativeLibrary(path) {
+  if (globalThis.Bun) {
+    const ffi2 = require2("bun:ffi");
+    const { u8, u32, ptr, void: voidType } = ffi2.FFIType;
+    const library2 = ffi2.dlopen(path, {
+      texInit: { args: [], returns: u32 },
+      texRender: { args: [ptr, u32, u8, ptr, ptr], returns: ptr },
+      texResultStatus: { args: [ptr], returns: u32 },
+      texResultPixels: { args: [ptr], returns: ptr },
+      texResultPixelsLength: { args: [ptr], returns: u32 },
+      texResultWidth: { args: [ptr], returns: u32 },
+      texResultHeight: { args: [ptr], returns: u32 },
+      texResultDestroy: { args: [ptr], returns: voidType }
+    });
+    return {
+      symbols: library2.symbols,
+      toArrayBuffer: (pointer, length) => ffi2.toArrayBuffer(pointer, 0, length)
+    };
+  }
+  const ffi = require2("node:ffi");
+  const library = ffi.dlopen(path, {
+    texInit: { arguments: [], return: "u32" },
+    texRender: { arguments: ["pointer", "u32", "u8", "pointer", "pointer"], return: "pointer" },
+    texResultStatus: { arguments: ["pointer"], return: "u32" },
+    texResultPixels: { arguments: ["pointer"], return: "pointer" },
+    texResultPixelsLength: { arguments: ["pointer"], return: "u32" },
+    texResultWidth: { arguments: ["pointer"], return: "u32" },
+    texResultHeight: { arguments: ["pointer"], return: "u32" },
+    texResultDestroy: { arguments: ["pointer"], return: "void" }
+  });
+  return {
+    symbols: library.functions,
+    toArrayBuffer: (pointer, length) => ffi.toArrayBuffer(pointer, length, true)
+  };
+}
+
+// src/native/platform.ts
+function packagePath(loaded) {
+  return typeof loaded === "string" ? loaded : loaded.default;
+}
+function linuxLibc() {
+  const configured = process.env.OPENTUI_LIBC;
+  if (configured === "gnu" || configured === "glibc")
+    return "gnu";
+  if (configured === "musl")
+    return "musl";
+  if (configured)
+    throw new Error(`Unsupported OPENTUI_LIBC value: ${configured}`);
+  const report = process.report?.getReport();
+  return report?.header?.glibcVersionRuntime ? "gnu" : "musl";
+}
+async function resolveNativeLibrary() {
+  if (process.env.OPENTUI_LATEX_NATIVE_PATH)
+    return process.env.OPENTUI_LATEX_NATIVE_PATH;
+  const abi = process.platform === "linux" ? linuxLibc() : undefined;
+  const suffix = `${process.platform}-${process.arch}${abi === "musl" ? "-musl" : ""}`;
+  if (suffix === "darwin-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-darwin-x64"));
+  if (suffix === "darwin-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-darwin-arm64"));
+  if (suffix === "win32-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-win32-x64"));
+  if (suffix === "win32-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-win32-arm64"));
+  if (suffix === "linux-x64")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-x64"));
+  if (suffix === "linux-x64-musl")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-x64-musl"));
+  if (suffix === "linux-arm64")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-arm64"));
+  if (suffix === "linux-arm64-musl")
+    return packagePath(await import("@simonklee/opentui-tex-native-linux-arm64-musl"));
+  throw new Error(`Unsupported native renderer platform: ${process.platform}-${process.arch}`);
+}
+
+// src/native/native-renderer.ts
+var CACHE_ENTRIES_MAX = 64;
+var QUEUE_ENTRIES_MAX = 128;
+var SOURCE_SIZE_MAX = 4096;
+var STATUS_MESSAGES = [
+  "ok",
+  "invalid native renderer argument",
+  "invalid TeX formula",
+  "invalid SVG output",
+  "rendered dimensions exceed limits",
+  "native renderer ran out of memory",
+  "internal native renderer error"
+];
+var nativePromise;
+async function getNative() {
+  nativePromise ??= resolveNativeLibrary().then((path) => {
+    const loaded = openNativeLibrary(path);
+    const status = loaded.symbols.texInit();
+    if (status !== 0)
+      throw new Error(STATUS_MESSAGES[status] ?? `Native renderer initialization failed with status ${status}`);
+    return loaded;
+  }).catch((error) => {
+    nativePromise = undefined;
+    throw error;
+  });
+  return nativePromise;
+}
+function rgb(hex) {
+  if (!/^#[0-9a-f]{6}$/i.test(hex))
+    throw new Error(`Invalid RGB color: ${hex}`);
+  return Uint8Array.of(Number.parseInt(hex.slice(1, 3), 16), Number.parseInt(hex.slice(3, 5), 16), Number.parseInt(hex.slice(5, 7), 16));
+}
+function copyResult(symbols, toArrayBuffer, handle) {
+  const status = symbols.texResultStatus(handle);
+  if (status !== 0)
+    throw new Error(STATUS_MESSAGES[status] ?? `Native renderer failed with status ${status}`);
+  const pixelsPointer = symbols.texResultPixels(handle);
+  const pixelsLength = symbols.texResultPixelsLength(handle);
+  const width = symbols.texResultWidth(handle);
+  const height = symbols.texResultHeight(handle);
+  if (!pixelsPointer || width === 0 || height === 0)
+    throw new Error("Native renderer returned an empty image");
+  const expectedLength = width * height * 4;
+  if (pixelsLength !== expectedLength)
+    throw new Error("Native renderer returned an invalid pixel length");
+  const pixels = new Uint8Array(toArrayBuffer(pixelsPointer, pixelsLength));
+  return NativeImage.fromRgba(pixels, width, height, width * 4);
+}
+
+class NativeTexRenderer {
+  cache = new Map;
+  queue = [];
+  queueTimer = null;
+  rendering = false;
+  destroyed = false;
+  constructor() {
+    if (!isMainThread)
+      throw new Error("NativeTexRenderer is single-threaded and must be loaded on the main thread");
+  }
+  async renderAsync(formula, display, foreground, background, signal) {
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    if (signal?.aborted)
+      throw signal.reason ?? new Error("Native render cancelled");
+    const key = `${display ? "D" : "I"}\x00${foreground}\x00${background}\x00${formula}`;
+    const cached = this.getCached(key);
+    if (cached)
+      return cached;
+    this.discardAbortedJobs();
+    if (this.queue.length >= QUEUE_ENTRIES_MAX)
+      throw new Error(`Native render queue exceeds ${QUEUE_ENTRIES_MAX} formulas`);
+    const promise = new Promise((resolve, reject) => {
+      this.queue.push({ formula, display, foreground, background, signal, resolve, reject });
+    });
+    this.scheduleQueue();
+    return promise;
+  }
+  destroy() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    if (this.queueTimer)
+      clearTimeout(this.queueTimer);
+    this.queueTimer = null;
+    for (const job of this.queue.splice(0))
+      job.reject(new Error("Native renderer is destroyed"));
+    for (const image of this.cache.values())
+      image.dispose();
+    this.cache.clear();
+  }
+  async renderSync(formula, display, foreground, background, signal) {
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    const key = `${display ? "D" : "I"}\x00${foreground}\x00${background}\x00${formula}`;
+    const cached = this.getCached(key);
+    if (cached)
+      return cached;
+    const source = new TextEncoder().encode(formula);
+    if (source.byteLength === 0 || source.byteLength > SOURCE_SIZE_MAX)
+      throw new Error(`Formula must contain between 1 and ${SOURCE_SIZE_MAX} UTF-8 bytes`);
+    const foregroundRgb = rgb(foreground);
+    const backgroundRgb = rgb(background);
+    const library = await getNative();
+    if (this.destroyed)
+      throw new Error("Native renderer is destroyed");
+    if (signal?.aborted)
+      throw signal.reason ?? new Error("Native render cancelled");
+    const handle = library.symbols.texRender(source, source.byteLength, display ? 1 : 0, foregroundRgb, backgroundRgb);
+    if (!handle)
+      throw new Error("Native renderer could not allocate a result");
+    let image;
+    try {
+      image = copyResult(library.symbols, library.toArrayBuffer, handle);
+    } finally {
+      library.symbols.texResultDestroy(handle);
+    }
+    if (this.destroyed || signal?.aborted) {
+      image.dispose();
+      if (this.destroyed)
+        throw new Error("Native renderer is destroyed");
+      throw signal?.reason ?? new Error("Native render cancelled");
+    }
+    this.cache.set(key, image);
+    if (this.cache.size > CACHE_ENTRIES_MAX) {
+      const [oldest, evicted] = this.cache.entries().next().value;
+      this.cache.delete(oldest);
+      evicted.dispose();
+    }
+    return image.retain();
+  }
+  getCached(key) {
+    const image = this.cache.get(key);
+    if (!image)
+      return null;
+    this.cache.delete(key);
+    this.cache.set(key, image);
+    return image.retain();
+  }
+  scheduleQueue() {
+    if (this.queueTimer || this.rendering || this.queue.length === 0)
+      return;
+    this.queueTimer = setTimeout(() => {
+      this.queueTimer = null;
+      const job = this.queue.shift();
+      if (!job)
+        return;
+      if (job.signal?.aborted)
+        job.reject(job.signal.reason ?? new Error("Native render cancelled"));
+      else {
+        this.rendering = true;
+        this.renderSync(job.formula, job.display, job.foreground, job.background, job.signal).then(job.resolve, job.reject).finally(() => {
+          this.rendering = false;
+          this.scheduleQueue();
+        });
+        return;
+      }
+      this.scheduleQueue();
+    }, 0);
+  }
+  discardAbortedJobs() {
+    for (let index = this.queue.length - 1;index >= 0; index -= 1) {
+      const job = this.queue[index];
+      if (!job.signal?.aborted)
+        continue;
+      this.queue.splice(index, 1);
+      job.reject(job.signal.reason ?? new Error("Native render cancelled"));
+    }
+  }
+}
+
+// src/native/native-tex-backend.ts
+class NativeTexBackend {
+  renderer;
+  constructor(renderer = new NativeTexRenderer) {
+    this.renderer = renderer;
+  }
+  async render(request) {
+    const image = await this.renderer.renderAsync(request.formula, request.display, request.foreground, request.background, request.signal);
+    return { kind: "image", image };
+  }
+  destroy() {
+    this.renderer.destroy();
+  }
+}
+export {
+  NativeTexRenderer,
+  NativeTexBackend
+};

package/dist/react.d.ts

@@ -0,0 +1,8 @@
+import { BindingTexRenderable } from "./binding-tex-renderable.js";
+declare module "@opentui/react" {
+    interface OpenTUIComponents {
+        tex: typeof BindingTexRenderable;
+    }
+}
+export declare function registerTex(): void;
+export * from "./index.js";