@pokit/tabs-ink 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daniel Grant
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @pokit/tabs-ink
+
+Tabbed terminal UI adapter for pok using [Ink](https://github.com/vadimdemedes/ink).
+
+## Installation
+
+```bash
+bun add @pokit/tabs-ink
+```
+
+## Usage
+
+```typescript
+import { run } from '@pokit/core';
+import { createTabsAdapter } from '@pokit/tabs-ink';
+
+await run(args, {
+  tabs: createTabsAdapter(),
+  // ...
+});
+```
+
+In commands:
+
+```typescript
+run: async (r) => {
+  await r.tabs([r.exec('npm run dev'), r.exec('stripe listen')], { name: 'Development' });
+};
+```
+
+## Features
+
+- Full-screen tabbed interface
+- Keyboard navigation (arrow keys, numbers)
+- Scrollable output per tab
+- Process lifecycle management
+- Status indicators (running, success, error)
+
+## Documentation
+
+See the [full documentation](https://github.com/openpok/pok/blob/main/docs/packages/tabs-ink.md).

package/dist/adapter.d.ts

@@ -0,0 +1,20 @@
+import type { TabsAdapter, EventBus } from '@pokit/core';
+/**
+ * Create a tabs adapter using Ink
+ */
+export declare function createTabsAdapter(): TabsAdapter;
+export type EventAdapterOptions = {
+    onExit?: (code: number) => void;
+};
+/**
+ * Create an event-driven adapter that renders based on EventBus events.
+ * This adapter builds a state tree from events and renders it using Ink.
+ *
+ * @param bus - The EventBus to listen to
+ * @param options - Options for the adapter
+ * @returns Object with unmount function to stop the adapter
+ */
+export declare function createEventAdapter(bus: EventBus, options?: EventAdapterOptions): {
+    unmount: () => void;
+};
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,WAAW,EAAwB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAK/E;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CA+G/C;AAMD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,QAAQ,EACb,OAAO,GAAE,mBAAwB,GAChC;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA2EzB"}

package/dist/adapter.js

@@ -0,0 +1,169 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Ink-based Tabs Adapter
+ *
+ * Implements the TabsAdapter interface using Ink (React for CLI).
+ * Also provides an event-driven adapter that renders based on EventBus events.
+ */
+import { render } from 'ink';
+import { TabsApp } from './tabs-app.js';
+import { EventDrivenApp } from './event-driven-app.js';
+import { TabsErrorBoundary, restoreTerminal } from './error-boundary.js';
+/**
+ * Create a tabs adapter using Ink
+ */
+export function createTabsAdapter() {
+    return {
+        async run(items, options) {
+            // Check stdout TTY
+            if (!process.stdout.isTTY) {
+                throw new Error('Tabbed view requires stdout to be a TTY');
+            }
+            // Check stdin TTY - required for keyboard input
+            if (!process.stdin.isTTY) {
+                throw new Error('Tabbed view requires stdin to be a TTY for keyboard input');
+            }
+            // Empty items - nothing to do
+            if (items.length === 0) {
+                return;
+            }
+            // Switch to alternate screen buffer (like vim/less)
+            // This preserves the main terminal content and provides a clean canvas
+            process.stdout.write('\x1b[?1049h\x1b[H');
+            // Ensure stdin is not paused - previous CLI operations (prompts, spinners)
+            // may have left it in a paused state
+            if (process.stdin.isPaused()) {
+                process.stdin.resume();
+            }
+            // Enable raw mode before Ink starts - Ink's internal ref counting may be
+            // out of sync if previous CLI operations (clack prompts/spinners) didn't
+            // properly balance their setRawMode calls
+            process.stdin.setRawMode(true);
+            return new Promise((resolve) => {
+                let resolved = false;
+                let unmount = null;
+                let clear = null;
+                // Cleanup function to restore terminal and resolve
+                const cleanup = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    // Remove signal handlers
+                    process.removeListener('SIGTERM', handleSignal);
+                    process.removeListener('SIGQUIT', handleSignal);
+                    process.removeListener('uncaughtException', handleUncaughtException);
+                    try {
+                        clear?.();
+                        unmount?.();
+                    }
+                    catch {
+                        // Ignore errors during cleanup
+                    }
+                    restoreTerminal();
+                    resolve();
+                };
+                // Signal handler for graceful shutdown
+                const handleSignal = () => {
+                    cleanup();
+                    process.exit(0);
+                };
+                // Handle uncaught exceptions
+                const handleUncaughtException = (error) => {
+                    restoreTerminal();
+                    console.error('\n[TabsUI] Uncaught exception:', error);
+                    cleanup();
+                    process.exit(1);
+                };
+                // Register signal handlers
+                process.on('SIGTERM', handleSignal);
+                process.on('SIGQUIT', handleSignal);
+                process.on('uncaughtException', handleUncaughtException);
+                // Handle fatal errors from error boundary
+                const handleFatalError = () => {
+                    cleanup();
+                };
+                const result = render(_jsx(TabsErrorBoundary, { onFatalError: handleFatalError, children: _jsx(TabsApp, { items: items, options: options, onExit: () => {
+                            cleanup();
+                        } }) }), {
+                    exitOnCtrlC: false, // We handle quit ourselves
+                    incrementalRendering: true, // Only update changed lines to reduce flicker
+                });
+                unmount = result.unmount;
+                clear = result.clear;
+                // Also resolve when ink exits naturally
+                result.waitUntilExit().then(() => {
+                    if (!resolved) {
+                        cleanup();
+                    }
+                });
+            });
+        },
+    };
+}
+/**
+ * Create an event-driven adapter that renders based on EventBus events.
+ * This adapter builds a state tree from events and renders it using Ink.
+ *
+ * @param bus - The EventBus to listen to
+ * @param options - Options for the adapter
+ * @returns Object with unmount function to stop the adapter
+ */
+export function createEventAdapter(bus, options = {}) {
+    if (!process.stdout.isTTY) {
+        throw new Error('Event-driven tabs view requires stdout to be a TTY');
+    }
+    if (!process.stdin.isTTY) {
+        throw new Error('Event-driven tabs view requires stdin to be a TTY for keyboard input');
+    }
+    process.stdout.write('\x1b[?1049h\x1b[H');
+    let isCleanedUp = false;
+    // Cleanup function to restore terminal
+    const cleanup = () => {
+        if (isCleanedUp)
+            return;
+        isCleanedUp = true;
+        // Remove signal handlers
+        process.removeListener('SIGTERM', handleSignal);
+        process.removeListener('SIGQUIT', handleSignal);
+        process.removeListener('uncaughtException', handleUncaughtException);
+        try {
+            clear();
+            unmount();
+        }
+        catch {
+            // Ignore errors during cleanup
+        }
+        restoreTerminal();
+    };
+    // Signal handler for graceful shutdown
+    const handleSignal = () => {
+        cleanup();
+        process.exit(0);
+    };
+    // Handle uncaught exceptions
+    const handleUncaughtException = (error) => {
+        restoreTerminal();
+        console.error('\n[TabsUI] Uncaught exception:', error);
+        cleanup();
+        process.exit(1);
+    };
+    // Register signal handlers
+    process.on('SIGTERM', handleSignal);
+    process.on('SIGQUIT', handleSignal);
+    process.on('uncaughtException', handleUncaughtException);
+    const handleExit = (code) => {
+        cleanup();
+        options.onExit?.(code);
+    };
+    // Handle fatal errors from error boundary
+    const handleFatalError = () => {
+        cleanup();
+    };
+    const { unmount, clear } = render(_jsx(TabsErrorBoundary, { onFatalError: handleFatalError, children: _jsx(EventDrivenApp, { bus: bus, onExit: handleExit }) }), {
+        exitOnCtrlC: false,
+        incrementalRendering: true,
+    });
+    return {
+        unmount: cleanup,
+    };
+}

package/dist/error-boundary.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Error Boundary for Tabs UI
+ *
+ * Catches React errors and ensures terminal state is restored before displaying error.
+ * This prevents the terminal from being left in a corrupted state (alternate screen,
+ * hidden cursor, raw mode) when React rendering crashes.
+ */
+import { Component, type ReactNode, type ErrorInfo } from 'react';
+export type ErrorBoundaryProps = {
+    children: ReactNode;
+    onFatalError?: (error: Error, errorInfo: ErrorInfo) => void;
+};
+type ErrorBoundaryState = {
+    hasError: boolean;
+    error: Error | null;
+};
+/**
+ * Restore terminal to a clean state.
+ * Called on errors and signal handlers to ensure terminal isn't left corrupted.
+ */
+export declare function restoreTerminal(): void;
+/**
+ * React Error Boundary that ensures terminal cleanup on crashes.
+ */
+export declare class TabsErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=error-boundary.d.ts.map

package/dist/error-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-boundary.d.ts","sourceRoot":"","sources":["../src/error-boundary.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGlE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,SAAS,CAAC;IACpB,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;CAC7D,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAgBtC;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;gBAC1E,KAAK,EAAE,kBAAkB;IAKrC,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,kBAAkB;IAIjE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAe3D,MAAM,IAAI,SAAS;CAkBpB"}

package/dist/error-boundary.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Error Boundary for Tabs UI
+ *
+ * Catches React errors and ensures terminal state is restored before displaying error.
+ * This prevents the terminal from being left in a corrupted state (alternate screen,
+ * hidden cursor, raw mode) when React rendering crashes.
+ */
+import { Component } from 'react';
+import { Text, Box } from 'ink';
+/**
+ * Restore terminal to a clean state.
+ * Called on errors and signal handlers to ensure terminal isn't left corrupted.
+ */
+export function restoreTerminal() {
+    // Exit alternate screen buffer
+    process.stdout.write('\x1b[?1049l');
+    // Show cursor (in case it was hidden)
+    process.stdout.write('\x1b[?25h');
+    // Reset all attributes (colors, styles)
+    process.stdout.write('\x1b[0m');
+    // Try to restore raw mode if stdin is a TTY
+    if (process.stdin.isTTY && process.stdin.isRaw) {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch {
+            // Ignore errors - stdin may already be closed
+        }
+    }
+}
+/**
+ * React Error Boundary that ensures terminal cleanup on crashes.
+ */
+export class TabsErrorBoundary extends Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+        // Restore terminal state immediately
+        restoreTerminal();
+        // Log error details for debugging
+        console.error('\n[TabsUI] Fatal error caught by error boundary:');
+        console.error(error);
+        if (errorInfo.componentStack) {
+            console.error('\nComponent stack:', errorInfo.componentStack);
+        }
+        // Notify parent if callback provided
+        this.props.onFatalError?.(error, errorInfo);
+    }
+    render() {
+        if (this.state.hasError) {
+            // Show minimal error message - terminal should already be restored
+            return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "red", bold: true, children: "TabsUI encountered a fatal error" }), _jsx(Text, { color: "gray", children: this.state.error?.message ?? 'Unknown error' }), _jsx(Text, { color: "gray", dimColor: true, children: "Press Ctrl+C to exit" })] }));
+        }
+        return this.props.children;
+    }
+}

package/dist/event-driven-app.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Event-Driven CLI App
+ *
+ * A React component that renders CLI state based on EventBus events.
+ * Supports different layouts (tabs, parallel, sequence) based on group layout hints.
+ */
+import type { EventBus } from '@pokit/core';
+type EventDrivenAppProps = {
+    bus: EventBus;
+    onExit: (code: number) => void;
+};
+export declare function EventDrivenApp({ bus, onExit }: EventDrivenAppProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=event-driven-app.d.ts.map

package/dist/event-driven-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-driven-app.d.ts","sourceRoot":"","sources":["../src/event-driven-app.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAK5C,KAAK,mBAAmB,GAAG;IACzB,GAAG,EAAE,QAAQ,CAAC;IACd,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC,CAAC;AA8HF,wBAAgB,cAAc,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,mBAAmB,2CAyGlE"}

package/dist/event-driven-app.js

@@ -0,0 +1,128 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Event-Driven CLI App
+ *
+ * A React component that renders CLI state based on EventBus events.
+ * Supports different layouts (tabs, parallel, sequence) based on group layout hints.
+ */
+import { useState, useCallback } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { findTabsGroup, getTabsGroupActivities } from '@pokit/tabs-core';
+import { useEventBus } from './use-event-bus.js';
+function getStatusIndicator({ status, inverse, }) {
+    switch (status) {
+        case 'running':
+            return { color: inverse ? 'cyanBright' : 'cyan', icon: '●' };
+        case 'success':
+            return { color: inverse ? 'greenBright' : 'green', icon: '✓' };
+        case 'failure':
+            return { color: inverse ? 'redBright' : 'red', icon: '✗' };
+    }
+}
+function ActivityTabBar({ activities, activeIndex, }) {
+    return (_jsx(Box, { gap: 1, flexWrap: "wrap", children: activities.map((activity, i) => {
+            const isActive = i === activeIndex;
+            const { color, icon } = getStatusIndicator({
+                status: activity.status,
+                inverse: isActive,
+            });
+            return (_jsxs(Box, { children: [_jsxs(Text, { inverse: isActive, color: color, children: [' ', icon, ' '] }), _jsxs(Text, { inverse: isActive, children: [" ", activity.label] }), _jsxs(Text, { inverse: isActive, children: [' (', i + 1, ') '] })] }, activity.id));
+        }) }));
+}
+function ActivityView({ activity, viewHeight }) {
+    const logs = activity.logs.slice(-viewHeight);
+    return (_jsxs(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: [activity.message && _jsx(Text, { color: "cyan", children: activity.message }), activity.progress !== undefined && (_jsxs(Text, { color: "yellow", children: ["Progress: ", activity.progress, "%"] })), logs.map((log, i) => {
+                let color;
+                switch (log.level) {
+                    case 'error':
+                        color = 'red';
+                        break;
+                    case 'warn':
+                        color = 'yellow';
+                        break;
+                    case 'success':
+                        color = 'green';
+                        break;
+                    case 'info':
+                        color = 'blue';
+                        break;
+                    default:
+                        color = undefined;
+                }
+                return (_jsx(Text, { color: color, wrap: "truncate", children: log.message }, i));
+            }), Array.from({
+                length: Math.max(0, viewHeight -
+                    logs.length -
+                    (activity.message ? 1 : 0) -
+                    (activity.progress !== undefined ? 1 : 0)),
+            }).map((_, i) => (_jsx(Text, { children: " " }, `empty-${i}`)))] }));
+}
+function StatusBar({ activityCount, quitConfirmPending, }) {
+    if (quitConfirmPending) {
+        return (_jsx(Box, { children: _jsxs(Text, { backgroundColor: "yellow", color: "black", children: [' ', "Press q again to quit, any other key to cancel", ' '] }) }));
+    }
+    return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["[Tab/1-", activityCount, "] switch | [q]uit"] }) }));
+}
+export function EventDrivenApp({ bus, onExit }) {
+    const state = useEventBus(bus);
+    const { stdout } = useStdout();
+    const [activeIndex, setActiveIndex] = useState(0);
+    const [quitConfirmPending, setQuitConfirmPending] = useState(false);
+    const terminalHeight = stdout?.rows ?? 24;
+    const viewHeight = Math.max(5, terminalHeight - 6);
+    const tabsGroup = findTabsGroup(state);
+    const activities = tabsGroup
+        ? getTabsGroupActivities(state, tabsGroup.id)
+        : Array.from(state.activities.values());
+    const activeActivity = activities[activeIndex];
+    const switchTab = useCallback((newIndex) => {
+        if (newIndex >= 0 && newIndex < activities.length) {
+            setActiveIndex(newIndex);
+        }
+    }, [activities.length]);
+    const handleQuitRequest = useCallback(() => {
+        setQuitConfirmPending((prev) => !prev);
+    }, []);
+    const handleQuit = useCallback(() => {
+        onExit(state.exitCode ?? 0);
+    }, [onExit, state.exitCode]);
+    useInput((input, key) => {
+        if (quitConfirmPending) {
+            if (input === 'q') {
+                handleQuit();
+            }
+            else {
+                handleQuitRequest();
+            }
+            return;
+        }
+        if (input === 'q') {
+            handleQuitRequest();
+            return;
+        }
+        if (input === 'c' && key.ctrl) {
+            handleQuit();
+            return;
+        }
+        const num = parseInt(input, 10);
+        if (num >= 1 && num <= activities.length) {
+            switchTab(num - 1);
+            return;
+        }
+        if (key.tab && key.shift) {
+            switchTab((activeIndex - 1 + activities.length) % activities.length);
+            return;
+        }
+        if (key.tab) {
+            switchTab((activeIndex + 1) % activities.length);
+            return;
+        }
+    }, { isActive: true });
+    if (activities.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { children: "Waiting for activities..." }), state.appName && (_jsxs(Text, { dimColor: true, children: [state.appName, state.version ? ` v${state.version}` : ''] }))] }));
+    }
+    if (!activeActivity) {
+        return _jsx(Text, { children: "No active activity" });
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(ActivityTabBar, { activities: activities, activeIndex: activeIndex }), _jsx(Box, { borderLeft: false, borderRight: false, borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(ActivityView, { activity: activeActivity, viewHeight: viewHeight }) }), _jsx(StatusBar, { activityCount: activities.length, quitConfirmPending: quitConfirmPending })] }));
+}

package/dist/help-overlay.d.ts

@@ -0,0 +1,5 @@
+export type HelpOverlayProps = {
+    onClose: () => void;
+};
+export declare function HelpOverlay(_props: HelpOverlayProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=help-overlay.d.ts.map

package/dist/help-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help-overlay.d.ts","sourceRoot":"","sources":["../src/help-overlay.tsx"],"names":[],"mappings":"AAGA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,wBAAgB,WAAW,CAAC,MAAM,EAAE,gBAAgB,2CAgCnD"}

package/dist/help-overlay.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { HELP_CONTENT } from '@pokit/tabs-core';
+export function HelpOverlay(_props) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "blue", paddingX: 2, paddingY: 1, children: [_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsx(Text, { bold: true, children: "Keyboard Help" }) }), HELP_CONTENT.map((group, i) => (_jsxs(Box, { flexDirection: "column", marginBottom: i < HELP_CONTENT.length - 1 ? 1 : 0, children: [_jsx(Text, { bold: true, color: "cyan", children: group.title }), group.shortcuts.map(({ key, description }) => (_jsxs(Box, { children: [_jsx(Box, { width: 16, children: _jsx(Text, { color: "yellow", children: key }) }), _jsx(Text, { children: description })] }, key)))] }, group.title))), _jsx(Box, { marginTop: 1, justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "Press ? or Escape to close" }) })] }));
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createTabsAdapter, createEventAdapter } from './adapter.js';
+export type { EventAdapterOptions } from './adapter.js';
+export { useEventBus } from './use-event-bus.js';
+export { createInitialState, reducer, getTabsGroupActivities, findTabsGroup, } from '@pokit/tabs-core';
+export type { ActivityNode, GroupNode, EventDrivenState, TabProcess } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACrE,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAGjD,OAAO,EACL,kBAAkB,EAClB,OAAO,EACP,sBAAsB,EACtB,aAAa,GACd,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createTabsAdapter, createEventAdapter } from './adapter.js';
+export { useEventBus } from './use-event-bus.js';
+// Re-export state management from @pokit/tabs-core (single source of truth)
+export { createInitialState, reducer, getTabsGroupActivities, findTabsGroup, } from '@pokit/tabs-core';

package/dist/tabbed-view.d.ts

@@ -0,0 +1,21 @@
+import type { TabProcess } from '@pokit/tabs-core';
+type TabbedViewProps = {
+    tabs: TabProcess[];
+    activeIndex: number;
+    onActiveIndexChange: (index: number) => void;
+    onQuit: () => void;
+    onQuitRequest: () => void;
+    onRestart: (index: number) => void;
+    onKill: (index: number) => void;
+    quitConfirmPending: boolean;
+    focusMode: boolean;
+    onEnterFocusMode: () => void;
+    onExitFocusMode: () => void;
+    onSendInput: (data: string) => void;
+    helpVisible: boolean;
+    onToggleHelp: () => void;
+    onCloseHelp: () => void;
+};
+export declare function TabbedView({ tabs, activeIndex, onActiveIndexChange, onQuit, onQuitRequest, onRestart, onKill, quitConfirmPending, focusMode, onEnterFocusMode, onExitFocusMode, onSendInput, helpVisible, onToggleHelp, onCloseHelp, }: TabbedViewProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=tabbed-view.d.ts.map

package/dist/tabbed-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabbed-view.d.ts","sourceRoot":"","sources":["../src/tabbed-view.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAWnD,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB,CAAC;AAyMF,wBAAgB,UAAU,CAAC,EACzB,IAAI,EACJ,WAAW,EACX,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,SAAS,EACT,MAAM,EACN,kBAAkB,EAClB,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,WAAW,EACX,YAAY,EACZ,WAAW,GACZ,EAAE,eAAe,2CAqGjB"}

package/dist/tabbed-view.js

@@ -0,0 +1,137 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text, useInput, useStdout } from 'ink';
+import { useTabsState, useKeyboardCallbackRefs, processKeyEvent, executeKeyboardAction, } from '@pokit/tabs-core';
+import { HelpOverlay } from './help-overlay.js';
+function getStatusIndicator({ status, inverse, }) {
+    switch (status) {
+        case 'running':
+            return { color: inverse ? 'cyanBright' : 'cyan', icon: '●' };
+        case 'done':
+            return { color: inverse ? 'greenBright' : 'green', icon: '✓' };
+        case 'error':
+            return { color: inverse ? 'redBright' : 'red', icon: '✗' };
+        case 'stopped':
+            return { color: inverse ? 'yellowBright' : 'yellow', icon: '■' };
+    }
+}
+function TabBar({ tabs, activeIndex, focusMode, }) {
+    return (_jsxs(Box, { gap: 1, flexWrap: "wrap", children: [tabs.map((tab, i) => {
+                const isActive = i === activeIndex;
+                const { color, icon } = getStatusIndicator({
+                    status: tab.status,
+                    inverse: isActive,
+                });
+                return (_jsxs(Box, { children: [_jsxs(Text, { inverse: isActive, color: color, children: [' ', icon, ' '] }), _jsxs(Text, { inverse: isActive, children: [" ", tab.label] }), _jsxs(Text, { inverse: isActive, children: [' (', i + 1, ') '] })] }, tab.id));
+            }), focusMode && (_jsx(Text, { backgroundColor: "yellow", color: "black", children: ' INPUT MODE ' }))] }));
+}
+function OutputView({ lines, scrollOffset, viewHeight, canScrollUp, canScrollDown, }) {
+    const visibleLines = lines.slice(scrollOffset, scrollOffset + viewHeight);
+    return (_jsxs(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: [visibleLines.map((line, i) => {
+                // Show scroll indicator on first two lines
+                let prefix = '  ';
+                if (i === 0 && canScrollUp)
+                    prefix = '↑ ';
+                else if (i === 1 && canScrollDown)
+                    prefix = '↓ ';
+                return (_jsxs(Text, { wrap: "truncate", dimColor: i < 2 && prefix !== '  ', children: [_jsx(Text, { dimColor: true, children: prefix }), _jsx(Text, { children: line || ' ' })] }, i));
+            }), Array.from({
+                length: Math.max(0, viewHeight - visibleLines.length),
+            }).map((_, i) => {
+                const lineIndex = visibleLines.length + i;
+                let prefix = '  ';
+                if (lineIndex === 0 && canScrollUp)
+                    prefix = '↑ ';
+                else if (lineIndex === 1 && canScrollDown)
+                    prefix = '↓ ';
+                return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: prefix }), _jsx(Text, { children: " " })] }, `empty-${i}`));
+            })] }));
+}
+function StatusBar({ tabCount, quitConfirmPending, focusMode, showHelpHint, }) {
+    if (quitConfirmPending) {
+        return (_jsx(Box, { children: _jsxs(Text, { backgroundColor: "yellow", color: "black", children: [' ', "Press q again to quit, any other key to cancel", ' '] }) }));
+    }
+    if (focusMode) {
+        return (_jsxs(Box, { children: [_jsxs(Text, { backgroundColor: "cyan", color: "black", children: [' ', "INPUT MODE", ' '] }), _jsx(Text, { dimColor: true, children: " Press Esc to exit input mode" })] }));
+    }
+    return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["[\u2191\u2193] scroll | [Tab/1-", tabCount, "] switch | [i]nput | [r]estart | [k]ill | [q]uit", showHelpHint && ' | Press ? for help'] }) }));
+}
+/**
+ * Normalize Ink's useInput key event to the shared NormalizedKeyEvent format.
+ */
+function normalizeInkKeyEvent(input, key) {
+    // Map Ink key properties to normalized key names
+    let name;
+    if (key.escape)
+        name = 'escape';
+    else if (key.return)
+        name = 'return';
+    else if (key.tab)
+        name = 'tab';
+    else if (key.backspace)
+        name = 'backspace';
+    else if (key.delete)
+        name = 'delete';
+    else if (key.upArrow)
+        name = 'up';
+    else if (key.downArrow)
+        name = 'down';
+    else if (key.leftArrow)
+        name = 'left';
+    else if (key.rightArrow)
+        name = 'right';
+    else if (key.pageUp)
+        name = 'pageup';
+    else if (key.pageDown)
+        name = 'pagedown';
+    return {
+        char: input || undefined,
+        name,
+        ctrl: key.ctrl,
+        shift: key.shift,
+        meta: key.meta,
+    };
+}
+export function TabbedView({ tabs, activeIndex, onActiveIndexChange, onQuit, onQuitRequest, onRestart, onKill, quitConfirmPending, focusMode, onEnterFocusMode, onExitFocusMode, onSendInput, helpVisible, onToggleHelp, onCloseHelp, }) {
+    const { stdout } = useStdout();
+    // Calculate view height based on terminal size
+    // Reserve space for: padding (2) + tab bar (1) + border (2) + status bar (1) = 6
+    const terminalHeight = stdout?.rows ?? 24;
+    const viewHeight = Math.max(5, terminalHeight - 6);
+    // Use shared tabs state hook
+    const { showHelpHint, activeScrollOffset, canScrollUp, canScrollDown, scrollBy, switchTab, nextTab, prevTab, } = useTabsState({
+        tabs,
+        activeIndex,
+        onActiveIndexChange,
+        viewHeight,
+    });
+    // Use shared callback refs hook
+    const callbacks = {
+        onQuit,
+        onQuitRequest,
+        onRestart,
+        onKill,
+        onEnterFocusMode,
+        onExitFocusMode,
+        onSendInput,
+        onToggleHelp,
+        onCloseHelp,
+    };
+    const callbackRefs = useKeyboardCallbackRefs(callbacks);
+    // Keyboard handling via useInput - always active
+    useInput((input, key) => {
+        const normalizedEvent = normalizeInkKeyEvent(input, key);
+        const action = processKeyEvent(normalizedEvent, {
+            helpVisible,
+            focusMode,
+            quitConfirmPending,
+            activeIndex,
+            tabCount: tabs.length,
+        }, viewHeight);
+        executeKeyboardAction(action, callbackRefs, scrollBy, switchTab, nextTab, prevTab);
+    });
+    const activeTab = tabs[activeIndex];
+    if (!activeTab) {
+        return _jsx(Text, { children: "No tabs available" });
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(TabBar, { tabs: tabs, activeIndex: activeIndex, focusMode: focusMode }), _jsx(Box, { borderLeft: false, borderRight: false, borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(OutputView, { lines: activeTab.output, scrollOffset: activeScrollOffset, viewHeight: viewHeight, canScrollUp: canScrollUp, canScrollDown: canScrollDown }) }), _jsx(StatusBar, { tabCount: tabs.length, quitConfirmPending: quitConfirmPending, focusMode: focusMode, showHelpHint: showHelpHint }), helpVisible && (_jsx(Box, { position: "absolute", flexDirection: "column", alignItems: "center", justifyContent: "center", width: "100%", height: "100%", children: _jsx(HelpOverlay, { onClose: onCloseHelp }) }))] }));
+}

package/dist/tabs-app.d.ts

@@ -0,0 +1,9 @@
+import type { TabSpec, TabsOptions } from '@pokit/core';
+type TabsAppProps = {
+    items: TabSpec[];
+    options: TabsOptions;
+    onExit: (code: number) => void;
+};
+export declare function TabsApp({ items, options, onExit }: TabsAppProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=tabs-app.d.ts.map

package/dist/tabs-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs-app.d.ts","sourceRoot":"","sources":["../src/tabs-app.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAIxD,KAAK,YAAY,GAAG;IAClB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC,CAAC;AAOF,wBAAgB,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,YAAY,2CA+R/D"}

package/dist/tabs-app.js

@@ -0,0 +1,234 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { spawn } from 'node:child_process';
+import { TabbedView } from './tabbed-view.js';
+import { OutputBuffer, MAX_OUTPUT_LINES, MAX_LINE_LENGTH, BUFFER_WARNING_THRESHOLD, } from '@pokit/tabs-core';
+const OUTPUT_BATCH_MS = 16;
+export function TabsApp({ items, options, onExit }) {
+    // Ring buffers for storing all output per tab (with O(1) operations)
+    const ringBuffersRef = useRef(new Map());
+    // Initialize ring buffers for each tab
+    const getOrCreateRingBuffer = useCallback((tabId) => {
+        let buffer = ringBuffersRef.current.get(tabId);
+        if (!buffer) {
+            buffer = new OutputBuffer({
+                maxLines: MAX_OUTPUT_LINES,
+                maxLineLength: MAX_LINE_LENGTH,
+                warnAtPercentage: BUFFER_WARNING_THRESHOLD,
+                tabId,
+                // Optional: could add onPressure callback here for UI feedback
+            });
+            ringBuffersRef.current.set(tabId, buffer);
+        }
+        return buffer;
+    }, []);
+    const [tabs, setTabs] = useState(() => items.map((item, i) => ({
+        id: `tab-${i}`,
+        label: item.label,
+        exec: item.exec,
+        output: [],
+        status: 'running',
+    })));
+    const [quitConfirmPending, setQuitConfirmPending] = useState(false);
+    const [focusMode, setFocusMode] = useState(false);
+    const [activeIndex, setActiveIndex] = useState(0);
+    const [helpVisible, setHelpVisible] = useState(false);
+    const processesRef = useRef([]);
+    const batchBuffersRef = useRef(new Map());
+    const flushScheduledRef = useRef(false);
+    const flushOutput = useCallback(() => {
+        flushScheduledRef.current = false;
+        const buffersSnapshot = batchBuffersRef.current;
+        batchBuffersRef.current = new Map();
+        if (buffersSnapshot.size === 0)
+            return;
+        const updates = [];
+        for (const [index, buffer] of buffersSnapshot.entries()) {
+            if (buffer.lines.length > 0) {
+                updates.push({ index, lines: buffer.lines });
+            }
+        }
+        if (updates.length === 0)
+            return;
+        setTabs((prev) => {
+            const next = [...prev];
+            for (const { index, lines } of updates) {
+                const tab = next[index];
+                if (!tab)
+                    continue;
+                // Push to ring buffer and get output with dropped indicator
+                const ringBuffer = getOrCreateRingBuffer(tab.id);
+                ringBuffer.push(...lines);
+                next[index] = { ...tab, output: ringBuffer.toArray() };
+            }
+            return next;
+        });
+    }, [getOrCreateRingBuffer]);
+    const scheduleFlush = useCallback(() => {
+        if (flushScheduledRef.current)
+            return;
+        flushScheduledRef.current = true;
+        setTimeout(flushOutput, OUTPUT_BATCH_MS);
+    }, [flushOutput]);
+    const appendOutput = useCallback((index, data) => {
+        const text = data.toString('utf-8');
+        const lines = text.split(/\r?\n/).filter((line, idx, arr) => {
+            return line || idx < arr.length - 1;
+        });
+        if (lines.length === 0)
+            return;
+        let buffer = batchBuffersRef.current.get(index);
+        if (!buffer) {
+            buffer = { lines: [] };
+            batchBuffersRef.current.set(index, buffer);
+        }
+        buffer.lines.push(...lines);
+        scheduleFlush();
+    }, [scheduleFlush]);
+    const spawnProcess = useCallback((index) => {
+        const item = items[index];
+        if (!item)
+            return null;
+        // Use 'pipe' for stdin so we can send input in focus mode
+        const proc = spawn('sh', ['-c', item.exec], {
+            cwd: options.cwd,
+            env: {
+                ...options.env,
+                FORCE_COLOR: '1',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const handleData = (data) => appendOutput(index, data);
+        proc.stdout?.on('data', handleData);
+        proc.stderr?.on('data', handleData);
+        proc.on('close', (code) => {
+            flushOutput();
+            setTabs((prev) => {
+                const next = [...prev];
+                const tab = next[index];
+                if (!tab)
+                    return prev;
+                next[index] = {
+                    ...tab,
+                    status: code === 0 ? 'done' : 'error',
+                    exitCode: code ?? undefined,
+                };
+                return next;
+            });
+        });
+        proc.on('error', (err) => {
+            setTabs((prev) => {
+                const next = [...prev];
+                const tab = next[index];
+                if (!tab)
+                    return prev;
+                next[index] = {
+                    ...tab,
+                    status: 'error',
+                    output: [...tab.output, `Error: ${err.message}`],
+                };
+                return next;
+            });
+        });
+        return proc;
+    }, [items, options.cwd, options.env, appendOutput, flushOutput]);
+    useEffect(() => {
+        const procs = items.map((_, i) => spawnProcess(i));
+        processesRef.current = procs;
+        return () => {
+            for (const proc of processesRef.current) {
+                if (proc && !proc.killed) {
+                    proc.kill('SIGTERM');
+                }
+            }
+        };
+    }, [items, spawnProcess]);
+    const killAll = useCallback(() => {
+        for (const proc of processesRef.current) {
+            if (proc && !proc.killed) {
+                proc.kill('SIGTERM');
+            }
+        }
+    }, []);
+    const handleRestart = useCallback((index) => {
+        const existingProc = processesRef.current[index];
+        if (existingProc && !existingProc.killed) {
+            existingProc.kill('SIGTERM');
+        }
+        // Clear both batch buffer and ring buffer
+        batchBuffersRef.current.delete(index);
+        const tabId = `tab-${index}`;
+        ringBuffersRef.current.get(tabId)?.clear();
+        setTabs((prev) => {
+            const next = [...prev];
+            const tab = next[index];
+            if (!tab)
+                return prev;
+            next[index] = {
+                ...tab,
+                output: ['Restarting...', ''],
+                status: 'running',
+                exitCode: undefined,
+            };
+            return next;
+        });
+        setTimeout(() => {
+            const newProc = spawnProcess(index);
+            processesRef.current[index] = newProc;
+        }, 100);
+    }, [spawnProcess]);
+    const handleKill = useCallback((index) => {
+        const proc = processesRef.current[index];
+        if (proc && !proc.killed) {
+            proc.kill('SIGTERM');
+        }
+        setTabs((prev) => {
+            const next = [...prev];
+            const tab = next[index];
+            if (!tab)
+                return prev;
+            if (tab.status !== 'running')
+                return prev;
+            next[index] = {
+                ...tab,
+                status: 'stopped',
+                output: [...tab.output, '', 'Stopped'],
+            };
+            return next;
+        });
+    }, []);
+    const handleQuitRequest = useCallback(() => {
+        setQuitConfirmPending((prev) => !prev);
+    }, []);
+    const handleQuit = useCallback(() => {
+        killAll();
+        onExit(0);
+    }, [killAll, onExit]);
+    const handleEnterFocusMode = useCallback(() => {
+        const proc = processesRef.current[activeIndex];
+        if (proc && !proc.killed && proc.stdin) {
+            setFocusMode(true);
+        }
+    }, [activeIndex]);
+    const handleExitFocusMode = useCallback(() => {
+        setFocusMode(false);
+    }, []);
+    const handleSendInput = useCallback((data) => {
+        const proc = processesRef.current[activeIndex];
+        if (proc && !proc.killed && proc.stdin) {
+            proc.stdin.write(data);
+        }
+    }, [activeIndex]);
+    const handleActiveIndexChange = useCallback((index) => {
+        setActiveIndex(index);
+        // Exit focus mode when switching tabs
+        setFocusMode(false);
+    }, []);
+    const handleToggleHelp = useCallback(() => {
+        setHelpVisible((prev) => !prev);
+    }, []);
+    const handleCloseHelp = useCallback(() => {
+        setHelpVisible(false);
+    }, []);
+    return (_jsx(TabbedView, { tabs: tabs, activeIndex: activeIndex, onActiveIndexChange: handleActiveIndexChange, onQuit: handleQuit, onQuitRequest: handleQuitRequest, onRestart: handleRestart, onKill: handleKill, quitConfirmPending: quitConfirmPending, focusMode: focusMode, onEnterFocusMode: handleEnterFocusMode, onExitFocusMode: handleExitFocusMode, onSendInput: handleSendInput, helpVisible: helpVisible, onToggleHelp: handleToggleHelp, onCloseHelp: handleCloseHelp }));
+}

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Types for tabs-ink
+ *
+ * Re-exports shared types from @pokit/tabs-core and defines implementation-specific types.
+ */
+import type { ChildProcess } from 'node:child_process';
+import type { TabProcess as BaseTabProcess } from '@pokit/tabs-core';
+export type { TabStatus, ActivityNode, GroupNode, EventDrivenState } from '@pokit/tabs-core';
+export { MAX_OUTPUT_LINES } from '@pokit/tabs-core';
+/**
+ * Extended TabProcess with ChildProcess reference for process management.
+ * This extends the base TabProcess from tabs-core with Ink-specific fields.
+ */
+export type TabProcess = BaseTabProcess & {
+    /** Reference to the spawned child process (Ink-specific) */
+    process?: ChildProcess;
+};
+/**
+ * Props for the TabbedView component (UI-specific)
+ */
+export type TabbedViewProps = {
+    tabs: TabProcess[];
+    onQuit: () => void;
+    onQuitRequest: () => void;
+    quitConfirmPending: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMrE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAE7F,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAMpD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG;IACxC,4DAA4D;IAC5D,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC"}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for tabs-ink
+ *
+ * Re-exports shared types from @pokit/tabs-core and defines implementation-specific types.
+ */
+export { MAX_OUTPUT_LINES } from '@pokit/tabs-core';

package/dist/use-event-bus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * React Hook for EventBus
+ *
+ * Provides a hook to subscribe to EventBus events and manage state.
+ */
+import type { EventBus } from '@pokit/core';
+import type { EventDrivenState } from '@pokit/tabs-core';
+/**
+ * Hook to subscribe to EventBus and manage state
+ */
+export declare function useEventBus(bus: EventBus): EventDrivenState;
+//# sourceMappingURL=use-event-bus.d.ts.map

package/dist/use-event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event-bus.d.ts","sourceRoot":"","sources":["../src/use-event-bus.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAa3D"}

package/dist/use-event-bus.js

@@ -0,0 +1,21 @@
+/**
+ * React Hook for EventBus
+ *
+ * Provides a hook to subscribe to EventBus events and manage state.
+ */
+import { useState, useEffect, useCallback } from 'react';
+import { createInitialState, reducer } from '@pokit/tabs-core';
+/**
+ * Hook to subscribe to EventBus and manage state
+ */
+export function useEventBus(bus) {
+    const [state, setState] = useState(createInitialState);
+    const handleEvent = useCallback((event) => {
+        setState((prevState) => reducer(prevState, event));
+    }, []);
+    useEffect(() => {
+        const unsubscribe = bus.on(handleEvent);
+        return unsubscribe;
+    }, [bus, handleEvent]);
+    return state;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@pokit/tabs-ink",
+  "version": "0.0.1",
+  "description": "Ink-based tab renderer for pok CLI applications",
+  "keywords": [
+    "cli",
+    "command-line",
+    "typescript",
+    "bun",
+    "terminal",
+    "pok",
+    "pokjs",
+    "tabs",
+    "ink",
+    "react",
+    "tui"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/notation-dev/openpok.git",
+    "directory": "packages/tabs-ink"
+  },
+  "homepage": "https://github.com/notation-dev/openpok#readme",
+  "bugs": {
+    "url": "https://github.com/notation-dev/openpok/issues"
+  },
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ink": "^6.6.0",
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.0",
+    "@pokit/core": "0.0.1",
+    "@pokit/tabs-core": "0.0.1"
+  },
+  "peerDependencies": {
+    "@pokit/core": "0.0.1",
+    "@pokit/tabs-core": "0.0.1"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { createTabsAdapter, createEventAdapter } from './adapter.js';
+export type { EventAdapterOptions } from './adapter.js';
+
+export { useEventBus } from './use-event-bus.js';
+
+// Re-export state management from @pokit/tabs-core (single source of truth)
+export {
+  createInitialState,
+  reducer,
+  getTabsGroupActivities,
+  findTabsGroup,
+} from '@pokit/tabs-core';
+
+// Re-export types from local types.ts (which re-exports from tabs-core + adds Ink-specific types)
+export type { ActivityNode, GroupNode, EventDrivenState, TabProcess } from './types.js';