tmux-ide 1.3.1 → 2.0.0

package/dist/launch.js

@@ -1,174 +0,0 @@
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { execSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { readConfig, getSessionName } from "./lib/yaml-io.js";
-import { computeSizes, toSplitPercents } from "./lib/sizes.js";
-import { outputError } from "./lib/output.js";
-import { collectPaneStartupPlan } from "./lib/launch-plan.js";
-import { buildSessionOptions } from "./lib/session-options.js";
-import { attachSession, createDetachedSession, getPaneCurrentCommand, getSessionVariable, hasSession, runSessionCommand, selectPane, sendLiteral, setPaneTitle, setSessionEnvironment, setSessionVariable, splitPane, startSessionMonitor, } from "./lib/tmux.js";
-import { validateConfig } from "./validate.js";
-function sleepMs(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function configHash(config) {
-    return createHash("sha256").update(JSON.stringify(config)).digest("hex").slice(0, 12);
-}
-export function waitForPaneCommand(targetPane, expectedCommands, { attempts = 20, delayMs = 100, getCurrentCommand = getPaneCurrentCommand, sleep = sleepMs, } = {}) {
-    const allowed = new Set(expectedCommands.map((command) => command.toLowerCase()));
-    for (let attempt = 0; attempt < attempts; attempt++) {
-        try {
-            const current = getCurrentCommand(targetPane)?.trim().toLowerCase();
-            if (current && allowed.has(current))
-                return true;
-        }
-        catch {
-            // Fall through to retry; tmux can briefly report transitional state.
-        }
-        if (attempt < attempts - 1) {
-            sleep(delayMs);
-        }
-    }
-    return false;
-}
-export function buildPaneMap(rows, dir, rootPaneId, splitPaneFn) {
-    const rowSizes = computeSizes(rows);
-    const rowSplitPercents = toSplitPercents(rowSizes);
-    // Create all rows vertically first so each row spans the full width.
-    const rowPaneIds = [rootPaneId];
-    for (let rowIdx = 1; rowIdx < rows.length; rowIdx++) {
-        const splitFrom = rowPaneIds[rowIdx - 1];
-        const newPaneId = splitPaneFn({
-            targetPane: splitFrom,
-            direction: "vertical",
-            cwd: dir,
-            percent: rowSplitPercents[rowIdx - 1],
-        });
-        rowPaneIds.push(newPaneId);
-    }
-    const paneMap = [];
-    const firstPanesOfRows = new Set(rowPaneIds);
-    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-        const row = rows[rowIdx];
-        const panes = row.panes ?? [];
-        const rowPaneId = rowPaneIds[rowIdx];
-        const rowPanes = [rowPaneId];
-        const paneSizes = computeSizes(panes);
-        const paneSplitPercents = toSplitPercents(paneSizes);
-        for (let paneIdx = 1; paneIdx < panes.length; paneIdx++) {
-            const pane = panes[paneIdx];
-            const targetPane = rowPanes[paneIdx - 1];
-            const paneDir = pane.dir ? resolve(dir, pane.dir) : dir;
-            const newPaneId = splitPaneFn({
-                targetPane,
-                direction: "horizontal",
-                cwd: paneDir,
-                percent: paneSplitPercents[paneIdx - 1],
-            });
-            rowPanes.push(newPaneId);
-        }
-        paneMap.push(rowPanes);
-    }
-    return { paneMap, firstPanesOfRows };
-}
-function loadLaunchConfig(dir) {
-    let config;
-    try {
-        ({ config } = readConfig(dir));
-    }
-    catch (error) {
-        if (error?.code === "ENOENT") {
-            outputError(`No ide.yml found in ${dir}. Run "tmux-ide init" or "tmux-ide detect --write" to create one.`, "CONFIG_NOT_FOUND");
-        }
-        outputError(`Cannot read ide.yml: ${error.message}`, "READ_ERROR");
-    }
-    const errors = validateConfig(config);
-    if (errors.length > 0) {
-        outputError(`Invalid ide.yml in ${dir}. Run "tmux-ide validate" for details.`, "INVALID_CONFIG");
-    }
-    return config;
-}
-function runBeforeHook(command, dir) {
-    if (!command)
-        return;
-    console.log(`Running: ${command}`);
-    try {
-        execSync(command, { cwd: dir, stdio: "inherit" });
-    }
-    catch {
-        outputError(`The before hook failed: ${command}`, "BEFORE_HOOK_FAILED");
-    }
-}
-export async function launch(targetDir, { json = false, attach = true } = {}) {
-    const dir = resolve(targetDir ?? ".");
-    const config = loadLaunchConfig(dir);
-    const { name: fallbackName } = getSessionName(dir);
-    const session = config.name ?? fallbackName;
-    const rows = config.rows;
-    const theme = config.theme ?? {};
-    const team = config.team ?? null;
-    runBeforeHook(config.before, dir);
-    // If session already exists, check for config drift and attach
-    if (hasSession(session)) {
-        const currentHash = configHash(config);
-        const storedHash = getSessionVariable(session, "@config_hash");
-        const configChanged = Boolean(storedHash && currentHash !== storedHash);
-        if (json) {
-            console.log(JSON.stringify({ session, running: true, configChanged }));
-        }
-        else if (configChanged) {
-            console.log(`Session "${session}" is running but ide.yml has changed.`);
-            console.log(`Run "tmux-ide restart" to apply changes.`);
-        }
-        else {
-            console.log(`Session "${session}" is already running. Attaching...`);
-        }
-        if (attach) {
-            attachSession(session);
-        }
-        return;
-    }
-    // Get terminal dimensions
-    const cols = process.stdout.columns ?? 200;
-    const lines = process.stdout.rows ?? 50;
-    // Create session with first pane
-    const rootPaneId = createDetachedSession(session, dir, { cols, lines });
-    // Set agent teams env var if team config is present
-    if (team) {
-        setSessionEnvironment(session, "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS", "1");
-    }
-    const { paneMap, firstPanesOfRows } = buildPaneMap(rows, dir, rootPaneId, ({ targetPane, direction, cwd, percent }) => splitPane(targetPane, direction, cwd, percent));
-    const { focusPane, paneActions } = collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir);
-    for (const action of paneActions) {
-        if (action.title) {
-            setPaneTitle(action.targetPane, action.title);
-        }
-        if (action.chdir) {
-            sendLiteral(action.targetPane, `cd ${action.chdir}`);
-        }
-        for (const exportCommand of action.exports) {
-            sendLiteral(action.targetPane, exportCommand);
-        }
-        if (action.command) {
-            sendLiteral(action.targetPane, action.command);
-        }
-    }
-    for (const command of buildSessionOptions(session, { theme })) {
-        runSessionCommand(command);
-    }
-    // Store config hash for drift detection on re-launch
-    setSessionVariable(session, "@config_hash", configHash(config));
-    // Start background session monitor (port detection + agent status)
-    const monitorScript = resolve(dirname(fileURLToPath(import.meta.url)), "lib", "session-monitor.js");
-    startSessionMonitor(session, monitorScript);
-    // Focus the correct pane
-    selectPane(focusPane);
-    // Launch summary
-    const totalPanes = rows.reduce((sum, r) => sum + (r.panes?.length ?? 0), 0);
-    console.log(`Starting "${session}" (${rows.length} row${rows.length === 1 ? "" : "s"}, ${totalPanes} pane${totalPanes === 1 ? "" : "s"})...`);
-    // Attach
-    if (attach) {
-        attachSession(session);
-    }
-}

package/dist/lib/dot-path.d.ts

@@ -1,2 +0,0 @@
-export declare function getByPath(obj: Record<string, any>, path: string): unknown;
-export declare function setByPath(obj: Record<string, any>, path: string, value: unknown): void;

package/dist/lib/dot-path.js

@@ -1,17 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function getByPath(obj, path) {
-    return path.split(".").reduce((o, k) => o?.[k], obj);
-}
-export function setByPath(obj, path, value) {
-    const keys = path.split(".");
-    const last = keys.pop();
-    let i = 0;
-    const target = keys.reduce((o, k) => {
-        const nextKey = keys[i + 1] ?? last;
-        if (o[k] === undefined)
-            o[k] = /^\d+$/.test(nextKey) ? [] : {};
-        i++;
-        return o[k];
-    }, obj);
-    target[last] = value;
-}

package/dist/lib/errors.d.ts

@@ -1,29 +0,0 @@
-export declare class IdeError extends Error {
-    code: string | undefined;
-    exitCode: number;
-    constructor(message: string, { code, exitCode, cause }?: {
-        code?: string;
-        exitCode?: number;
-        cause?: Error;
-    });
-    toJSON(): {
-        error: string;
-        code: string | undefined;
-        cause?: string;
-    };
-}
-export declare class ConfigError extends IdeError {
-    constructor(message: string, code: string, { cause }?: {
-        cause?: Error;
-    });
-}
-export declare class TmuxError extends IdeError {
-    constructor(message: string, code: string, { cause }?: {
-        cause?: Error;
-    });
-}
-export declare class SessionError extends IdeError {
-    constructor(message: string, code: string, { cause }?: {
-        cause?: Error;
-    });
-}

package/dist/lib/errors.js

@@ -1,37 +0,0 @@
-export class IdeError extends Error {
-    code;
-    exitCode;
-    constructor(message, { code, exitCode = 1, cause } = {}) {
-        super(message, { cause });
-        this.name = "IdeError";
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-    toJSON() {
-        const obj = {
-            error: this.message,
-            code: this.code,
-        };
-        if (this.cause)
-            obj.cause = this.cause.message;
-        return obj;
-    }
-}
-export class ConfigError extends IdeError {
-    constructor(message, code, { cause } = {}) {
-        super(message, { code, exitCode: 1, cause });
-        this.name = "ConfigError";
-    }
-}
-export class TmuxError extends IdeError {
-    constructor(message, code, { cause } = {}) {
-        super(message, { code, exitCode: 1, cause });
-        this.name = "TmuxError";
-    }
-}
-export class SessionError extends IdeError {
-    constructor(message, code, { cause } = {}) {
-        super(message, { code, exitCode: 1, cause });
-        this.name = "SessionError";
-    }
-}

package/dist/lib/launch-plan.d.ts

@@ -1,6 +0,0 @@
-import type { Pane, Row, PaneAction } from "../types.ts";
-export declare function buildPaneCommand(pane: Pane): string | null;
-export declare function collectPaneStartupPlan(rows: Row[], paneMap: string[][], firstPanesOfRows: Set<string>, dir: string): {
-    focusPane: string;
-    paneActions: PaneAction[];
-};

package/dist/lib/launch-plan.js

@@ -1,40 +0,0 @@
-import { resolve } from "node:path";
-export function buildPaneCommand(pane) {
-    if (!pane.command)
-        return null;
-    return pane.command;
-}
-export function collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir) {
-    let focusPane = paneMap[0][0];
-    const paneActions = [];
-    for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
-        const row = rows[rowIdx];
-        const panes = row.panes ?? [];
-        for (let paneIdx = 0; paneIdx < panes.length; paneIdx++) {
-            const pane = panes[paneIdx];
-            const tmuxPane = paneMap[rowIdx][paneIdx];
-            const action = {
-                targetPane: tmuxPane,
-                title: pane.title ?? null,
-                chdir: null,
-                exports: [],
-                command: null,
-            };
-            if (pane.dir && firstPanesOfRows.has(tmuxPane)) {
-                action.chdir = resolve(dir, pane.dir);
-            }
-            if (pane.env && typeof pane.env === "object") {
-                action.exports = Object.entries(pane.env).map(([key, value]) => `export ${key}=${value}`);
-            }
-            const command = buildPaneCommand(pane);
-            if (command) {
-                action.command = command;
-            }
-            if (pane.focus) {
-                focusPane = tmuxPane;
-            }
-            paneActions.push(action);
-        }
-    }
-    return { focusPane, paneActions };
-}

package/dist/lib/output.d.ts

@@ -1,9 +0,0 @@
-import { IdeError } from "./errors.ts";
-import type { IdeConfig } from "../types.ts";
-export declare function printLayout(config: IdeConfig): void;
-export declare function outputError(message: string, code: string, { exitCode }?: {
-    exitCode?: number;
-}): never;
-export declare function printCommandError(error: IdeError, { json }?: {
-    json?: boolean;
-}): never;

package/dist/lib/output.js

@@ -1,65 +0,0 @@
-import { IdeError } from "./errors.js";
-export function printLayout(config) {
-    const INNER = 40;
-    const rows = config.rows ?? [];
-    if (rows.length === 0)
-        return;
-    for (let r = 0; r < rows.length; r++) {
-        const panes = rows[r].panes ?? [];
-        const count = panes.length || 1;
-        const widths = [];
-        let remaining = INNER;
-        for (let i = 0; i < count; i++) {
-            const w = i < count - 1 ? Math.floor(INNER / count) : remaining;
-            widths.push(w);
-            remaining -= w;
-        }
-        // Top border or mid divider
-        if (r === 0) {
-            let top = "  \u250c";
-            for (let i = 0; i < count; i++) {
-                top += "\u2500".repeat(widths[i]);
-                top += i < count - 1 ? "\u252c" : "\u2510";
-            }
-            console.log(top);
-        }
-        else {
-            console.log("  \u251c" + "\u2500".repeat(INNER + count - 1) + "\u2524");
-        }
-        // Content line
-        const sizeLabel = rows[r].size ?? "";
-        let line = "  \u2502";
-        for (let i = 0; i < count; i++) {
-            const title = panes[i]?.title ?? "";
-            const w = widths[i];
-            const pad = Math.max(0, w - title.length);
-            const left = Math.floor(pad / 2);
-            const right = pad - left;
-            line += " ".repeat(left) + title + " ".repeat(right) + "\u2502";
-        }
-        if (sizeLabel)
-            line += "  " + sizeLabel;
-        console.log(line);
-        // Bottom border (last row only)
-        if (r === rows.length - 1) {
-            let bot = "  \u2514";
-            for (let i = 0; i < count; i++) {
-                bot += "\u2500".repeat(widths[i]);
-                bot += i < count - 1 ? "\u2534" : "\u2518";
-            }
-            console.log(bot);
-        }
-    }
-}
-export function outputError(message, code, { exitCode = 1 } = {}) {
-    throw new IdeError(message, { code, exitCode });
-}
-export function printCommandError(error, { json = false } = {}) {
-    if (json) {
-        console.error(JSON.stringify(error.toJSON(), null, 2));
-    }
-    else {
-        console.error(error.message);
-    }
-    process.exit(error.exitCode ?? 1);
-}

package/dist/lib/session-monitor.d.ts

@@ -1,12 +0,0 @@
-interface MonitorPane {
-    id: string;
-    pid: string;
-    cmd?: string;
-    title?: string;
-}
-export declare function computePortPanes(panes: MonitorPane[], { listeners, tree }?: {
-    listeners?: Set<string>;
-    tree?: Map<string, string>;
-}): Set<string>;
-export declare function computeAgentStates(panes: MonitorPane[]): Map<string, "busy" | "idle" | null>;
-export {};

package/dist/lib/session-monitor.js

@@ -1,160 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { resolve } from "node:path";
-const INTERVAL = 1000;
-const SPINNERS = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⠂⠒⠢⠆⠐⠠⠄◐◓◑◒|/\\-] /;
-// --- Port detection (pure helpers) ---
-function getListeningPids() {
-    // Returns Set of PIDs that have a listening TCP port in range 1024-20000
-    try {
-        const raw = execFileSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-FpPn"], {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        const pids = new Set();
-        let currentPid = null;
-        for (const line of raw.split("\n")) {
-            if (line.startsWith("p")) {
-                currentPid = line.slice(1);
-            }
-            else if (line.startsWith("n") && currentPid) {
-                const match = line.match(/:(\d+)$/);
-                if (match) {
-                    const port = parseInt(match[1], 10);
-                    if (port >= 1024 && port <= 20000)
-                        pids.add(currentPid);
-                }
-            }
-        }
-        return pids;
-    }
-    catch {
-        return new Set();
-    }
-}
-function getProcessTree() {
-    // Returns Map<pid, ppid>
-    try {
-        const raw = execFileSync("ps", ["-axo", "pid=,ppid="], {
-            encoding: "utf-8",
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        const tree = new Map();
-        for (const line of raw.trim().split("\n")) {
-            const parts = line.trim().split(/\s+/);
-            if (parts.length === 2)
-                tree.set(parts[0], parts[1]);
-        }
-        return tree;
-    }
-    catch {
-        return new Map();
-    }
-}
-export function computePortPanes(panes, { listeners, tree } = {}) {
-    // Walk up from each listening PID to find which pane owns it
-    const resolvedListeners = listeners ?? getListeningPids();
-    const resolvedTree = tree ?? getProcessTree();
-    if (resolvedListeners.size === 0)
-        return new Set();
-    const panePids = new Map(panes.map((p) => [p.pid, p.id]));
-    const result = new Set();
-    for (const listenerPid of resolvedListeners) {
-        let pid = listenerPid;
-        while (pid && pid !== "0") {
-            if (panePids.has(pid)) {
-                result.add(panePids.get(pid));
-                break;
-            }
-            pid = resolvedTree.get(pid);
-        }
-    }
-    return result;
-}
-// --- Agent detection ---
-export function computeAgentStates(panes) {
-    // Returns Map<paneId, "busy" | "idle" | null>
-    const states = new Map();
-    for (const pane of panes) {
-        const cmd = (pane.cmd ?? "").toLowerCase();
-        if (!cmd.includes("claude") && !cmd.includes("codex")) {
-            states.set(pane.id, null);
-            continue;
-        }
-        states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
-    }
-    return states;
-}
-// --- Main loop (only runs when executed directly) ---
-const isMainModule = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
-if (isMainModule) {
-    const session = process.argv[2];
-    if (!session)
-        process.exit(1);
-    function tmux(...args) {
-        return execFileSync("tmux", args, { encoding: "utf-8" }).trim();
-    }
-    function tmuxSilent(...args) {
-        try {
-            return tmux(...args);
-        }
-        catch {
-            return "";
-        }
-    }
-    function sessionExists() {
-        try {
-            tmux("has-session", "-t", session);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    function hasClients() {
-        return tmuxSilent("list-clients").length > 0;
-    }
-    function listPanes() {
-        const raw = tmuxSilent("list-panes", "-t", session, "-F", "#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{pane_title}");
-        if (!raw)
-            return [];
-        return raw.split("\n").map((line) => {
-            const [id, pid, cmd, title] = line.split("\t");
-            return { id: id, pid: pid, cmd, title };
-        });
-    }
-    let lastState = "";
-    function tick() {
-        if (!sessionExists())
-            process.exit(0);
-        if (!hasClients())
-            return; // skip when nobody is watching
-        const panes = listPanes();
-        if (panes.length === 0)
-            return;
-        const portPanes = computePortPanes(panes);
-        const agentStates = computeAgentStates(panes);
-        // Build state fingerprint for change detection
-        const stateKey = panes
-            .map((p) => {
-            const port = portPanes.has(p.id) ? "1" : "0";
-            const agent = agentStates.get(p.id) ?? "-";
-            return `${p.id}:${port}:${agent}`;
-        })
-            .join("|");
-        if (stateKey === lastState)
-            return;
-        // Apply changes
-        for (const pane of panes) {
-            const hasPort = portPanes.has(pane.id) ? "1" : "0";
-            const agent = agentStates.get(pane.id);
-            tmuxSilent("set-option", "-pqt", pane.id, "@has_port", hasPort);
-            tmuxSilent("set-option", "-pqt", pane.id, "@agent_busy", agent === "busy" ? "1" : "0");
-            tmuxSilent("set-option", "-pqt", pane.id, "@agent_idle", agent === "idle" ? "1" : "0");
-        }
-        tmuxSilent("refresh-client", "-S");
-        lastState = stateKey;
-    }
-    setInterval(tick, INTERVAL);
-    tick(); // run immediately
-}

package/dist/lib/session-options.d.ts

@@ -1,13 +0,0 @@
-/**
- * Composable builders for tmux session configuration.
- * Each returns an array of tmux command arrays.
- */
-import type { ThemeConfig, TmuxCommand } from "../types.ts";
-export declare function buildSessionOptions(session: string, { theme }?: {
-    theme?: ThemeConfig;
-}): TmuxCommand[];
-export declare function themeOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function borderOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function behaviorOptions(session: string): TmuxCommand[];
-export declare function statusBarOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function keyBindings(): TmuxCommand[];

package/dist/lib/session-options.js

@@ -1,85 +0,0 @@
-/**
- * Composable builders for tmux session configuration.
- * Each returns an array of tmux command arrays.
- */
-export function buildSessionOptions(session, { theme = {} } = {}) {
-    return [
-        ...themeOptions(session, theme),
-        ...borderOptions(session, theme),
-        ...behaviorOptions(session),
-        ...statusBarOptions(session, theme),
-        ...keyBindings(),
-    ];
-}
-export function themeOptions(session, theme) {
-    const accent = theme.accent ?? "colour75";
-    const border = theme.border ?? "colour238";
-    const bg = theme.bg ?? "colour235";
-    const fg = theme.fg ?? "colour248";
-    return [
-        ["set-option", "-t", session, "status-style", `bg=${bg},fg=${fg}`],
-        ["set-option", "-t", session, "pane-border-style", `fg=${border}`],
-        ["set-option", "-t", session, "pane-active-border-style", `fg=${accent}`],
-    ];
-}
-export function borderOptions(session, theme) {
-    const accent = theme.accent ?? "colour75";
-    const border = theme.border ?? "colour238";
-    const fg = theme.fg ?? "colour248";
-    return [
-        ["set-option", "-t", session, "pane-border-status", "top"],
-        [
-            "set-option",
-            "-t",
-            session,
-            "pane-border-format",
-            ` #{?pane_active,#[fg=${accent}#,bold]▸ #T  #[fg=${fg}]#{pane_current_path},#[fg=${border}]· #T  #{pane_current_path}} `,
-        ],
-    ];
-}
-export function behaviorOptions(session) {
-    return [
-        ["set-option", "-t", session, "mouse", "on"],
-        ["set-option", "-t", session, "escape-time", "0"],
-        ["set-option", "-t", session, "status-interval", "1"],
-    ];
-}
-export function statusBarOptions(session, theme) {
-    const accent = theme.accent ?? "colour75";
-    const border = theme.border ?? "colour238";
-    const fg = theme.fg ?? "colour248";
-    // Pane tab components — each is a self-contained piece
-    const agentIndicator = [
-        `#{?#{==:#{@agent_busy},1},#[fg=${accent}]⏺ ,`,
-        `#{?#{==:#{@agent_idle},1},#[fg=${border}]● ,}}`,
-    ].join("");
-    const portIndicator = `#{?#{==:#{@has_port},1},#[fg=green]⏺ ,}`;
-    const paneStyle = `#{?pane_active,#[fg=${accent}],#[fg=${border}]}`;
-    const paneTab = `${agentIndicator}${portIndicator}${paneStyle}#[range=pane|#{pane_id}] #T #[norange]#[default]`;
-    const separator = `#{?loop_last_flag,,#[fg=${border}]│}`;
-    return [
-        [
-            "set-option",
-            "-t",
-            session,
-            "status-left",
-            `#[fg=colour0,bg=${accent},bold]  ${session.toUpperCase()} IDE #[default] `,
-        ],
-        ["set-option", "-t", session, "status-left-length", "30"],
-        [
-            "set-option",
-            "-t",
-            session,
-            "status-right",
-            `#[fg=colour243]%H:%M #[fg=${accent}]│ #[fg=${fg}]%b %d `,
-        ],
-        ["set-option", "-t", session, "status-justify", "centre"],
-        ["set-option", "-t", session, "window-status-current-format", `#[fg=${accent},bold]●`],
-        ["set-option", "-t", session, "window-status-format", `#[fg=${border}]○`],
-        ["set-option", "-t", session, "status", "2"],
-        ["set-option", "-t", session, "status-format[1]", `  #{P:${paneTab}${separator}}`],
-    ];
-}
-export function keyBindings() {
-    return [["bind-key", "-n", "MouseDown1StatusDefault", "select-pane", "-t", "="]];
-}

package/dist/lib/sizes.d.ts

@@ -1,16 +0,0 @@
-/**
- * Compute absolute sizes for items where some have explicit sizes and others don't.
- * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
- * among items without a size.
- */
-export declare function computeSizes(items: {
-    size?: string;
-}[]): number[];
-/**
- * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
- * Returns array of -p values (one per split after the first item).
- *
- * Each tmux split divides the current pane. The percentage given to -p is
- * the portion allocated to the NEW (bottom/right) pane.
- */
-export declare function toSplitPercents(sizes: number[]): number[];