@dkkoval/tui-preview 0.1.0

package/dist/core/normalize.js

@@ -0,0 +1,89 @@
+const DEFAULT_SIZE = { cols: 80, rows: 24 };
+const EMPTY_ENV = {};
+const EMPTY_ARGV = [];
+function isModernProps(props) {
+    return "wasm" in props;
+}
+function resolveArgvInput(argv) {
+    const value = argv ?? EMPTY_ARGV;
+    if (typeof value === "function") {
+        return value;
+    }
+    return () => value;
+}
+function resolveLegacySize(props) {
+    const hasExplicitSize = props.cols !== undefined || props.rows !== undefined;
+    if (!hasExplicitSize) {
+        return { fit: "container", size: DEFAULT_SIZE };
+    }
+    return {
+        fit: "none",
+        size: {
+            cols: Math.max(1, props.cols ?? DEFAULT_SIZE.cols),
+            rows: Math.max(1, props.rows ?? DEFAULT_SIZE.rows),
+        },
+    };
+}
+let warnedLegacyProps = false;
+export function warnLegacyPropsOnce(usedLegacyProps) {
+    if (!usedLegacyProps || warnedLegacyProps)
+        return;
+    warnedLegacyProps = true;
+    console.warn("[tui-preview] Legacy props (`app`, `args`, `cols`, `rows`, `fontSize`, `fontFamily`, `theme`) are deprecated. " +
+        "Use `wasm`, `argv`, `fit`, `size`, and `terminal`.");
+}
+export function resolveTuiPreviewProps(props) {
+    if (isModernProps(props)) {
+        const fit = props.fit ?? (props.size ? "none" : "container");
+        const size = fit === "none"
+            ? {
+                cols: Math.max(1, props.size?.cols ?? DEFAULT_SIZE.cols),
+                rows: Math.max(1, props.size?.rows ?? DEFAULT_SIZE.rows),
+            }
+            : {
+                cols: Math.max(1, props.size?.cols ?? DEFAULT_SIZE.cols),
+                rows: Math.max(1, props.size?.rows ?? DEFAULT_SIZE.rows),
+            };
+        return {
+            wasm: props.wasm,
+            env: props.env ?? EMPTY_ENV,
+            interactive: props.interactive ?? true,
+            mode: (props.mode ?? "terminal"),
+            fit,
+            size,
+            terminal: {
+                fontSize: props.terminal?.fontSize ?? 14,
+                fontFamily: props.terminal?.fontFamily ?? "monospace",
+                cursorBlink: props.terminal?.cursorBlink ?? true,
+                convertEol: props.terminal?.convertEol ?? true,
+                theme: props.terminal?.theme,
+            },
+            resolveArgv: resolveArgvInput(props.argv),
+            onExit: props.onExit,
+            onError: props.onError,
+            onStatusChange: props.onStatusChange,
+            usedLegacyProps: false,
+        };
+    }
+    const { fit, size } = resolveLegacySize(props);
+    return {
+        wasm: props.app,
+        env: props.env ?? EMPTY_ENV,
+        interactive: props.interactive ?? true,
+        mode: "terminal",
+        fit,
+        size,
+        terminal: {
+            fontSize: props.fontSize ?? 14,
+            fontFamily: props.fontFamily ?? "monospace",
+            cursorBlink: true,
+            convertEol: true,
+            theme: props.theme,
+        },
+        resolveArgv: resolveArgvInput(props.args),
+        onExit: props.onExit,
+        onError: props.onError,
+        onStatusChange: props.onStatusChange,
+        usedLegacyProps: true,
+    };
+}

package/dist/core/wasi.d.ts

@@ -0,0 +1,34 @@
+/**
+ * WASI bridge — connects a wasm32-wasi TUI app to a ghostty-web terminal.
+ *
+ * Implements a minimal WASI preview1 surface sufficient for interactive TUI apps:
+ *   - fd_write (stdout/stderr → terminal)
+ *   - fd_read (stdin ← keyboard input queue)
+ *   - poll_oneoff (non-blocking stdin check, needed by crossterm/ratatui)
+ *   - proc_exit
+ *   - environ_get / environ_sizes_get
+ *   - args_get / args_sizes_get
+ */
+import type { WasiOptions } from "../types.js";
+export declare class WasiBridge {
+    private opts;
+    private inputQueue;
+    private memory;
+    constructor(opts: WasiOptions);
+    /** Push keyboard data from the terminal into the app's stdin */
+    pushInput(data: string | Uint8Array): void;
+    /** Attach the WASM instance's memory after instantiation */
+    attachMemory(memory: WebAssembly.Memory): void;
+    private view;
+    private u8;
+    get imports(): WebAssembly.ModuleImports;
+    private envEntries;
+}
+export declare class WasiExitError extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+/** Load and instantiate a WASM TUI app with a WasiBridge */
+export declare function instantiateApp(source: string | URL, bridge: WasiBridge): Promise<{
+    run: () => Promise<void>;
+}>;

package/dist/core/wasi.js

@@ -0,0 +1,218 @@
+/**
+ * WASI bridge — connects a wasm32-wasi TUI app to a ghostty-web terminal.
+ *
+ * Implements a minimal WASI preview1 surface sufficient for interactive TUI apps:
+ *   - fd_write (stdout/stderr → terminal)
+ *   - fd_read (stdin ← keyboard input queue)
+ *   - poll_oneoff (non-blocking stdin check, needed by crossterm/ratatui)
+ *   - proc_exit
+ *   - environ_get / environ_sizes_get
+ *   - args_get / args_sizes_get
+ */
+const WASI_ESUCCESS = 0;
+const WASI_EAGAIN = 6;
+const WASI_BADF = 8;
+const STDIN_FD = 0;
+const STDOUT_FD = 1;
+const STDERR_FD = 2;
+export class WasiBridge {
+    opts;
+    inputQueue = [];
+    memory;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    /** Push keyboard data from the terminal into the app's stdin */
+    pushInput(data) {
+        const chunk = typeof data === "string" ? new TextEncoder().encode(data) : data;
+        this.inputQueue.push(chunk);
+    }
+    /** Attach the WASM instance's memory after instantiation */
+    attachMemory(memory) {
+        this.memory = memory;
+    }
+    view() {
+        return new DataView(this.memory.buffer);
+    }
+    u8() {
+        return new Uint8Array(this.memory.buffer);
+    }
+    // ── WASI imports object ────────────────────────────────────────────────
+    get imports() {
+        return {
+            args_sizes_get: (argcPtr, argvBufSizePtr) => {
+                const { args } = this.opts;
+                const enc = new TextEncoder();
+                const total = args.reduce((sum, arg) => sum + enc.encode(arg).length + 1, 0);
+                this.view().setUint32(argcPtr, args.length, true);
+                this.view().setUint32(argvBufSizePtr, total, true);
+                return WASI_ESUCCESS;
+            },
+            args_get: (argvPtr, argvBufPtr) => {
+                const enc = new TextEncoder();
+                const u8 = this.u8();
+                const view = this.view();
+                let bufOffset = argvBufPtr;
+                this.opts.args.forEach((arg, i) => {
+                    const bytes = enc.encode(arg);
+                    u8.set(bytes, bufOffset);
+                    u8[bufOffset + bytes.length] = 0;
+                    view.setUint32(argvPtr + i * 4, bufOffset, true);
+                    bufOffset += bytes.length + 1;
+                });
+                return WASI_ESUCCESS;
+            },
+            environ_sizes_get: (countPtr, bufSizePtr) => {
+                const entries = this.envEntries();
+                const enc = new TextEncoder();
+                const total = entries.reduce((sum, entry) => sum + enc.encode(entry).length + 1, 0);
+                this.view().setUint32(countPtr, entries.length, true);
+                this.view().setUint32(bufSizePtr, total, true);
+                return WASI_ESUCCESS;
+            },
+            environ_get: (environPtr, environBufPtr) => {
+                const enc = new TextEncoder();
+                const u8 = this.u8();
+                const view = this.view();
+                let bufOffset = environBufPtr;
+                this.envEntries().forEach((entry, i) => {
+                    const bytes = enc.encode(entry);
+                    u8.set(bytes, bufOffset);
+                    u8[bufOffset + bytes.length] = 0;
+                    view.setUint32(environPtr + i * 4, bufOffset, true);
+                    bufOffset += bytes.length + 1;
+                });
+                return WASI_ESUCCESS;
+            },
+            fd_write: (fd, iovsPtr, iovsLen, nwrittenPtr) => {
+                if (fd !== STDOUT_FD && fd !== STDERR_FD)
+                    return WASI_BADF;
+                const view = this.view();
+                const u8 = this.u8();
+                let nwritten = 0;
+                const chunks = [];
+                for (let i = 0; i < iovsLen; i++) {
+                    const ptr = view.getUint32(iovsPtr + i * 8, true);
+                    const len = view.getUint32(iovsPtr + i * 8 + 4, true);
+                    chunks.push(u8.slice(ptr, ptr + len));
+                    nwritten += len;
+                }
+                const merged = new Uint8Array(nwritten);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    merged.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                if (fd === STDOUT_FD) {
+                    this.opts.stdout(merged);
+                }
+                else {
+                    this.opts.stderr(merged);
+                }
+                view.setUint32(nwrittenPtr, nwritten, true);
+                return WASI_ESUCCESS;
+            },
+            fd_read: (fd, iovsPtr, iovsLen, nreadPtr) => {
+                if (fd !== STDIN_FD)
+                    return WASI_BADF;
+                const chunk = this.inputQueue.shift();
+                if (!chunk)
+                    return WASI_EAGAIN;
+                const view = this.view();
+                const u8 = this.u8();
+                let nread = 0;
+                for (let i = 0; i < iovsLen && nread < chunk.length; i++) {
+                    const ptr = view.getUint32(iovsPtr + i * 8, true);
+                    const len = view.getUint32(iovsPtr + i * 8 + 4, true);
+                    const toCopy = Math.min(len, chunk.length - nread);
+                    u8.set(chunk.subarray(nread, nread + toCopy), ptr);
+                    nread += toCopy;
+                }
+                view.setUint32(nreadPtr, nread, true);
+                return WASI_ESUCCESS;
+            },
+            poll_oneoff: (inPtr, outPtr, nsubscriptions, neventsPtr) => {
+                const view = this.view();
+                let nevents = 0;
+                for (let i = 0; i < nsubscriptions; i++) {
+                    const subPtr = inPtr + i * 48;
+                    const type = view.getUint8(subPtr + 8);
+                    if (type === 0 && this.inputQueue.length > 0) {
+                        const evPtr = outPtr + nevents * 32;
+                        view.setBigUint64(evPtr, view.getBigUint64(subPtr, true), true);
+                        view.setUint16(evPtr + 8, 0, true);
+                        view.setUint8(evPtr + 10, type);
+                        nevents++;
+                    }
+                }
+                view.setUint32(neventsPtr, nevents, true);
+                return WASI_ESUCCESS;
+            },
+            proc_exit: (code) => {
+                this.opts.onExit(code);
+                throw new WasiExitError(code);
+            },
+            random_get: (bufPtr, bufLen) => {
+                crypto.getRandomValues(new Uint8Array(this.memory.buffer, bufPtr, bufLen));
+                return WASI_ESUCCESS;
+            },
+            // Stubs for calls TUI apps may make but we don't need to implement.
+            fd_close: () => WASI_ESUCCESS,
+            fd_seek: () => WASI_ESUCCESS,
+            fd_fdstat_get: (fd, ptr) => {
+                const view = this.view();
+                view.setUint8(ptr, fd <= 2 ? 2 : 0); // 2=char_device
+                return WASI_ESUCCESS;
+            },
+            fd_prestat_get: () => WASI_BADF,
+            fd_prestat_dir_name: () => WASI_BADF,
+            path_open: () => WASI_BADF,
+            sched_yield: () => WASI_ESUCCESS,
+            clock_time_get: (_id, _precision, timePtr) => {
+                const ns = BigInt(Date.now()) * 1000000n;
+                this.view().setBigUint64(timePtr, ns, true);
+                return WASI_ESUCCESS;
+            },
+        };
+    }
+    envEntries() {
+        const base = {
+            TERM: "xterm-256color",
+            COLORTERM: "truecolor",
+            ...this.opts.env,
+        };
+        return Object.entries(base).map(([k, v]) => `${k}=${v}`);
+    }
+}
+export class WasiExitError extends Error {
+    code;
+    constructor(code) {
+        super(`WASI exit: ${code}`);
+        this.code = code;
+    }
+}
+/** Load and instantiate a WASM TUI app with a WasiBridge */
+export async function instantiateApp(source, bridge) {
+    const response = await fetch(source);
+    const bytes = await response.arrayBuffer();
+    const module = await WebAssembly.compile(bytes);
+    const importObject = {
+        wasi_snapshot_preview1: bridge.imports,
+    };
+    const instance = await WebAssembly.instantiate(module, importObject);
+    bridge.attachMemory(instance.exports.memory);
+    const _start = instance.exports._start;
+    if (!_start)
+        throw new Error("WASM module has no _start export");
+    return {
+        run: async () => {
+            try {
+                _start();
+            }
+            catch (e) {
+                if (!(e instanceof WasiExitError))
+                    throw e;
+            }
+        },
+    };
+}