@zswarm/core 0.1.0

package/dist/zellij/bus.js

@@ -0,0 +1,279 @@
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expandHomePath } from "./binary.js";
+/**
+ * The event-bus side of zswarm: Zellij pushes pane and tab state into a WASM
+ * plugin as it changes, and one CLI pipe reads it back out of memory. Parsing
+ * and path resolution live here; the process calls live in the client, and the
+ * fallback policy lives in `ops/bus.ts`.
+ */
+export const BUS_PIPE_NAME = "zswarm";
+export const DEFAULT_BUS_KEY = "zswarm-bus";
+/** A stalled instance answers nothing, so the pipe must not inherit the long timeout. */
+export const DEFAULT_BUS_TIMEOUT_MS = 2_500;
+/**
+ * Where a published zswarm keeps the compiled plugin, relative to the tree root.
+ *
+ * The version suffix is load-bearing. Zellij caches a permission decision per
+ * plugin URL and will not re-prompt when a build asks for more than the
+ * approved set — it denies the new one silently. A build that gains a
+ * permission has to ship under a new name; `-v2` is the ReadPaneContents one.
+ */
+const PREBUILT_WASM = "zswarm-bus-v3.wasm";
+const PREBUILT_RELATIVE = join("packages", "wasm", PREBUILT_WASM);
+const WAIT_REASONS = ["match", "idle", "timeout", "gone"];
+function jsonLines(stdout) {
+    const out = [];
+    for (const line of stdout.split("\n")) {
+        const text = line.trim();
+        if (!text.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed && typeof parsed === "object") {
+                out.push(parsed);
+            }
+        }
+        catch {
+            // Zellij's own notices share the stream; skip anything that is not ours.
+        }
+    }
+    return out;
+}
+function screenOf(value) {
+    if (!Array.isArray(value))
+        return "";
+    return value.filter((l) => typeof l === "string").join("\n");
+}
+/** A held wait answers once, late. Same scan as every other bus reply. */
+export function parseWaitReply(stdout) {
+    for (const value of jsonLines(stdout)) {
+        if (value.ok !== true)
+            continue;
+        const reason = value.reason;
+        if (typeof reason !== "string")
+            continue;
+        if (!WAIT_REASONS.includes(reason))
+            continue;
+        return {
+            reason: reason,
+            pane: typeof value.pane === "string" ? value.pane : "",
+            screen: screenOf(value.viewport),
+        };
+    }
+    return null;
+}
+export function parseChangedReply(stdout) {
+    for (const value of jsonLines(stdout)) {
+        if (value.ok !== true || !Array.isArray(value.panes))
+            continue;
+        const panes = [];
+        for (const row of value.panes) {
+            if (!row || typeof row !== "object")
+                continue;
+            const p = row;
+            if (typeof p.id !== "string")
+                continue;
+            panes.push({
+                id: p.id,
+                screen: screenOf(p.viewport),
+                changed: p.changed === true,
+                first: p.first === true,
+            });
+        }
+        return {
+            ready: value.ready === true,
+            panes,
+            missing: Array.isArray(value.missing)
+                ? value.missing.filter((m) => typeof m === "string")
+                : [],
+        };
+    }
+    return null;
+}
+/**
+ * The plugin ships as its own package so it can version independently: Zellij
+ * caches permission grants per URL, so a build asking for a new permission has
+ * to arrive under a new filename. Resolving by name works wherever the package
+ * manager put it; the walk-up is the fallback for a checkout with nothing
+ * installed yet.
+ */
+function resolvePluginPackage() {
+    try {
+        return createRequire(import.meta.url).resolve(`@zswarm/wasm/${PREBUILT_WASM}`);
+    }
+    catch {
+        return null;
+    }
+}
+/** Absolute path of the plugin wasm, or null when there is nothing to load. */
+export function resolveBusPlugin(env = process.env) {
+    const explicit = expandHomePath((env.ZSWARM_BUS_PLUGIN ?? "").trim().replace(/^['"]|['"]$/g, ""), env);
+    if (explicit)
+        return existsSync(explicit) ? resolve(explicit) : null;
+    const installed = resolvePluginPackage();
+    if (installed && existsSync(installed))
+        return installed;
+    // Walk up from this module so a checkout works before anything is installed.
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 8; depth++) {
+        const candidate = join(dir, PREBUILT_RELATIVE);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Zellij wants a `file:` url with forward slashes, including on Windows. */
+export function busPluginUrl(pluginPath) {
+    return `file:${resolve(pluginPath).replace(/\\/g, "/")}`;
+}
+/** zswarm-bus → zswarm-bus-2 → zswarm-bus-3: a fresh pipe destination each time. */
+export function nextConfigKey(key) {
+    const match = /^(.*)-(\d+)$/.exec(key);
+    if (!match)
+        return `${key}-2`;
+    return `${match[1]}-${Number(match[2]) + 1}`;
+}
+function toSnapshot(value) {
+    if (value.ok !== true || !Array.isArray(value.panes))
+        return null;
+    const panes = [];
+    for (const row of value.panes) {
+        if (!row || typeof row !== "object")
+            continue;
+        const p = row;
+        if (typeof p.id !== "string")
+            continue;
+        panes.push({
+            id: p.id,
+            title: typeof p.title === "string" ? p.title : "",
+            exited: p.exited === true,
+            focused: p.focused === true,
+            command: typeof p.command === "string" ? p.command : null,
+            tab: typeof p.tab === "number" ? p.tab : 0,
+        });
+    }
+    return {
+        ready: value.ready === true,
+        paneUpdates: typeof value.paneUpdates === "number" ? value.paneUpdates : 0,
+        tabUpdates: typeof value.tabUpdates === "number" ? value.tabUpdates : 0,
+        tabs: Array.isArray(value.tabs)
+            ? value.tabs.filter((t) => typeof t === "string")
+            : [],
+        panes,
+    };
+}
+/**
+ * Pull the plugin's answer out of the pipe. Zellij interleaves its own notices
+ * ("Action CliPipe did not complete within 1s timeout" shows up on successful
+ * runs too), so scan for the first line that is our JSON rather than parsing
+ * the whole of stdout.
+ */
+export function parseBusReply(stdout) {
+    for (const line of stdout.split("\n")) {
+        const text = line.trim();
+        if (!text.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (parsed && typeof parsed === "object") {
+            const snapshot = toSnapshot(parsed);
+            if (snapshot)
+                return snapshot;
+        }
+    }
+    return null;
+}
+function stringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function toScrollback(value) {
+    if (value.ok !== true || !Array.isArray(value.panes))
+        return null;
+    const panes = [];
+    for (const row of value.panes) {
+        if (!row || typeof row !== "object")
+            continue;
+        const p = row;
+        if (typeof p.id !== "string")
+            continue;
+        panes.push({
+            id: p.id,
+            viewport: stringList(p.viewport),
+            above: stringList(p.above),
+            below: stringList(p.below),
+        });
+    }
+    return {
+        ready: value.ready === true,
+        panes,
+        missing: stringList(value.missing),
+    };
+}
+/**
+ * Same scan as parseBusReply: Zellij prints "Action CliPipe did not complete
+ * within 1s timeout" on successful pipes, so the JSON is never the whole of
+ * stdout. First line with ok===true and a panes array wins; anything else is
+ * no reply and the caller falls back.
+ */
+export function parseScrollbackReply(stdout) {
+    for (const line of stdout.split("\n")) {
+        const text = line.trim();
+        if (!text.startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (parsed && typeof parsed === "object") {
+            const reply = toScrollback(parsed);
+            if (reply)
+                return reply;
+        }
+    }
+    return null;
+}
+/** Rebuild dump-screen-shaped text. Byte-identity with dump-screen is unproven. */
+export function scrollbackToScreen(pane) {
+    return pane.above.concat(pane.viewport).concat(pane.below).join("\n");
+}
+/**
+ * Shape the snapshot like `list-panes` output. `cwd` and `floating` are not in
+ * the manifest Zellij pushes, so they read as unknown here — callers that need
+ * them (anything verbose) must take the polling path instead.
+ */
+export function busToPanes(snapshot) {
+    return snapshot.panes.map((pane) => {
+        const isPlugin = pane.id.startsWith("plugin_");
+        const numeric = Number(pane.id.slice(pane.id.indexOf("_") + 1));
+        return {
+            id: pane.id,
+            numericId: Number.isFinite(numeric) ? numeric : -1,
+            isPlugin,
+            title: pane.title,
+            command: pane.command,
+            cwd: null,
+            tabName: snapshot.tabs[pane.tab] ?? null,
+            tabId: pane.tab,
+            focused: pane.focused,
+            exited: pane.exited,
+            floating: false,
+        };
+    });
+}

package/dist/zellij/client.d.ts

@@ -0,0 +1,162 @@
+import { buildClosePaneArgs, buildDumpArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, type WaitRequest, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PipeInput } from "./args.js";
+import { resolveTab, type ZellijTab } from "./tabs.js";
+import { type ZellijExecFn } from "./binary.js";
+import { normalizePaneId, resolvePane, type ZellijPane } from "./panes.js";
+import { type ZellijSessionResolve } from "./session.js";
+export type ZellijClientOptions = {
+    exec?: ZellijExecFn;
+    zellijPath?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+};
+/** Thin, stateless wrapper over the `zellij` binary. */
+export declare function createZellijClient(options?: ZellijClientOptions): {
+    zellijPath: string;
+    selfPaneId: string | null;
+    /** A `file:` plugin url only names a path on the machine running Zellij. */
+    remote: boolean;
+    listSessions: () => Promise<string[]>;
+    resolveSession: (explicit?: string | null) => Promise<ZellijSessionResolve>;
+    listPanes: (session: string) => Promise<ZellijPane[]>;
+    resolvePane: typeof resolvePane;
+    injectPane: (input: {
+        session: string;
+        paneId: string;
+        text: string;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+    }>;
+    dumpPane: (input: {
+        session: string;
+        paneId: string;
+        full?: boolean;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+        text: string;
+    }>;
+    sendKeys: (input: {
+        session: string;
+        paneId: string;
+        keys: string[];
+    }) => Promise<{
+        paneId: string;
+        session: string;
+        keys: string[];
+    }>;
+    writeChars: (input: {
+        session: string;
+        paneId: string;
+        chars: string;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+    }>;
+    closePane: (input: {
+        session: string;
+        paneId: string;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+    }>;
+    newPane: (input: NewPaneInput) => Promise<{
+        session: string;
+        paneId: string | null;
+        stdout: string;
+    }>;
+    newTab: (input: NewTabInput) => Promise<{
+        session: string;
+        tabId: number | null;
+        stdout: string;
+    }>;
+    renamePane: (input: {
+        session: string;
+        paneId: string;
+        name: string;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+        name: string;
+    }>;
+    renameTab: (input: {
+        session: string;
+        tabId: number;
+        name: string;
+    }) => Promise<{
+        tabId: number;
+        session: string;
+        name: string;
+    }>;
+    focusPane: (input: {
+        session: string;
+        paneId: string;
+    }) => Promise<{
+        paneId: string;
+        session: string;
+    }>;
+    listTabs: (session: string) => Promise<ZellijTab[]>;
+    dumpLayout: (session: string) => Promise<string>;
+    stackPanes: (input: {
+        session: string;
+        paneIds: string[];
+    }) => Promise<{
+        session: string;
+        paneIds: string[];
+    }>;
+    pipePlugin: (input: PipeInput & {
+        timeoutMs?: number;
+    }) => Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    scrollbackPlugin: (input: {
+        session: string;
+        url: string;
+        configKey: string;
+        panes: string[];
+        full?: boolean;
+        timeoutMs?: number;
+    }) => Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    waitPlugin: (input: {
+        session: string;
+        url: string;
+        configKey: string;
+    } & WaitRequest) => Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    changedPlugin: (input: {
+        session: string;
+        url: string;
+        configKey: string;
+        panes: string[];
+    }) => Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    launchPlugin: (input: LaunchPluginInput) => Promise<{
+        session: string;
+        paneId: string | null;
+    }>;
+    resolveTab: typeof resolveTab;
+    normalizePaneId: typeof normalizePaneId;
+    formatPeerMessage: (from: string, body: string) => string;
+    buildListPanesArgs: typeof buildListPanesArgs;
+    buildPasteArgs: typeof buildPasteArgs;
+    buildSendEnterArgs: typeof buildSendEnterArgs;
+    buildDumpArgs: typeof buildDumpArgs;
+    buildSendKeysArgs: typeof buildSendKeysArgs;
+    buildWriteCharsArgs: typeof buildWriteCharsArgs;
+    buildClosePaneArgs: typeof buildClosePaneArgs;
+    buildNewPaneArgs: typeof buildNewPaneArgs;
+    buildNewTabArgs: typeof buildNewTabArgs;
+};
+export type ZellijClient = ReturnType<typeof createZellijClient>;

package/dist/zellij/client.js

@@ -0,0 +1,246 @@
+import { ZellijError } from "../errors.js";
+import { buildClosePaneArgs, buildDumpArgs, buildDumpLayoutArgs, buildFocusPaneArgs, buildLaunchPluginArgs, buildListPanesArgs, buildListTabsArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildRenamePaneArgs, buildRenameTabArgs, buildSendEnterArgs, buildSendKeysArgs, buildStackPanesArgs, buildWriteCharsArgs, changedPayload, scrollbackPayload, waitPayload, } from "./args.js";
+import { DEFAULT_BUS_TIMEOUT_MS, parseBusReply, parseChangedReply, parseScrollbackReply, parseWaitReply, } from "./bus.js";
+import { parseTabList, resolveTab } from "./tabs.js";
+import { createSshExec } from "../exec.js";
+import { DEFAULT_TIMEOUT_MS, NOT_FOUND_EXIT, defaultExec, resolveSshTarget, resolveZellijBinary, sanitizeZellijEnv, } from "./binary.js";
+import { normalizePaneId, parsePaneList, resolvePane, } from "./panes.js";
+import { parseSessionList, resolveSelfPaneId, sessionFromEnv, sessionFromList, } from "./session.js";
+/** Thin, stateless wrapper over the `zellij` binary. */
+export function createZellijClient(options = {}) {
+    const env = options.env ?? process.env;
+    // A remote crew never resolves a local binary.
+    const ssh = options.exec ? null : resolveSshTarget(env);
+    const zellijPath = options.zellijPath ??
+        (ssh ? `ssh://${ssh.host}/${ssh.remoteBin}` : resolveZellijBinary(env));
+    const exec = options.exec ??
+        (ssh
+            ? createSshExec(ssh, sanitizeZellijEnv(env))
+            : defaultExec(zellijPath, env));
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const selfPaneId = resolveSelfPaneId(env);
+    async function run(args, label) {
+        const result = await exec(args, { timeoutMs });
+        if (result.code === NOT_FOUND_EXIT) {
+            throw new ZellijError("zellij_missing", `zellij binary not found (${zellijPath}); install Zellij ≥ 0.42, add it to PATH, or set ZSWARM_BIN / ZSWARM_PATH`);
+        }
+        if (result.code !== 0) {
+            throw new ZellijError("zellij_failed", `${label} failed (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim() || "no output"}`);
+        }
+        return result;
+    }
+    async function listSessions() {
+        const result = await run(["list-sessions", "--short", "--no-formatting"], "zellij list-sessions");
+        return parseSessionList(result.stdout);
+    }
+    async function resolveSession(explicit) {
+        return sessionFromEnv(env, explicit) ?? sessionFromList(await listSessions());
+    }
+    async function listPanes(session) {
+        const result = await run(buildListPanesArgs(session), "zellij action list-panes");
+        return parsePaneList(result.stdout);
+    }
+    async function injectPane(input) {
+        const paneId = normalizePaneId(input.paneId);
+        if (!input.text) {
+            throw new ZellijError("missing_body", "inject text required");
+        }
+        await run(buildPasteArgs(input.session, paneId, input.text), "zellij action paste");
+        await run(buildSendEnterArgs(input.session, paneId), "zellij action send-keys");
+        return { paneId, session: input.session };
+    }
+    async function dumpPane(input) {
+        const paneId = normalizePaneId(input.paneId);
+        const result = await run(buildDumpArgs(input.session, paneId, input.full), "zellij action dump-screen");
+        return { paneId, session: input.session, text: result.stdout };
+    }
+    async function sendKeys(input) {
+        const paneId = normalizePaneId(input.paneId);
+        if (input.keys.length === 0) {
+            throw new ZellijError("bad_key", "no keys given");
+        }
+        await run(buildSendKeysArgs(input.session, paneId, input.keys), "zellij action send-keys");
+        return { paneId, session: input.session, keys: input.keys };
+    }
+    async function writeChars(input) {
+        const paneId = normalizePaneId(input.paneId);
+        if (!input.chars) {
+            throw new ZellijError("missing_body", "chars required");
+        }
+        await run(buildWriteCharsArgs(input.session, paneId, input.chars), "zellij action write-chars");
+        return { paneId, session: input.session };
+    }
+    async function renamePane(input) {
+        const paneId = normalizePaneId(input.paneId);
+        if (!input.name.trim()) {
+            throw new ZellijError("missing_name", "name required");
+        }
+        await run(buildRenamePaneArgs(input.session, paneId, input.name), "zellij action rename-pane");
+        return { paneId, session: input.session, name: input.name };
+    }
+    async function renameTab(input) {
+        if (!input.name.trim()) {
+            throw new ZellijError("missing_name", "name required");
+        }
+        await run(buildRenameTabArgs(input.session, input.tabId, input.name), "zellij action rename-tab-by-id");
+        return { tabId: input.tabId, session: input.session, name: input.name };
+    }
+    async function focusPane(input) {
+        const paneId = normalizePaneId(input.paneId);
+        await run(buildFocusPaneArgs(input.session, paneId), "zellij action focus-pane-id");
+        return { paneId, session: input.session };
+    }
+    async function listTabs(session) {
+        const result = await run(buildListTabsArgs(session), "zellij action list-tabs");
+        return parseTabList(result.stdout);
+    }
+    async function dumpLayout(session) {
+        const result = await run(buildDumpLayoutArgs(session), "zellij action dump-layout");
+        return result.stdout;
+    }
+    async function stackPanes(input) {
+        if (input.paneIds.length < 2) {
+            throw new ZellijError("bad_arg", "stack needs at least two panes");
+        }
+        await run(buildStackPanesArgs(input.session, input.paneIds), "zellij action stack-panes");
+        return {
+            session: input.session,
+            paneIds: input.paneIds.map((id) => normalizePaneId(id)),
+        };
+    }
+    async function closePane(input) {
+        const paneId = normalizePaneId(input.paneId);
+        await run(buildClosePaneArgs(input.session, paneId), "zellij action close-pane");
+        return { paneId, session: input.session };
+    }
+    /** `new-pane` prints the created pane id; `new-tab` prints a tab id instead. */
+    function parseCreatedPaneId(stdout) {
+        const match = /(terminal|plugin)_\d+/i.exec(stdout);
+        return match ? match[0].toLowerCase() : null;
+    }
+    async function newPane(input) {
+        const result = await run(buildNewPaneArgs(input), "zellij action new-pane");
+        return {
+            session: input.session,
+            paneId: parseCreatedPaneId(result.stdout),
+            stdout: result.stdout.trim(),
+        };
+    }
+    async function newTab(input) {
+        const result = await run(buildNewTabArgs(input), "zellij action new-tab");
+        const digits = /-?\d+/.exec(result.stdout);
+        return {
+            session: input.session,
+            tabId: digits ? Number(digits[0]) : null,
+            stdout: result.stdout.trim(),
+        };
+    }
+    /**
+     * Ask the event-bus plugin, without the usual failure handling: a missing or
+     * unresponsive plugin is an expected outcome the caller falls back from, not
+     * an error worth raising.
+     */
+    async function pipePlugin(input) {
+        return exec(buildPipeArgs(input), {
+            timeoutMs: input.timeoutMs ?? DEFAULT_BUS_TIMEOUT_MS,
+            // The answer is what we want; the process outliving it is not our problem.
+            until: (stdout) => parseBusReply(stdout) !== null,
+        });
+    }
+    /**
+     * Multi-pane scrollback over the same pipe. Missing/unresponsive plugin is a
+     * value, not a throw — same fallback contract as pipePlugin. Wait on the JSON
+     * reply, not process exit: zellij pipe answers in ~40ms but stays resident
+     * when it has no terminal.
+     */
+    async function scrollbackPlugin(input) {
+        return exec(buildPipeArgs({
+            session: input.session,
+            url: input.url,
+            configKey: input.configKey,
+            payload: scrollbackPayload({ panes: input.panes, full: input.full }),
+        }), {
+            timeoutMs: input.timeoutMs ?? DEFAULT_BUS_TIMEOUT_MS,
+            until: (stdout) => parseScrollbackReply(stdout) !== null,
+        });
+    }
+    /**
+     * A wait the plugin holds open. The transport timeout has to outlast the
+     * caller's own, or the pipe dies before the wait it is carrying.
+     */
+    async function waitPlugin(input) {
+        const budget = (input.timeoutMs ?? 60_000) + DEFAULT_BUS_TIMEOUT_MS;
+        return exec(buildPipeArgs({
+            session: input.session,
+            url: input.url,
+            configKey: input.configKey,
+            payload: waitPayload(input),
+        }), {
+            timeoutMs: budget,
+            until: (stdout) => parseWaitReply(stdout) !== null,
+        });
+    }
+    async function changedPlugin(input) {
+        return exec(buildPipeArgs({
+            session: input.session,
+            url: input.url,
+            configKey: input.configKey,
+            payload: changedPayload(input.panes),
+        }), {
+            timeoutMs: DEFAULT_BUS_TIMEOUT_MS,
+            until: (stdout) => parseChangedReply(stdout) !== null,
+        });
+    }
+    async function launchPlugin(input) {
+        const result = await run(buildLaunchPluginArgs(input), "zellij action launch-or-focus-plugin");
+        return {
+            session: input.session,
+            paneId: parseCreatedPaneId(result.stdout),
+        };
+    }
+    /** Visible prefix so peer CLIs can tell zSwarm injects from human prompts. */
+    function formatPeerMessage(from, body) {
+        const sender = from.trim() || "swarm";
+        return `[zswarm from=${sender}]\n${body.trim()}`;
+    }
+    return {
+        zellijPath,
+        selfPaneId,
+        /** A `file:` plugin url only names a path on the machine running Zellij. */
+        remote: ssh !== null,
+        listSessions,
+        resolveSession,
+        listPanes,
+        resolvePane,
+        injectPane,
+        dumpPane,
+        sendKeys,
+        writeChars,
+        closePane,
+        newPane,
+        newTab,
+        renamePane,
+        renameTab,
+        focusPane,
+        listTabs,
+        dumpLayout,
+        stackPanes,
+        pipePlugin,
+        scrollbackPlugin,
+        waitPlugin,
+        changedPlugin,
+        launchPlugin,
+        resolveTab,
+        normalizePaneId,
+        formatPeerMessage,
+        buildListPanesArgs,
+        buildPasteArgs,
+        buildSendEnterArgs,
+        buildDumpArgs,
+        buildSendKeysArgs,
+        buildWriteCharsArgs,
+        buildClosePaneArgs,
+        buildNewPaneArgs,
+        buildNewTabArgs,
+    };
+}