@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/with-panes-MKB46MPQ.js

@@ -0,0 +1,782 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createMuxDomainModule,
+  createYaziSession,
+  ensureYaziProfile,
+  resolveYaziBinaries,
+  watchViewerCommand,
+  yaziProfileDir
+} from "./chunk-HZHHCK24.js";
+import {
+  paneWatchDecision
+} from "./chunk-PMZCIOCJ.js";
+import {
+  PANES_PRESETS
+} from "./chunk-YJX4SHTD.js";
+import "./chunk-LCGCVYZ4.js";
+import {
+  newestRunEventJournalRunId,
+  runEventJournalPath,
+  runEventJournalRoot
+} from "./chunk-IQ7KR472.js";
+import {
+  resolveBinary
+} from "./chunk-BMS5RKQY.js";
+import "./chunk-QSNYB6ZV.js";
+import "./chunk-QDC3K2U3.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-TVHHYFHE.js";
+import {
+  BusChannels
+} from "./chunk-HLW2MRKE.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  clioCacheDir,
+  clioConfigDir,
+  clioDataDir,
+  clioStateDir
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/entry/with-panes.ts
+init_esm_shims();
+
+// src/interactive/mux-bridge.ts
+init_esm_shims();
+var MUX_BRIDGE_THROTTLE_MS = 250;
+var LONG_RUN_MS = 6e4;
+var DETAIL_MAX_CHARS = 96;
+function isFailure(outcome) {
+  return outcome === "failed" || outcome === "timed_out";
+}
+function selfStateFor(phase) {
+  if (phase === "tool_blocked") return "blocked";
+  return phase === "idle" || phase === "ended" ? "idle" : "working";
+}
+function terminalOutcome(outcome) {
+  if (outcome === "succeeded") return "succeeded";
+  if (outcome === "canceled") return "canceled";
+  if (outcome === "timed_out") return "timed_out";
+  return "failed";
+}
+function createMuxBridge(deps) {
+  const log = deps.log ?? (() => void 0);
+  const now = deps.now ?? Date.now;
+  const throttleMs = deps.throttleMs ?? MUX_BRIDGE_THROTTLE_MS;
+  const setTimeoutFn = deps.setTimeoutFn ?? setTimeout;
+  const clearTimeoutFn = deps.clearTimeoutFn ?? clearTimeout;
+  const startedAt = /* @__PURE__ */ new Map();
+  let disposed = false;
+  let timer = null;
+  let draining = Promise.resolve();
+  let pendingSelf = null;
+  let reportedSelf = null;
+  const schedule = () => {
+    if (disposed || timer !== null) return;
+    timer = setTimeoutFn(() => {
+      timer = null;
+      void drainSelf();
+    }, throttleMs);
+    timer.unref?.();
+  };
+  const drainSelf = () => {
+    draining = draining.then(async () => {
+      if (disposed) return;
+      const self = pendingSelf;
+      pendingSelf = null;
+      if (self !== null && self !== reportedSelf) {
+        reportedSelf = self;
+        await deps.mux.reportSelf({ state: self }).catch(() => false);
+      }
+    });
+    return draining;
+  };
+  const boundedDetail = (value) => {
+    if (typeof value !== "string" || value.length === 0) return null;
+    return sanitizeCallTargetText(value).slice(0, DETAIL_MAX_CHARS);
+  };
+  const onTerminal = (identity, rawOutcome, fields) => {
+    const outcome = terminalOutcome(rawOutcome);
+    const begun = startedAt.get(identity.runId);
+    startedAt.delete(identity.runId);
+    const policy = deps.notificationsPolicy();
+    const failed = isFailure(outcome);
+    const qualifies = policy === "all" || policy === "failures" && failed;
+    if (!qualifies) return;
+    const detail = boundedDetail(fields.detail);
+    const durationMs = typeof fields.durationMs === "number" ? fields.durationMs : begun === void 0 ? null : now() - begun;
+    if (failed) {
+      deps.notice?.("error", `${identity.agentId} ${outcome} (${identity.runId})${detail ? `: ${detail}` : ""}`);
+    }
+    if (!deps.mux.available()) return;
+    draining = draining.then(async () => {
+      if (disposed) return;
+      try {
+        await deps.mux.notify({
+          title: `${identity.agentId} ${outcome}`,
+          ...detail ? { body: detail } : {},
+          // A failure interrupts; a long success announces. A short success
+          // in `all` mode gets the toast without the chime.
+          sound: failed ? "request" : durationMs !== null && durationMs >= LONG_RUN_MS ? "done" : "none"
+        });
+      } catch (error) {
+        log("debug", `mux bridge notify failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    });
+  };
+  const unsubscribers = [
+    deps.bus.on(BusChannels.DispatchStarted, (payload) => {
+      startedAt.set(payload.runId, now());
+    }),
+    deps.bus.on(BusChannels.DispatchCompleted, (payload) => {
+      onTerminal(payload, payload.outcome, { durationMs: payload.durationMs, detail: payload.outcomeDetail });
+    }),
+    deps.bus.on(BusChannels.DispatchFailed, (payload) => {
+      onTerminal(payload, payload.reason, { durationMs: payload.durationMs, detail: payload.outcomeDetail });
+    }),
+    // SA-3. The interactive status machine is the one surface that already
+    // knows when a turn starts, when it ends, and when a tool call is parked
+    // on an approval, so the self-report rides its transitions rather than
+    // growing a second turn-lifecycle listener.
+    deps.bus.on(BusChannels.AgentStatusChanged, (payload) => {
+      const state = selfStateFor(payload.phase);
+      if (state === reportedSelf && pendingSelf === null) return;
+      pendingSelf = state;
+      schedule();
+    })
+  ];
+  return {
+    flush() {
+      if (timer !== null) {
+        clearTimeoutFn(timer);
+        timer = null;
+      }
+      return drainSelf();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (timer !== null) clearTimeoutFn(timer);
+      timer = null;
+      for (const unsubscribe of unsubscribers) unsubscribe();
+      startedAt.clear();
+    }
+  };
+}
+
+// src/interactive/panes-runtime.ts
+init_esm_shims();
+var UNAVAILABLE = "the pane layer is not available in this session";
+function inventory(records) {
+  return records.map((record) => ({
+    paneId: record.ref.paneId,
+    tabId: record.ref.tabId,
+    purpose: record.purpose,
+    label: record.label,
+    adopted: record.adopted === true
+  }));
+}
+function createPanesRuntime(deps) {
+  const probe = deps.resolveBinaryPath ?? resolveBinary;
+  const journalRoot = deps.journalRoot ?? runEventJournalRoot;
+  let yaziController = null;
+  let watchController = null;
+  let nextPendingOpen = 0;
+  const pendingOpens = /* @__PURE__ */ new Map();
+  const beginPendingOpen = (label) => {
+    nextPendingOpen += 1;
+    const id = `pending:${nextPendingOpen}`;
+    pendingOpens.set(id, {
+      paneId: id,
+      tabId: "pending",
+      purpose: "utility",
+      label,
+      adopted: false,
+      pending: true
+    });
+    return id;
+  };
+  const closedYaziStatus = () => ({
+    mode: "closed",
+    paneId: null,
+    paneCwd: null,
+    lastLineAt: null,
+    droppedLines: 0
+  });
+  const matchRun = (target) => {
+    const needle = target.trim().toLowerCase();
+    if (needle.length === 0) return null;
+    const snapshot = deps.getDispatchSnapshot();
+    const live = [
+      ...snapshot.running.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "running" })),
+      ...snapshot.retrying.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "retrying" }))
+    ];
+    const newestFirst = [...live].reverse();
+    const byAgent = newestFirst.find((run) => run.agentId.toLowerCase().includes(needle));
+    if (byAgent) return byAgent;
+    return newestFirst.find((run) => run.runId.toLowerCase().startsWith(needle)) ?? null;
+  };
+  const presetArgv = (presetId, binaryPath) => {
+    if (presetId === "shell") return [binaryPath, "-l"];
+    if (presetId === "logs") {
+      const runId = (deps.newestJournalRunId ?? (() => newestRunEventJournalRunId(journalRoot())))();
+      if (runId === null) return null;
+      return [binaryPath, "-n", "200", "-F", runEventJournalPath(runId, journalRoot())];
+    }
+    return null;
+  };
+  const show = async (target, source) => {
+    if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+    const match = matchRun(target);
+    if (match === null) {
+      const snapshot = deps.getDispatchSnapshot();
+      const candidates = [
+        .../* @__PURE__ */ new Set([...snapshot.running.map((run) => run.agentId), ...snapshot.retrying.map((run) => run.agentId)])
+      ];
+      return { status: "not-found", target, candidates };
+    }
+    const decision = paneWatchDecision({ source, runStatus: match.status });
+    if (!decision.open) return { status: "refused", reason: decision.reason };
+    if (watchController === null) {
+      return { status: "unavailable", reason: "the watch pane is not wired in this session" };
+    }
+    const watched = await watchController.watch(match.runId);
+    if (watched.status !== "watching") return { status: "unavailable", reason: watched.reason };
+    return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
+  };
+  return {
+    status() {
+      const detection = deps.mux.detection();
+      const panes = deps.getSettings().panes;
+      return {
+        mode: deps.mux.mode,
+        available: deps.mux.available(),
+        reason: detection.reason,
+        socketPath: detection.socketPath,
+        server: detection.server,
+        settings: {
+          enabled: panes.enabled,
+          notifications: panes.notifications,
+          journal: panes.journal,
+          yazi: { ...panes.yazi }
+        },
+        yazi: yaziController?.status() ?? closedYaziStatus(),
+        panes: [...inventory(deps.mux.list()), ...pendingOpens.values()]
+      };
+    },
+    show(target) {
+      return show(target, "slash");
+    },
+    async open(request) {
+      const cwd = deps.getCwd();
+      if (request.preset !== void 0) {
+        const preset = PANES_PRESETS.find((entry) => entry.id === request.preset);
+        if (!preset) {
+          return { status: "refused", reason: `unknown preset: ${request.preset}` };
+        }
+        if (preset.id === "yazi") {
+          if (!deps.getSettings().panes.yazi.enabled) {
+            return { status: "refused", reason: "the files pane is disabled by panes.yazi.enabled" };
+          }
+          if (!yaziController) {
+            return { status: "unavailable", reason: "the files-pane return path is not ready" };
+          }
+          const pendingId3 = beginPendingOpen(preset.id);
+          try {
+            const result = await yaziController.open(request.once ? { once: true } : void 0);
+            if (result.status === "opened") {
+              return { status: "opened", label: preset.id, paneId: result.paneId };
+            }
+            if (result.status === "missing-binary") {
+              return {
+                status: "missing-binary",
+                preset: preset.id,
+                binary: result.binary,
+                installHint: preset.installHint,
+                detail: result.detail
+              };
+            }
+            return {
+              status: result.status === "profile-error" ? "refused" : "unavailable",
+              reason: result.reason
+            };
+          } finally {
+            pendingOpens.delete(pendingId3);
+          }
+        }
+        if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+        const binaryPath = probe(preset.binary);
+        if (binaryPath === null) {
+          return {
+            status: "missing-binary",
+            preset: preset.id,
+            binary: preset.binary,
+            installHint: preset.installHint,
+            detail: `${preset.binary} was not found (install with \`${preset.installHint}\`)`
+          };
+        }
+        const argv2 = presetArgv(preset.id, binaryPath);
+        if (argv2 === null) {
+          return { status: "refused", reason: `preset ${preset.id} has nothing to show yet` };
+        }
+        const pendingId2 = beginPendingOpen(preset.id);
+        try {
+          const ref = await deps.mux.openUtilityPane({ argv: argv2, cwd, label: preset.id });
+          if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${preset.id}` };
+          return { status: "opened", label: preset.id, paneId: ref.paneId };
+        } finally {
+          pendingOpens.delete(pendingId2);
+        }
+      }
+      if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+      const argv = request.argv ?? [];
+      if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
+      const label = argv[0] ?? "pane";
+      const pendingId = beginPendingOpen(label);
+      try {
+        const ref = await deps.mux.openUtilityPane({ argv, cwd, label });
+        if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${label}` };
+        return { status: "opened", label, paneId: ref.paneId };
+      } finally {
+        pendingOpens.delete(pendingId);
+      }
+    },
+    async close(target) {
+      if (!deps.mux.available()) return { status: "unavailable", reason: UNAVAILABLE };
+      const owned = deps.mux.list();
+      if (target === "all") {
+        const labels = [];
+        for (const record of [...owned]) {
+          if (await deps.mux.closePane(record.ref.paneId)) labels.push(record.label);
+        }
+        return { status: "closed", closed: labels.length, labels };
+      }
+      const needle = target.trim().toLowerCase();
+      const newestFirst = [...owned].reverse();
+      const match = newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ?? newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ?? newestFirst.find((record) => record.purpose === needle);
+      if (!match) return { status: "not-found", target };
+      const closed = await deps.mux.closePane(match.ref.paneId);
+      return closed ? { status: "closed", closed: 1, labels: [match.label] } : { status: "not-found", target };
+    },
+    attachYazi(controller) {
+      yaziController = controller;
+      return () => {
+        if (yaziController === controller) yaziController = null;
+      };
+    },
+    attachWatch(controller) {
+      watchController = controller;
+      return () => {
+        if (watchController === controller) watchController = null;
+      };
+    }
+  };
+}
+
+// src/interactive/watch-pane.ts
+init_esm_shims();
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function watchSelectionPath(stateDir = clioStateDir()) {
+  return join(stateDir, "watch-selection");
+}
+function atomicWrite(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, path);
+}
+function createWatchPaneController(deps) {
+  const selectionPath = deps.selectionPath ?? watchSelectionPath();
+  const dirs = deps.dirs ?? Object.freeze({
+    config: clioConfigDir(),
+    data: clioDataDir(),
+    state: clioStateDir(),
+    cache: clioCacheDir()
+  });
+  const command = deps.command ?? ((path, layout) => watchViewerCommand(path, { dirs: layout }));
+  const write = deps.writeFile ?? atomicWrite;
+  let paneId = null;
+  let disposed = false;
+  let adoptionInFlight = null;
+  const unsubscribe = deps.mux.onPaneGone((record) => {
+    if (record.ref.paneId === paneId) paneId = null;
+  });
+  const adoptExistingPane = () => {
+    if (disposed || paneId !== null) return Promise.resolve(true);
+    if (adoptionInFlight !== null) return adoptionInFlight;
+    const attempt = Promise.resolve().then(() => deps.mux.adoptPane({ purpose: "watch", label: "watch" })).then((adopted) => {
+      if (!disposed && paneId === null && adopted !== null) paneId = adopted.paneId;
+      return true;
+    }).catch(() => {
+      return false;
+    }).finally(() => {
+      if (adoptionInFlight === attempt) adoptionInFlight = null;
+    });
+    adoptionInFlight = attempt;
+    return attempt;
+  };
+  const writeSelection = (runId) => {
+    try {
+      write(selectionPath, `${runId}
+`);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  void adoptExistingPane();
+  return {
+    async watch(runId) {
+      if (!writeSelection(runId)) {
+        return { status: "unavailable", reason: `cannot write the watch selection at ${selectionPath}` };
+      }
+      if (paneId !== null) return { status: "watching", runId, paneId, opened: false };
+      const scanned = await adoptExistingPane();
+      if (!scanned) await adoptExistingPane();
+      if (paneId !== null) return { status: "watching", runId, paneId, opened: false };
+      const opened = await deps.mux.openUtilityPane({
+        argv: command(selectionPath, dirs),
+        cwd: deps.getCwd(),
+        label: "watch",
+        title: "clio watch",
+        purpose: "watch",
+        direction: "right"
+      });
+      if (opened === null) {
+        return { status: "unavailable", reason: "the pane host refused to open the watch pane" };
+      }
+      paneId = opened.paneId;
+      return { status: "watching", runId, paneId, opened: true };
+    },
+    follow(runId) {
+      if (paneId === null) return false;
+      return writeSelection(runId);
+    },
+    isOpen() {
+      return paneId !== null;
+    },
+    dispose() {
+      disposed = true;
+      unsubscribe();
+    }
+  };
+}
+
+// src/interactive/yazi-bridge.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { isAbsolute, join as join2, relative, resolve } from "node:path";
+var YAZI_PICK_MAX_PATHS = 32;
+var YAZI_PICK_MAX_CHARS = 4096;
+var YAZI_LIVENESS_MS = 5e3;
+function readOptional(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function runYaziTerminalChooser(options) {
+  const binaries = (options.resolveBinaries ?? resolveYaziBinaries)();
+  if (!binaries.yaziPath) {
+    return { status: "missing-binary", binary: "yazi", detail: binaries.missingYaziDetail };
+  }
+  if (options.profileMode === "managed" && !binaries.yaPath) {
+    return {
+      status: "missing-binary",
+      binary: "ya",
+      detail: "the Yazi helper `ya` is not available; install the complete pinned Yazi tool"
+    };
+  }
+  const cacheDir = options.cacheDir ?? clioCacheDir();
+  const sessionsDir = join2(cacheDir, "yazi", "sessions");
+  mkdirSync2(sessionsDir, { recursive: true });
+  const sessionId = options.sessionId ?? randomUUID();
+  const chooserPath = join2(sessionsDir, `${sessionId}.chooser`);
+  const cwdPath = join2(sessionsDir, `${sessionId}.cwd`);
+  const profile = options.profileMode === "managed" ? (options.ensureProfile ?? ensureYaziProfile)({
+    yaPath: binaries.yaPath,
+    yaziPath: binaries.yaziPath,
+    profileDir: yaziProfileDir(cacheDir)
+  }) : null;
+  if (options.profileMode === "managed" && !profile) {
+    return { status: "profile-error", reason: "Clio could not generate a valid managed Yazi profile" };
+  }
+  writeFileSync2(chooserPath, "");
+  writeFileSync2(cwdPath, "");
+  const args = [options.cwd, "--chooser-file", chooserPath, "--cwd-file", cwdPath];
+  const env = { ...process.env, ...profile ? { YAZI_CONFIG_HOME: profile.dir } : {} };
+  let processError;
+  options.stopUi();
+  try {
+    const result = options.spawnYazi ? options.spawnYazi(binaries.yaziPath, args, { cwd: options.cwd, env }) : spawnSync(binaries.yaziPath, args, { cwd: options.cwd, env, stdio: "inherit" });
+    processError = result.error;
+  } catch (error) {
+    processError = error instanceof Error ? error : new Error(String(error));
+  } finally {
+    options.startUi();
+    options.requestRender();
+  }
+  if (processError) return { status: "unavailable", reason: `yazi chooser failed: ${processError.message}` };
+  const paths = readOptional(chooserPath).split("\n").filter((path) => path.length > 0);
+  if (paths.length === 0) return { status: "cancelled" };
+  return {
+    status: "chosen",
+    choice: { paths, cwd: readOptional(cwdPath).trim() || options.cwd }
+  };
+}
+function containsAsciiWhitespace(value) {
+  for (const character of value) {
+    const code = character.charCodeAt(0);
+    if (code === 32 || code >= 9 && code <= 13) return true;
+  }
+  return false;
+}
+function relativeWhenInside(path, cwd) {
+  const candidate = relative(cwd, path);
+  if (candidate.length > 0 && candidate !== ".." && !candidate.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(candidate)) {
+    return candidate;
+  }
+  return path;
+}
+function draftContains(draft, item) {
+  let from = 0;
+  while (from <= draft.length) {
+    const at = draft.indexOf(item, from);
+    if (at < 0) return false;
+    const before = at === 0 ? "" : draft[at - 1] ?? "";
+    const after = draft[at + item.length] ?? "";
+    if ((before === "" || /\s/u.test(before)) && (after === "" || /\s/u.test(after))) return true;
+    from = at + item.length;
+  }
+  return false;
+}
+function pathKind(path) {
+  try {
+    const stat = statSync(path);
+    if (stat.isFile()) return "file";
+    if (stat.isDirectory()) return "directory";
+    return "other";
+  } catch {
+    return "other";
+  }
+}
+function formatYaziMentions(paths, options) {
+  const maxPaths = options.maxPaths ?? YAZI_PICK_MAX_PATHS;
+  const maxChars = options.maxChars ?? YAZI_PICK_MAX_CHARS;
+  const inspect = options.statPath ?? pathKind;
+  const rendered = [];
+  const seen = /* @__PURE__ */ new Set();
+  let mentions = 0;
+  let plainPaths = 0;
+  let duplicates = 0;
+  let truncated = Math.max(0, paths.length - maxPaths);
+  const candidates = paths.slice(0, maxPaths);
+  for (const [index, rawPath] of candidates.entries()) {
+    const absolute = isAbsolute(rawPath) ? rawPath : resolve(options.cwd, rawPath);
+    if (seen.has(absolute)) {
+      duplicates += 1;
+      continue;
+    }
+    seen.add(absolute);
+    const kind = inspect(absolute);
+    let display = relativeWhenInside(absolute, options.cwd);
+    if (kind === "directory" && display !== "/" && !display.endsWith("/")) display = `${display}/`;
+    const mention = kind === "file" && !containsAsciiWhitespace(display);
+    const item = mention ? `@${display}` : `\`${display.replaceAll("`", "\\`")}\``;
+    if (draftContains(options.draft, item)) {
+      duplicates += 1;
+      continue;
+    }
+    const nextLength = rendered.length === 0 ? item.length : rendered.join(" ").length + 1 + item.length;
+    if (nextLength > maxChars) {
+      truncated += candidates.length - index;
+      break;
+    }
+    rendered.push(item);
+    if (mention) mentions += 1;
+    else plainPaths += 1;
+  }
+  return {
+    text: rendered.join(" "),
+    inserted: rendered.length,
+    mentions,
+    plainPaths,
+    duplicates,
+    truncated
+  };
+}
+function appendDraft(draft, addition) {
+  if (addition.length === 0) return draft;
+  if (draft.length === 0) return addition;
+  return `${draft.replace(/\s+$/u, "")} ${addition}`;
+}
+function createYaziBridge(deps) {
+  const openSession = deps.openSession ?? createYaziSession;
+  let active = null;
+  let paneCwd = null;
+  let droppedLines = 0;
+  let disposed = false;
+  let generation = 0;
+  let livenessTimer = null;
+  let sawLine = false;
+  const clearLiveness = () => {
+    if (livenessTimer) clearTimeout(livenessTimer);
+    livenessTimer = null;
+  };
+  const insert = (paths, cwd) => {
+    const draft = deps.getDraft();
+    const batch = formatYaziMentions(paths, { cwd, draft, ...deps.statPath ? { statPath: deps.statPath } : {} });
+    if (batch.inserted === 0) {
+      if (batch.truncated > 0) {
+        deps.notice(
+          "warning",
+          `${batch.truncated} file-pane path${batch.truncated === 1 ? " was" : "s were"} omitted by the pick limits`
+        );
+      }
+      return;
+    }
+    deps.setDraft(appendDraft(draft, batch.text));
+    deps.requestRender();
+    deps.notice(
+      "info",
+      `${batch.inserted} ${batch.inserted === 1 ? "path" : "paths"} from the file pane added to the draft`
+    );
+    if (batch.plainPaths > 0) {
+      deps.notice(
+        "info",
+        `${batch.plainPaths} ${batch.plainPaths === 1 ? "path was" : "paths were"} inserted as plain text because directories and spaced paths cannot be file mentions`
+      );
+    }
+    if (batch.truncated > 0) {
+      deps.notice(
+        "warning",
+        `${batch.truncated} file-pane path${batch.truncated === 1 ? " was" : "s were"} omitted by the pick limits`
+      );
+    }
+  };
+  const start = async (mode, profileMode) => {
+    const mux = deps.mux;
+    if (!mux?.available()) return { status: "unavailable", reason: "the pane layer is not available" };
+    generation += 1;
+    const ownGeneration = generation;
+    const token = (deps.pickToken ?? randomUUID)();
+    sawLine = false;
+    paneCwd = deps.getCwd();
+    const result = await openSession({
+      mux,
+      mode,
+      profileMode,
+      cwd: deps.getCwd(),
+      pickToken: token,
+      onEvent: (event) => {
+        if (disposed || ownGeneration !== generation) return;
+        sawLine = true;
+        if (event.kind === "cd") {
+          paneCwd = event.cwd;
+          return;
+        }
+        if (event.values[0] !== token) {
+          droppedLines += 1;
+          return;
+        }
+        insert(event.values.slice(1), paneCwd ?? deps.getCwd());
+      },
+      onChooser: (choice) => {
+        if (disposed || ownGeneration !== generation) return;
+        paneCwd = choice.cwd;
+        if (choice.paths.length > 0) insert(choice.paths, choice.cwd);
+      },
+      onStopped: () => {
+        if (ownGeneration !== generation) return;
+        clearLiveness();
+        active = null;
+      }
+    });
+    if (result.status !== "opened") return result;
+    if (disposed || ownGeneration !== generation) {
+      await result.session.close();
+      return { status: "unavailable", reason: "the file pane was closed while it was opening" };
+    }
+    active = result.session;
+    if (mode === "companion") {
+      livenessTimer = setTimeout(() => {
+        if (disposed || ownGeneration !== generation || sawLine || active === null) return;
+        const stale = active;
+        active = null;
+        deps.notice("warning", "the file-pane event stream did not start; reopening yazi in chooser mode");
+        void stale.close().finally(() => {
+          if (!disposed && ownGeneration === generation) void start("chooser", profileMode);
+        });
+      }, deps.livenessMs ?? YAZI_LIVENESS_MS);
+      livenessTimer.unref();
+    }
+    return { status: "opened", mode, paneId: result.session.pane.paneId, existing: false };
+  };
+  return {
+    async open(options = {}) {
+      if (disposed) return { status: "unavailable", reason: "the file-pane bridge is closed" };
+      const settings = deps.getSettings?.() ?? { mode: "companion", profile: "managed", followCwd: true };
+      if (active) {
+        if (settings.followCwd) {
+          const cwd = deps.getCwd();
+          if (await active.pushCwd(cwd)) paneCwd = cwd;
+        }
+        return { status: "opened", mode: active.mode, paneId: active.pane.paneId, existing: true };
+      }
+      const mode = options.once || settings.profile === "user" ? "chooser" : settings.mode;
+      if (!deps.mux?.available()) {
+        const result = await (deps.runTerminalChooser ?? ((choiceOptions) => runYaziTerminalChooser({
+          ...choiceOptions,
+          stopUi: deps.stopUi ?? (() => {
+          }),
+          startUi: deps.startUi ?? (() => {
+          }),
+          requestRender: deps.requestRender
+        })))({ cwd: deps.getCwd(), profileMode: settings.profile });
+        if (result.status === "chosen") {
+          paneCwd = result.choice.cwd;
+          insert(result.choice.paths, result.choice.cwd);
+        }
+        if (result.status === "chosen" || result.status === "cancelled") {
+          return { status: "opened", mode: "chooser", paneId: null, existing: false };
+        }
+        return result;
+      }
+      return await start(mode, settings.profile);
+    },
+    status() {
+      const snapshot = active?.snapshot();
+      return {
+        mode: active?.mode ?? "closed",
+        paneId: active?.pane.paneId ?? null,
+        paneCwd: paneCwd ?? snapshot?.paneCwd ?? null,
+        lastLineAt: snapshot?.lastLineAt ?? null,
+        droppedLines
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      generation += 1;
+      clearLiveness();
+      const closing = active;
+      active = null;
+      if (closing) void closing.close();
+    }
+  };
+}
+export {
+  createMuxBridge,
+  createMuxDomainModule,
+  createPanesRuntime,
+  createWatchPaneController,
+  createYaziBridge
+};
+//# sourceMappingURL=with-panes-MKB46MPQ.js.map