@svelterm/core 0.1.0 → 0.23.0

package/dist/src/terminal/clipboard.js

@@ -0,0 +1,39 @@
+/**
+ * Clipboard writes. OSC 52 travels in-band (works over ssh and through
+ * multiplexers that pass it on); a platform tool runs as well when one
+ * exists, covering terminals with OSC 52 disabled. Failures are silent —
+ * copying is best-effort by nature here.
+ */
+export function osc52Copy(text) {
+    const base64 = typeof Buffer !== 'undefined'
+        ? Buffer.from(text, 'utf8').toString('base64')
+        : btoa(String.fromCharCode(...new TextEncoder().encode(text)));
+    return `\x1b]52;c;${base64}\x07`;
+}
+/** The platform clipboard command, if this platform has a common one. */
+function platformCopyCommand() {
+    if (typeof process === 'undefined')
+        return null;
+    switch (process.platform) {
+        case 'darwin': return { command: 'pbcopy', args: [] };
+        case 'linux':
+            return process.env.WAYLAND_DISPLAY
+                ? { command: 'wl-copy', args: [] }
+                : { command: 'xclip', args: ['-selection', 'clipboard'] };
+        case 'win32': return { command: 'clip', args: [] };
+        default: return null;
+    }
+}
+/** Write text to the clipboard: OSC 52 through `write`, plus a platform tool. */
+export function copyToClipboard(text, write) {
+    write(osc52Copy(text));
+    const tool = platformCopyCommand();
+    if (!tool)
+        return;
+    import('node:child_process').then(({ spawn }) => {
+        const child = spawn(tool.command, tool.args, { stdio: ['pipe', 'ignore', 'ignore'] });
+        child.on('error', () => { });
+        child.stdin.on('error', () => { });
+        child.stdin.end(text);
+    }).catch(() => { });
+}

package/dist/src/terminal/io.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Terminal IO interface — abstracts over the physical terminal.
+ *
+ * Two implementations:
+ * - ProcessIO: passthrough to process.stdout/stdin (Node.js terminal)
+ * - In-process IO: connects to a VT100 emulator in the same JS context (browser)
+ */
+export interface TerminalIO {
+    /** Write a string to the terminal output */
+    write(data: string): void;
+    /** Get current terminal dimensions */
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    /** Subscribe to incoming data (keyboard, mouse, query responses) */
+    onData(callback: (data: Buffer) => void): void;
+    /** Subscribe to terminal resize */
+    onResize(callback: () => void): void;
+    /** Enable raw input mode (no echo, no line buffering) */
+    enableRawMode(): void;
+    /** Disable raw input mode */
+    disableRawMode(): void;
+    /** Clean up all listeners */
+    dispose(): void;
+}
+/**
+ * Passthrough to process.stdout/stdin — the default for Node.js terminal apps.
+ *
+ * When stdin is not a TTY — `curl app.mjs | node -` delivers the script
+ * itself on stdin — input falls back to the controlling terminal
+ * (`/dev/tty`) so the app stays interactive.
+ */
+export declare class ProcessIO implements TerminalIO {
+    private dataCallbacks;
+    private resizeCallbacks;
+    private input;
+    private onInputData;
+    private onStdoutResize;
+    private listening;
+    private rawModeWanted;
+    private disposed;
+    constructor();
+    private reopenControllingTerminal;
+    write(data: string): void;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    onData(callback: (data: Buffer) => void): void;
+    onResize(callback: () => void): void;
+    enableRawMode(): void;
+    disableRawMode(): void;
+    dispose(): void;
+}
+/**
+ * In-process IO — connects svelterm to a consumer in the same JS context.
+ * Used for browser-based terminal rendering (svelterm → VT100 emulator).
+ */
+export declare class InProcessIO implements TerminalIO {
+    private dataCallbacks;
+    private resizeCallbacks;
+    private _width;
+    private _height;
+    /** Called when svelterm writes output — connect this to a VT100 emulator */
+    onOutput?: (data: string) => void;
+    constructor(width: number, height: number);
+    write(data: string): void;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    onData(callback: (data: Buffer) => void): void;
+    onResize(callback: () => void): void;
+    enableRawMode(): void;
+    disableRawMode(): void;
+    dispose(): void;
+    /** Feed input data (keyboard/mouse) into svelterm */
+    feedInput(data: string): void;
+    /** Notify svelterm of a resize */
+    setSize(width: number, height: number): void;
+}

package/dist/src/terminal/io.js

@@ -0,0 +1,155 @@
+/**
+ * Terminal IO interface — abstracts over the physical terminal.
+ *
+ * Two implementations:
+ * - ProcessIO: passthrough to process.stdout/stdin (Node.js terminal)
+ * - In-process IO: connects to a VT100 emulator in the same JS context (browser)
+ */
+/**
+ * Passthrough to process.stdout/stdin — the default for Node.js terminal apps.
+ *
+ * When stdin is not a TTY — `curl app.mjs | node -` delivers the script
+ * itself on stdin — input falls back to the controlling terminal
+ * (`/dev/tty`) so the app stays interactive.
+ */
+export class ProcessIO {
+    dataCallbacks = [];
+    resizeCallbacks = [];
+    input = process.stdin;
+    onInputData = (data) => {
+        for (const cb of this.dataCallbacks)
+            cb(data);
+    };
+    onStdoutResize = () => {
+        for (const cb of this.resizeCallbacks)
+            cb();
+    };
+    listening = false;
+    rawModeWanted = false;
+    disposed = false;
+    constructor() {
+        // With `node -` the script is read to EOF before execution, so no
+        // input can be lost while the async reopen is in flight.
+        if (!process.stdin.isTTY) {
+            void this.reopenControllingTerminal();
+        }
+    }
+    async reopenControllingTerminal() {
+        try {
+            const [fs, tty] = await Promise.all([import('node:fs'), import('node:tty')]);
+            const stream = new tty.ReadStream(fs.openSync('/dev/tty', 'r'));
+            if (this.disposed) {
+                stream.destroy();
+                return;
+            }
+            const previous = this.input;
+            this.input = stream;
+            if (this.listening) {
+                previous.removeListener('data', this.onInputData);
+                stream.on('data', this.onInputData);
+            }
+            if (this.rawModeWanted && stream.isTTY) {
+                stream.setRawMode(true);
+                stream.resume();
+            }
+        }
+        catch {
+            // No controlling terminal (CI, Windows pipe) — stay on stdin.
+        }
+    }
+    write(data) {
+        process.stdout.write(data);
+    }
+    getSize() {
+        return {
+            width: Math.max(1, process.stdout.columns ?? 80),
+            height: Math.max(1, process.stdout.rows ?? 24),
+        };
+    }
+    onData(callback) {
+        this.dataCallbacks.push(callback);
+        if (!this.listening) {
+            this.input.on('data', this.onInputData);
+            this.listening = true;
+        }
+    }
+    onResize(callback) {
+        this.resizeCallbacks.push(callback);
+        process.stdout.on('resize', this.onStdoutResize);
+    }
+    enableRawMode() {
+        this.rawModeWanted = true;
+        if (this.input.isTTY) {
+            this.input.setRawMode(true);
+            this.input.resume();
+        }
+    }
+    disableRawMode() {
+        this.rawModeWanted = false;
+        if (this.input.isTTY) {
+            this.input.setRawMode(false);
+            this.input.pause();
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this.input.removeListener('data', this.onInputData);
+        process.stdout.removeListener('resize', this.onStdoutResize);
+        if (this.input !== process.stdin) {
+            this.input.destroy();
+        }
+        this.dataCallbacks = [];
+        this.resizeCallbacks = [];
+        this.listening = false;
+    }
+}
+/**
+ * In-process IO — connects svelterm to a consumer in the same JS context.
+ * Used for browser-based terminal rendering (svelterm → VT100 emulator).
+ */
+export class InProcessIO {
+    dataCallbacks = [];
+    resizeCallbacks = [];
+    _width;
+    _height;
+    /** Called when svelterm writes output — connect this to a VT100 emulator */
+    onOutput;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
+    }
+    write(data) {
+        this.onOutput?.(data);
+    }
+    getSize() {
+        return { width: this._width, height: this._height };
+    }
+    onData(callback) {
+        this.dataCallbacks.push(callback);
+    }
+    onResize(callback) {
+        this.resizeCallbacks.push(callback);
+    }
+    enableRawMode() { }
+    disableRawMode() { }
+    dispose() {
+        this.dataCallbacks = [];
+        this.resizeCallbacks = [];
+        this.onOutput = undefined;
+    }
+    /** Feed input data (keyboard/mouse) into svelterm */
+    feedInput(data) {
+        const buf = typeof Buffer !== 'undefined'
+            ? Buffer.from(data)
+            : new TextEncoder().encode(data);
+        for (const cb of this.dataCallbacks)
+            cb(buf);
+    }
+    /** Notify svelterm of a resize */
+    setSize(width, height) {
+        this._width = width;
+        this._height = height;
+        for (const cb of this.resizeCallbacks)
+            cb();
+    }
+}

package/dist/src/terminal/screen.d.ts

@@ -1,10 +1,3 @@
-export interface TerminalSize {
-    width: number;
-    height: number;
-}
-export declare function getTerminalSize(): TerminalSize;
-export declare function enterFullscreen(): void;
-export declare function exitFullscreen(): void;
-export declare function enableRawMode(): void;
-export declare function disableRawMode(): void;
-export declare function writeOutput(data: string): void;
+import type { TerminalIO } from './io.js';
+export declare function enterFullscreen(io: TerminalIO): void;
+export declare function exitFullscreen(io: TerminalIO): void;

package/dist/src/terminal/screen.js

@@ -1,31 +1,8 @@
 import * as ansi from '../render/ansi.js';
-export function getTerminalSize() {
-    return {
-        width: Math.max(1, process.stdout.columns ?? 80),
-        height: Math.max(1, process.stdout.rows ?? 24),
-    };
+export function enterFullscreen(io) {
+    io.write(ansi.enterAltScreen());
+    io.write(ansi.clearScreen());
 }
-export function enterFullscreen() {
-    process.stdout.write(ansi.enterAltScreen());
-    process.stdout.write(ansi.hideCursor());
-    process.stdout.write(ansi.clearScreen());
-}
-export function exitFullscreen() {
-    process.stdout.write(ansi.showCursor());
-    process.stdout.write(ansi.exitAltScreen());
-}
-export function enableRawMode() {
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-    }
-}
-export function disableRawMode() {
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(false);
-        process.stdin.pause();
-    }
-}
-export function writeOutput(data) {
-    process.stdout.write(ansi.beginSyncUpdate() + data + ansi.endSyncUpdate());
+export function exitFullscreen(io) {
+    io.write(ansi.exitAltScreen());
 }

package/dist/src/terminal/stdin-router.d.ts

@@ -1,27 +1,30 @@
 /**
- * Single point of control for process.stdin.
+ * Single point of control for terminal input.
  *
- * All stdin data flows through here. Incoming bytes are classified and
+ * All input data flows through here. Incoming bytes are classified and
  * routed to the appropriate handler. Query-response interactions (OSC 11,
  * DA1, etc.) are serialised — only one query is in-flight at a time.
  */
+import type { TerminalIO } from './io.js';
 export interface StdinHandlers {
-    onKey: (data: Buffer) => void;
-    onMouse: (data: Buffer) => void;
+    onKey: (data: Buffer | Uint8Array) => void;
+    onMouse: (data: Buffer | Uint8Array) => void;
     onPaste: (text: string) => void;
 }
 export declare class StdinRouter {
+    private io;
     private handlers;
     private pendingQuery;
     private queryQueue;
     private pasteBuffer;
+    constructor(io: TerminalIO);
     start(handlers: StdinHandlers): void;
     stop(): void;
     /**
      * Send a query and wait for a matching response.
      * Queries are serialised — queued if one is already in-flight.
      */
-    query(write: string, match: (data: string) => string | null, timeoutMs?: number): Promise<string | null>;
+    query(write: string, match: (data: string) => string | null, timeoutMs?: number, onSend?: () => void): Promise<string | null>;
     private drainQueryQueue;
     private onData;
 }

package/dist/src/terminal/stdin-router.js

@@ -1,7 +1,7 @@
 /**
- * Single point of control for process.stdin.
+ * Single point of control for terminal input.
  *
- * All stdin data flows through here. Incoming bytes are classified and
+ * All input data flows through here. Incoming bytes are classified and
  * routed to the appropriate handler. Query-response interactions (OSC 11,
  * DA1, etc.) are serialised — only one query is in-flight at a time.
  */
@@ -10,16 +10,19 @@ const SGR_MOUSE_RE = /\x1b\[<\d+;\d+;\d+[Mm]/g;
 const PASTE_START = '\x1b[200~';
 const PASTE_END = '\x1b[201~';
 export class StdinRouter {
+    io;
     handlers = null;
     pendingQuery = null;
     queryQueue = [];
     pasteBuffer = null;
+    constructor(io) {
+        this.io = io;
+    }
     start(handlers) {
         this.handlers = handlers;
-        process.stdin.on('data', this.onData);
+        this.io.onData(this.onData);
     }
     stop() {
-        process.stdin.removeListener('data', this.onData);
         this.handlers = null;
         if (this.pendingQuery) {
             clearTimeout(this.pendingQuery.timer);
@@ -31,16 +34,16 @@ export class StdinRouter {
      * Send a query and wait for a matching response.
      * Queries are serialised — queued if one is already in-flight.
      */
-    query(write, match, timeoutMs = 200) {
+    query(write, match, timeoutMs = 200, onSend) {
         return new Promise((resolve, reject) => {
-            this.queryQueue.push({ write, match, resolve: resolve, reject, timeoutMs });
+            this.queryQueue.push({ write, match, resolve: resolve, reject, timeoutMs, onSend });
             this.drainQueryQueue();
         });
     }
     drainQueryQueue() {
         if (this.pendingQuery || this.queryQueue.length === 0)
             return;
-        const { write, match, resolve, timeoutMs } = this.queryQueue.shift();
+        const { write, match, resolve, timeoutMs, onSend } = this.queryQueue.shift();
         const timer = setTimeout(() => {
             this.pendingQuery = null;
             resolve(null);
@@ -56,10 +59,13 @@ export class StdinRouter {
             },
             timer,
         };
-        process.stdout.write(write);
+        onSend?.();
+        this.io.write(write);
     }
     onData = (data) => {
-        const str = data.toString();
+        const str = typeof Buffer !== 'undefined' && Buffer.isBuffer(data)
+            ? data.toString()
+            : new TextDecoder().decode(data);
         // Check for pending query response first
         if (this.pendingQuery) {
             const result = this.pendingQuery.match(str);
@@ -99,7 +105,7 @@ export class StdinRouter {
         const mouseMatches = [...str.matchAll(SGR_MOUSE_RE)];
         if (mouseMatches.length > 0) {
             for (const match of mouseMatches) {
-                this.handlers?.onMouse(Buffer.from(match[0]));
+                this.handlers?.onMouse(toBytes(match[0]));
             }
             // Check if there's non-mouse data remaining
             let remaining = str;
@@ -107,7 +113,7 @@ export class StdinRouter {
                 remaining = remaining.replace(match[0], '');
             }
             if (remaining.length > 0 && remaining.trim().length > 0) {
-                this.handlers?.onKey(Buffer.from(remaining));
+                this.handlers?.onKey(toBytes(remaining));
             }
             return;
         }
@@ -131,3 +137,8 @@ export function parseOSC11Scheme(rgb) {
     const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
     return luminance > 128 ? 'light' : 'dark';
 }
+function toBytes(str) {
+    if (typeof Buffer !== 'undefined')
+        return Buffer.from(str);
+    return new TextEncoder().encode(str);
+}

package/dist/src/utils/node-map.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A Map-compatible container keyed by node IDs, backed by a sparse array
+ * for fast indexed access. Implements the full Map<number, T> interface
+ * so it's a drop-in replacement.
+ *
+ * ~10x faster than Map.get()/set() for integer keys.
+ */
+export declare class NodeMap<T> implements Map<number, T> {
+    private items;
+    private _size;
+    readonly [Symbol.toStringTag] = "NodeMap";
+    get(id: number): T | undefined;
+    set(id: number, value: T): this;
+    has(id: number): boolean;
+    delete(id: number): boolean;
+    get size(): number;
+    clear(): void;
+    clone(): NodeMap<T>;
+    forEach(fn: (value: T, key: number, map: Map<number, T>) => void): void;
+    entries(): MapIterator<[number, T]>;
+    values(): MapIterator<T>;
+    keys(): MapIterator<number>;
+    [Symbol.iterator](): MapIterator<[number, T]>;
+}

package/dist/src/utils/node-map.js

@@ -0,0 +1,75 @@
+/**
+ * A Map-compatible container keyed by node IDs, backed by a sparse array
+ * for fast indexed access. Implements the full Map<number, T> interface
+ * so it's a drop-in replacement.
+ *
+ * ~10x faster than Map.get()/set() for integer keys.
+ */
+export class NodeMap {
+    items = [];
+    _size = 0;
+    [Symbol.toStringTag] = 'NodeMap';
+    get(id) {
+        return this.items[id];
+    }
+    set(id, value) {
+        if (this.items[id] === undefined)
+            this._size++;
+        this.items[id] = value;
+        return this;
+    }
+    has(id) {
+        return this.items[id] !== undefined;
+    }
+    delete(id) {
+        if (this.items[id] !== undefined) {
+            this.items[id] = undefined;
+            this._size--;
+            return true;
+        }
+        return false;
+    }
+    get size() {
+        return this._size;
+    }
+    clear() {
+        this.items = [];
+        this._size = 0;
+    }
+    clone() {
+        const copy = new NodeMap();
+        copy.items = this.items.slice();
+        copy._size = this._size;
+        return copy;
+    }
+    forEach(fn) {
+        for (let i = 0; i < this.items.length; i++) {
+            const v = this.items[i];
+            if (v !== undefined)
+                fn(v, i, this);
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this.items.length; i++) {
+            const v = this.items[i];
+            if (v !== undefined)
+                yield [i, v];
+        }
+    }
+    *values() {
+        for (let i = 0; i < this.items.length; i++) {
+            const v = this.items[i];
+            if (v !== undefined)
+                yield v;
+        }
+    }
+    *keys() {
+        for (let i = 0; i < this.items.length; i++) {
+            if (this.items[i] !== undefined)
+                yield i;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}

package/dist/src/vite/config.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Vite configuration helpers for svelterm.
+ *
+ * Usage in vite.config.ts:
+ *
+ *   import { svelte } from '@sveltejs/vite-plugin-svelte'
+ *   import { svelterm } from '@svelterm/core/vite'
+ *
+ *   export default defineConfig({
+ *       plugins: [
+ *           svelte(svelterm.svelteOptions()),
+ *           ...svelterm.terminalServer(),
+ *       ],
+ *       environments: svelterm.environments(),
+ *   })
+ *
+ * Then in another terminal:
+ *   npx svelterm dev http://localhost:5173/src/App.svelte
+ */
+export interface SveltermConfig {
+    /** Custom renderer module specifier. Default: '@svelterm/core' */
+    renderer?: string;
+    /** Terminal entry component. Default: './App.svelte' */
+    entry?: string;
+}
+/**
+ * Returns svelte plugin options with dynamicCompileOptions for the
+ * terminal environment.
+ */
+export declare function svelteOptions(config?: SveltermConfig): {
+    dynamicCompileOptions({ environment }: any): {
+        generate: string;
+        css: string;
+        experimental: {
+            customRenderer: string;
+        };
+    } | undefined;
+};
+/**
+ * Returns Vite environment configuration for the terminal environment.
+ */
+export declare function environments(): {
+    terminal: {
+        dev: {
+            createEnvironment(name: string, config: any): import("vite").RunnableDevEnvironment;
+        };
+        resolve: {
+            conditions: string[];
+            noExternal: string[];
+        };
+    };
+};
+/**
+ * Returns Vite plugins that bridge the terminal environment over
+ * WebSocket and serve CSS for the svelterm CLI.
+ */
+export declare function terminalServer(config?: SveltermConfig): any[];
+export declare const svelterm: {
+    svelteOptions: typeof svelteOptions;
+    environments: typeof environments;
+    terminalServer: typeof terminalServer;
+};