@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/chunk-HZHHCK24.js

@@ -0,0 +1,1631 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  parseTomlDocument
+} from "./chunk-LCGCVYZ4.js";
+import {
+  describeResolution,
+  resolveToolBinary,
+  toolStatus
+} from "./chunk-QSNYB6ZV.js";
+import {
+  findPinnedTool
+} from "./chunk-QDC3K2U3.js";
+import {
+  readClioVersion,
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
+import {
+  clioCacheDir,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/mux/yazi/profile.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  cpSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative } from "node:path";
+
+// src/domains/mux/yazi/theme.ts
+init_esm_shims();
+
+// src/core/theme-token-hex.ts
+init_esm_shims();
+var TOKEN_HEX = {
+  accent: "#46e5d0",
+  accentDeep: "#1fb7a6",
+  action: "#ff7e29",
+  success: "#57e389",
+  warning: "#ffb454",
+  error: "#ff5c66",
+  info: "#5ba8ff",
+  reason: "#9d8cff",
+  dim: "#6a7a85",
+  muted: "#8a99a4",
+  title: "#46e5d0",
+  frame: "#2f5d5a",
+  frameStrong: "#2aab9e"
+};
+function tokenHex(token2) {
+  return TOKEN_HEX[token2];
+}
+
+// src/domains/mux/yazi/theme.ts
+function renderYaziTheme() {
+  return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
+
+[mgr]
+cwd = { fg = "${tokenHex("accent")}" }
+find_keyword = { fg = "${tokenHex("warning")}" }
+marker_selected = { fg = "${tokenHex("success")}", bg = "${tokenHex("success")}" }
+marker_copied = { fg = "${tokenHex("accent")}", bg = "${tokenHex("accent")}" }
+marker_cut = { fg = "${tokenHex("error")}", bg = "${tokenHex("error")}" }
+border_style = { fg = "${tokenHex("frame")}" }
+
+[mode]
+normal_main = { bg = "${tokenHex("accent")}" }
+normal_alt = { fg = "${tokenHex("accent")}" }
+select_main = { bg = "${tokenHex("action")}" }
+select_alt = { fg = "${tokenHex("action")}" }
+unset_main = { bg = "${tokenHex("error")}" }
+unset_alt = { fg = "${tokenHex("error")}" }
+
+[tabs]
+active = { bg = "${tokenHex("accent")}" }
+inactive = { fg = "${tokenHex("accent")}" }
+
+[status]
+perm_sep = { fg = "${tokenHex("dim")}" }
+`;
+}
+
+// src/domains/mux/yazi/profile.ts
+var PROFILE_FILES = ["yazi.toml", "keymap.toml", "theme.toml", "init.lua"];
+var PROFILE_PLUGIN_FILES = ["main.lua", "types.lua", "LICENSE", "README.md"];
+var STAMP_FILE = "stamp.json";
+function yaziProfileDir(cacheDir = resolveClioDirs().cache) {
+  return join(cacheDir, "yazi", "profile");
+}
+function userYaziConfigDir(env = process.env, home = homedir()) {
+  const xdg = env.XDG_CONFIG_HOME;
+  return xdg && isAbsolute(xdg) ? join(xdg, "yazi") : join(home, ".config", "yazi");
+}
+function resetYaziProfile(profileDir = yaziProfileDir()) {
+  rmSync(profileDir, { recursive: true, force: true });
+}
+function defaultAssetDir() {
+  return join(resolvePackageRoot(), "src", "domains", "mux", "yazi", "assets");
+}
+function yaziPin() {
+  return findPinnedTool("yazi")?.version ?? "unknown";
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function filesBelow(root, current = root) {
+  const files = [];
+  for (const entry of readdirSync(current, { withFileTypes: true }).sort(
+    (left, right) => left.name.localeCompare(right.name)
+  )) {
+    const path = join(current, entry.name);
+    if (entry.isDirectory()) files.push(...filesBelow(root, path));
+    else if (entry.isFile()) files.push(relative(root, path).replaceAll("\\", "/"));
+  }
+  return files;
+}
+function hashYaziAssetTree(assetDir) {
+  const hash = createHash("sha256");
+  for (const file of filesBelow(assetDir)) {
+    hash.update(file);
+    hash.update("\0");
+    hash.update(readFileSync(join(assetDir, file)));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function renderYaziKeymap(yaPath) {
+  const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-pick --list "$CLIO_YAZI_PICK_TOKEN" %s`;
+  return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
+
+[[mgr.prepend_keymap]]
+on   = "<C-y>"
+run  = ${JSON.stringify(command)}
+desc = "Send the selection to Clio"
+`;
+}
+function expected(options) {
+  const assetDir = options.assetDir ?? defaultAssetDir();
+  const themeToml = options.themeToml ?? renderYaziTheme();
+  const yaziToml = options.yaziToml ?? readFileSync(join(assetDir, "yazi.toml"), "utf8");
+  const keymapToml = options.keymapToml ?? renderYaziKeymap(options.yaPath);
+  return {
+    dir: options.profileDir ?? yaziProfileDir(),
+    assetDir,
+    yaziToml,
+    keymapToml,
+    themeToml,
+    stamp: {
+      yaziVersion: options.yaziVersion ?? yaziPin(),
+      clioVersion: options.clioVersion ?? readClioVersion(),
+      yaPath: options.yaPath,
+      assetSha256: hashYaziAssetTree(assetDir),
+      themeSha256: sha256(themeToml)
+    }
+  };
+}
+function readStamp(dir) {
+  try {
+    const value = JSON.parse(readFileSync(join(dir, STAMP_FILE), "utf8"));
+    if (typeof value.yaziVersion !== "string" || typeof value.clioVersion !== "string" || typeof value.yaPath !== "string" || typeof value.assetSha256 !== "string" || typeof value.themeSha256 !== "string") {
+      return null;
+    }
+    return value;
+  } catch {
+    return null;
+  }
+}
+function sameStamp(left, right) {
+  return left !== null && left.yaziVersion === right.yaziVersion && left.clioVersion === right.clioVersion && left.yaPath === right.yaPath && left.assetSha256 === right.assetSha256 && left.themeSha256 === right.themeSha256;
+}
+function profileFilesExist(dir) {
+  return PROFILE_FILES.every((file) => statSync(join(dir, file), { throwIfNoEntry: false })?.isFile()) && PROFILE_PLUGIN_FILES.every(
+    (file) => statSync(join(dir, "plugins", "git.yazi", file), { throwIfNoEntry: false })?.isFile() === true
+  );
+}
+function inspectYaziProfile(options) {
+  const inputs = expected(options);
+  const present = statSync(inputs.dir, { throwIfNoEntry: false })?.isDirectory() === true;
+  const current = present && profileFilesExist(inputs.dir) && sameStamp(readStamp(inputs.dir), inputs.stamp);
+  return {
+    dir: inputs.dir,
+    userConfigDir: userYaziConfigDir(),
+    state: current ? "current" : present ? "stale" : "missing",
+    stamp: inputs.stamp
+  };
+}
+function inspectCurrentYaziProfile() {
+  return inspectYaziProfile({ yaPath: resolveToolBinary("ya").binaryPath ?? "(unresolved)" });
+}
+function describeYaziProfile(inspection) {
+  return `${inspection.dir} (${inspection.state}); user config ${inspection.userConfigDir} is separate and untouched`;
+}
+function parseGenerated(dir) {
+  return ["yazi.toml", "keymap.toml", "theme.toml"].every((file) => {
+    try {
+      return parseTomlDocument(readFileSync(join(dir, file), "utf8")) !== null;
+    } catch {
+      return false;
+    }
+  });
+}
+var YAZI_CONFIG_ERROR_MARKERS = ["Failed to parse config", "Press <Enter> to continue with preset settings"];
+function validatesWithYazi(dir, yaziPath) {
+  const scratchHome = mkdtempSync(join(dirname(dir), ".yazi-validation-"));
+  try {
+    const result = spawnSync(yaziPath, ["--debug"], {
+      cwd: scratchHome,
+      env: {
+        ...process.env,
+        HOME: scratchHome,
+        XDG_CACHE_HOME: join(scratchHome, "cache"),
+        XDG_CONFIG_HOME: join(scratchHome, "config"),
+        YAZI_CONFIG_HOME: dir
+      },
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+    return result.error === void 0 && result.status === 0 && YAZI_CONFIG_ERROR_MARKERS.every((marker) => !output.includes(marker));
+  } catch {
+    return false;
+  } finally {
+    rmSync(scratchHome, { recursive: true, force: true });
+  }
+}
+function ensureYaziProfile(options) {
+  let inputs;
+  try {
+    inputs = expected({ ...options, profileDir: options.profileDir ?? yaziProfileDir(clioCacheDir()) });
+  } catch {
+    return null;
+  }
+  if (profileFilesExist(inputs.dir) && sameStamp(readStamp(inputs.dir), inputs.stamp)) {
+    return { dir: inputs.dir, stamp: inputs.stamp };
+  }
+  mkdirSync(dirname(inputs.dir), { recursive: true });
+  const staging = mkdtempSync(join(dirname(inputs.dir), ".profile-"));
+  try {
+    cpSync(join(inputs.assetDir, "init.lua"), join(staging, "init.lua"));
+    cpSync(join(inputs.assetDir, "plugins"), join(staging, "plugins"), { recursive: true });
+    writeFileSync(join(staging, "yazi.toml"), inputs.yaziToml);
+    writeFileSync(join(staging, "keymap.toml"), inputs.keymapToml);
+    writeFileSync(join(staging, "theme.toml"), inputs.themeToml);
+    writeFileSync(join(staging, STAMP_FILE), `${JSON.stringify(inputs.stamp, null, 2)}
+`);
+    if (!parseGenerated(staging) || !validatesWithYazi(staging, options.yaziPath)) {
+      rmSync(inputs.dir, { recursive: true, force: true });
+      return null;
+    }
+    rmSync(inputs.dir, { recursive: true, force: true });
+    renameSync(staging, inputs.dir);
+    return { dir: inputs.dir, stamp: inputs.stamp };
+  } catch {
+    rmSync(inputs.dir, { recursive: true, force: true });
+    return null;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+
+// src/domains/mux/index.ts
+init_esm_shims();
+
+// src/domains/mux/extension.ts
+init_esm_shims();
+
+// src/domains/mux/contract.ts
+init_esm_shims();
+
+// src/domains/mux/pane-registry.ts
+init_esm_shims();
+function createPaneRegistry() {
+  const byPane = /* @__PURE__ */ new Map();
+  return {
+    record(entry) {
+      byPane.set(entry.ref.paneId, entry);
+    },
+    byPaneId(paneId) {
+      return byPane.get(paneId) ?? null;
+    },
+    byPurpose(purpose) {
+      let newest = null;
+      for (const entry of byPane.values()) {
+        if (entry.purpose === purpose) newest = entry;
+      }
+      return newest;
+    },
+    owns(paneId) {
+      return byPane.has(paneId);
+    },
+    forget(paneId) {
+      const entry = byPane.get(paneId);
+      if (!entry) return null;
+      byPane.delete(paneId);
+      return entry;
+    },
+    reconcile(livePaneIds) {
+      const live = new Set(livePaneIds);
+      const dropped = [];
+      for (const [paneId, entry] of byPane) {
+        if (!live.has(paneId)) dropped.push(entry);
+      }
+      for (const entry of dropped) byPane.delete(entry.ref.paneId);
+      return dropped;
+    },
+    list() {
+      return [...byPane.values()];
+    },
+    clear() {
+      byPane.clear();
+    }
+  };
+}
+function paneRecord(ref, fields) {
+  return {
+    ref,
+    purpose: fields.purpose,
+    label: fields.label,
+    openedAt: fields.openedAt,
+    ...fields.adopted === true ? { adopted: true } : {}
+  };
+}
+
+// src/domains/mux/protocol.ts
+init_esm_shims();
+var MUX_METHOD_MIN_PROTOCOL = {
+  "notification.show": 17,
+  "pane.rename": 17,
+  "worktree.list": 10,
+  "worktree.create": 10,
+  "worktree.open": 10,
+  "worktree.remove": 10
+};
+function muxSupportsMethod(server, method) {
+  if (server === null) return false;
+  return server.protocol >= MUX_METHOD_MIN_PROTOCOL[method];
+}
+
+// src/domains/mux/types.ts
+init_esm_shims();
+var MuxError = class extends Error {
+  kind;
+  /** The server's raw error code, when the failure came back over the wire. */
+  wireCode;
+  method;
+  constructor(kind, message, options = {}) {
+    super(message);
+    this.name = "MuxError";
+    this.kind = kind;
+    this.wireCode = options.wireCode ?? null;
+    this.method = options.method ?? null;
+  }
+};
+var MuxRequestTimeout = class extends MuxError {
+  timeoutMs;
+  constructor(method, timeoutMs) {
+    super("timeout", `mux request ${method} timed out after ${timeoutMs}ms`, { method });
+    this.name = "MuxRequestTimeout";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var ERROR_KIND_BY_WIRE_CODE = {
+  agent_blocked: "agent_blocked",
+  agent_prompt_stalled: "agent_prompt_stalled",
+  feature_disabled: "feature_disabled",
+  invalid_params: "invalid_params",
+  invalid_request: "invalid_params",
+  not_found: "not_found"
+};
+function muxErrorKind(wireCode) {
+  const mapped = ERROR_KIND_BY_WIRE_CODE[wireCode];
+  if (mapped) return mapped;
+  if (wireCode.endsWith("_not_found")) return "not_found";
+  if (wireCode.startsWith("invalid_")) return "invalid_params";
+  return "unknown";
+}
+
+// src/domains/mux/contract.ts
+var METADATA_SOURCE = "clio:mux";
+var SELF_AGENT_SOURCE = "clio:coder";
+var OWNER_TOKEN_KEY = "clio_owner";
+var OWNER_TOKEN_VALUE = "clio:mux";
+var TOKEN_VALUE_MAX = 80;
+var DEGRADE_COOLDOWN_MS = 5e3;
+function shellQuote2(argv) {
+  return argv.map((arg) => `'${arg.replaceAll("'", `'\\''`)}'`).join(" ");
+}
+function token(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return value.length > TOKEN_VALUE_MAX ? value.slice(0, TOKEN_VALUE_MAX) : value;
+}
+function createMuxRuntime(options) {
+  const { detection, client } = options;
+  const log = options.log ?? (() => void 0);
+  const now = options.now ?? Date.now;
+  const registry = createPaneRegistry();
+  let healthy = client !== null;
+  let probeHealthAt = 0;
+  let stopped = false;
+  let subscription = null;
+  const paneGoneHandlers = /* @__PURE__ */ new Set();
+  const degrade = (what, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const transport = error instanceof MuxError && (error.kind === "transport" || error.kind === "timeout");
+    if (transport) {
+      healthy = false;
+      probeHealthAt = now() + DEGRADE_COOLDOWN_MS;
+    }
+    log(transport ? "warning" : "debug", `mux ${what} failed: ${message}`);
+  };
+  const usable = () => {
+    if (stopped || client === null || detection.mode === "none") return false;
+    return healthy || now() >= probeHealthAt;
+  };
+  const attempt = async (what, run, fallback) => {
+    if (!usable() || client === null) return fallback;
+    try {
+      const value = await run(client);
+      healthy = true;
+      return value;
+    } catch (error) {
+      degrade(what, error);
+      return fallback;
+    }
+  };
+  const tagOwner = async (live, paneId, tokens, title) => {
+    await live.paneReportMetadata({
+      paneId,
+      source: METADATA_SOURCE,
+      ...title === void 0 ? {} : { title },
+      tokens: { [OWNER_TOKEN_KEY]: OWNER_TOKEN_VALUE, ...tokens }
+    });
+  };
+  const onEvent = (event) => {
+    const dropped = registry.forget(event.paneId);
+    if (dropped) {
+      log("debug", `mux pane ${event.paneId} left on ${event.kind}; dropped from the registry`);
+      for (const handler of paneGoneHandlers) {
+        try {
+          handler(dropped);
+        } catch (error) {
+          log("debug", `mux pane-gone handler threw: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    }
+  };
+  const contract = {
+    mode: detection.mode,
+    available() {
+      return usable();
+    },
+    detection() {
+      return detection;
+    },
+    async openUtilityPane(request) {
+      return await attempt(
+        "openUtilityPane",
+        async (live) => {
+          const anchor = detection.self.paneId ?? (await live.paneCurrent()).paneId;
+          const pane = await live.paneSplit({
+            direction: request.direction ?? "right",
+            targetPaneId: anchor,
+            cwd: request.cwd,
+            focus: false,
+            ...request.env ? { env: request.env } : {}
+          });
+          const ref = { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+          const purpose = request.purpose ?? "utility";
+          registry.record(paneRecord(ref, { purpose, label: request.label, openedAt: now() }));
+          const title = request.title;
+          const titleSupported = title !== void 0 && muxSupportsMethod(detection.server, "pane.rename");
+          if (titleSupported) {
+            try {
+              await live.paneRename(pane.paneId, title);
+            } catch {
+            }
+          }
+          await tagOwner(live, pane.paneId, { role: token(purpose) }, titleSupported ? title : void 0);
+          if (request.argv.length > 0) {
+            const redirect = request.stdoutPath ? ` > ${shellQuote2([request.stdoutPath])}` : "";
+            await live.paneSendText(pane.paneId, `exec ${shellQuote2(request.argv)}${redirect}
+`);
+          }
+          return ref;
+        },
+        null
+      );
+    },
+    async closePane(paneId) {
+      if (!registry.owns(paneId)) return false;
+      return await attempt(
+        "closePane",
+        async (live) => {
+          await live.paneClose(paneId);
+          registry.forget(paneId);
+          return true;
+        },
+        false
+      );
+    },
+    async adoptPane(request) {
+      const existing = registry.byPurpose(request.purpose);
+      if (existing) return existing.ref;
+      return await attempt(
+        "adoptPane",
+        async (live) => {
+          const snapshot = await live.snapshot();
+          for (const pane of snapshot.panes) {
+            if (pane.tokens[OWNER_TOKEN_KEY] !== OWNER_TOKEN_VALUE) continue;
+            if (pane.tokens.role !== request.purpose) continue;
+            if (registry.owns(pane.paneId)) continue;
+            if (detection.self.workspaceId !== null && pane.workspaceId !== detection.self.workspaceId) continue;
+            const ref = { paneId: pane.paneId, tabId: pane.tabId, workspaceId: pane.workspaceId };
+            registry.record(
+              paneRecord(ref, { purpose: request.purpose, label: request.label, openedAt: now(), adopted: true })
+            );
+            log("info", `mux adopted a ${request.purpose} pane left open by a previous session`);
+            return ref;
+          }
+          return null;
+        },
+        null
+      );
+    },
+    async notify(request) {
+      if (!muxSupportsMethod(detection.server, "notification.show")) {
+        log("debug", `mux notify skipped, server protocol is below the notification.show floor: ${request.title}`);
+        return;
+      }
+      await attempt(
+        "notify",
+        async (live) => {
+          const result = await live.notificationShow({
+            title: request.title,
+            ...request.body ? { body: request.body } : {},
+            ...request.sound ? { sound: request.sound } : {}
+          });
+          if (!result.shown) log("debug", `mux notify not shown (${result.reason}): ${request.title}`);
+          return void 0;
+        },
+        void 0
+      );
+    },
+    async worktreeCreate(request) {
+      if (!muxSupportsMethod(detection.server, "worktree.create")) {
+        log("debug", "mux worktree.create skipped, server protocol is below the worktree floor");
+        return null;
+      }
+      return await attempt("worktreeCreate", (live) => live.worktreeCreate(request), null);
+    },
+    async worktreeRemove(workspaceId, removeOptions = {}) {
+      if (!muxSupportsMethod(detection.server, "worktree.remove")) {
+        log("debug", "mux worktree.remove skipped, server protocol is below the worktree floor");
+        return false;
+      }
+      return await attempt(
+        "worktreeRemove",
+        async (live) => {
+          await live.worktreeRemove(workspaceId, removeOptions);
+          return true;
+        },
+        false
+      );
+    },
+    onPaneGone(handler) {
+      paneGoneHandlers.add(handler);
+      return () => {
+        paneGoneHandlers.delete(handler);
+      };
+    },
+    list() {
+      return registry.list();
+    },
+    async reportSelf(report) {
+      const paneId = detection.self.paneId;
+      if (detection.mode !== "guest" || !paneId) return false;
+      return await attempt(
+        "reportSelf",
+        async (live) => {
+          await live.paneReportAgent({
+            paneId,
+            source: SELF_AGENT_SOURCE,
+            agent: "clio-coder",
+            state: report.state,
+            ...report.message ? { message: report.message } : {}
+          });
+          if (report.tokens || report.stateLabels || report.ttlMs !== void 0) {
+            await live.paneReportMetadata({
+              paneId,
+              source: METADATA_SOURCE,
+              ...report.tokens ? { tokens: report.tokens } : {},
+              ...report.stateLabels ? { stateLabels: report.stateLabels } : {},
+              ...report.ttlMs !== void 0 ? { ttlMs: report.ttlMs } : {}
+            });
+          }
+          return true;
+        },
+        false
+      );
+    },
+    async shutdown() {
+      if (stopped) return;
+      stopped = true;
+      subscription?.close();
+      subscription = null;
+      paneGoneHandlers.clear();
+      if (client) await client.close().catch(() => void 0);
+    }
+  };
+  const start = async () => {
+    if (detection.mode === "none" || client === null) return;
+    try {
+      subscription = await client.subscribe(["pane.closed", "pane.exited"], onEvent, {
+        onResync: (snapshot) => {
+          const dropped = registry.reconcile(snapshot.panes.map((pane) => pane.paneId));
+          if (dropped.length > 0) {
+            log("info", `mux reconciled ${dropped.length} pane(s) closed while the socket was down`);
+          }
+        }
+      });
+    } catch (error) {
+      degrade("event subscription", error);
+    }
+  };
+  return { contract, start, stop: contract.shutdown, registry };
+}
+
+// src/domains/mux/detect.ts
+init_esm_shims();
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/domains/mux/socket-client.ts
+init_esm_shims();
+import * as net from "node:net";
+var DEFAULT_REQUEST_TIMEOUT_MS = 5e3;
+var DEFAULT_CONNECT_TIMEOUT_MS = 2e3;
+var DEFAULT_BACKOFF = { initialDelayMs: 250, maxDelayMs: 5e3, factor: 2 };
+var MAX_LINE_BYTES = 8 * 1024 * 1024;
+function connectSocket(socketPath, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const socket = net.connect({ path: socketPath });
+    socket.setNoDelay(true);
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new MuxError("transport", `mux socket connect to ${socketPath} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+    const settle = (error) => {
+      clearTimeout(timer);
+      socket.removeListener("connect", onConnect);
+      socket.removeListener("error", onError);
+      if (error) {
+        socket.destroy();
+        reject(new MuxError("transport", `mux socket connect to ${socketPath} failed: ${error.message}`));
+        return;
+      }
+      resolve(socket);
+    };
+    const onConnect = () => settle(null);
+    const onError = (error) => settle(error);
+    socket.once("connect", onConnect);
+    socket.once("error", onError);
+  });
+}
+function readJsonLines(socket, onValue, onOverflow) {
+  let buffer = "";
+  socket.setEncoding("utf8");
+  socket.on("data", (chunk) => {
+    buffer += chunk;
+    if (buffer.length > MAX_LINE_BYTES) {
+      buffer = "";
+      onOverflow();
+      return;
+    }
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = buffer.slice(0, newline).trim();
+      buffer = buffer.slice(newline + 1);
+      if (line.length > 0) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          parsed = null;
+        }
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          onValue(parsed);
+        }
+      }
+      newline = buffer.indexOf("\n");
+    }
+  });
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function requireString(source, key, context) {
+  const value = source[key];
+  if (typeof value !== "string") {
+    throw new MuxError("protocol", `mux ${context} response is missing string field ${key}`);
+  }
+  return value;
+}
+function optionalString(source, key) {
+  const value = source[key];
+  return typeof value === "string" ? value : null;
+}
+function stringMap(value) {
+  const source = asRecord(value);
+  if (!source) return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(source)) {
+    if (typeof entry === "string") out[key] = entry;
+  }
+  return out;
+}
+var AGENT_STATES = /* @__PURE__ */ new Set(["idle", "working", "blocked", "done", "unknown"]);
+function readAgentState(value) {
+  return typeof value === "string" && AGENT_STATES.has(value) ? value : "unknown";
+}
+function readPane(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux pane response is not an object");
+  const revision = source.revision;
+  return {
+    paneId: requireString(source, "pane_id", "pane"),
+    tabId: requireString(source, "tab_id", "pane"),
+    workspaceId: requireString(source, "workspace_id", "pane"),
+    focused: source.focused === true,
+    agentState: readAgentState(source.agent_status),
+    revision: typeof revision === "number" ? revision : 0,
+    label: optionalString(source, "label"),
+    title: optionalString(source, "title"),
+    cwd: optionalString(source, "cwd"),
+    agent: optionalString(source, "agent"),
+    tokens: stringMap(source.tokens)
+  };
+}
+function readTab(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux tab response is not an object");
+  const number = source.number;
+  const paneCount = source.pane_count;
+  return {
+    tabId: requireString(source, "tab_id", "tab"),
+    workspaceId: requireString(source, "workspace_id", "tab"),
+    number: typeof number === "number" ? number : 0,
+    label: optionalString(source, "label") ?? "",
+    focused: source.focused === true,
+    paneCount: typeof paneCount === "number" ? paneCount : 0,
+    agentState: readAgentState(source.agent_status)
+  };
+}
+function readWorktree(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux worktree response is not an object");
+  return {
+    path: requireString(source, "path", "worktree"),
+    branch: optionalString(source, "branch"),
+    isBare: source.is_bare === true,
+    isDetached: source.is_detached === true,
+    isPrunable: source.is_prunable === true,
+    isLinkedWorktree: source.is_linked_worktree === true,
+    openWorkspaceId: optionalString(source, "open_workspace_id"),
+    label: optionalString(source, "label") ?? ""
+  };
+}
+function readWorktreeSource(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux worktree source response is not an object");
+  return {
+    repoKey: requireString(source, "repo_key", "worktree source"),
+    repoName: requireString(source, "repo_name", "worktree source"),
+    repoRoot: requireString(source, "repo_root", "worktree source"),
+    sourceCheckoutPath: requireString(source, "source_checkout_path", "worktree source"),
+    sourceWorkspaceId: optionalString(source, "source_workspace_id")
+  };
+}
+function readArray(source, key) {
+  const value = source[key];
+  return Array.isArray(value) ? value : [];
+}
+function readServerInfo(source) {
+  const protocol = source.protocol;
+  return {
+    version: optionalString(source, "version") ?? "",
+    protocol: typeof protocol === "number" ? protocol : 0
+  };
+}
+function readSnapshot(value) {
+  const source = asRecord(value);
+  if (!source) throw new MuxError("protocol", "mux snapshot response is not an object");
+  return {
+    server: readServerInfo(source),
+    focusedPaneId: optionalString(source, "focused_pane_id"),
+    focusedTabId: optionalString(source, "focused_tab_id"),
+    focusedWorkspaceId: optionalString(source, "focused_workspace_id"),
+    panes: readArray(source, "panes").map(readPane),
+    tabs: readArray(source, "tabs").map(readTab)
+  };
+}
+var EVENT_KIND_BY_WIRE = {
+  pane_closed: "pane.closed",
+  pane_exited: "pane.exited"
+};
+function readEvent(line) {
+  const wireKind = line.event;
+  if (typeof wireKind !== "string") return null;
+  const kind = EVENT_KIND_BY_WIRE[wireKind];
+  if (!kind) return null;
+  const data = asRecord(line.data);
+  if (!data) return null;
+  const paneId = data.pane_id;
+  const workspaceId = data.workspace_id;
+  if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
+  return { kind, paneId, workspaceId };
+}
+function params(entries) {
+  const out = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function createMuxClient(options) {
+  const socketPath = options.socketPath;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+  const backoff = options.backoff ?? DEFAULT_BACKOFF;
+  const log = options.log ?? (() => void 0);
+  let disposed = false;
+  let nextId = 0;
+  let reachable = false;
+  let serverInfo = null;
+  let snapshotCache = null;
+  let connectFailures = 0;
+  let retryAt = 0;
+  const delayFor = (failures) => Math.min(backoff.maxDelayMs, backoff.initialDelayMs * backoff.factor ** Math.max(0, failures - 1));
+  const call = async (method, callParams, timeoutMs) => {
+    if (disposed) throw new MuxError("transport", "mux client is closed");
+    const waitMs = retryAt - Date.now();
+    if (waitMs > 0) {
+      throw new MuxError("transport", `mux socket ${socketPath} is in backoff for another ${waitMs}ms`);
+    }
+    let socket;
+    try {
+      socket = await connectSocket(socketPath, connectTimeoutMs);
+    } catch (error) {
+      connectFailures += 1;
+      retryAt = Date.now() + delayFor(connectFailures);
+      reachable = false;
+      throw error;
+    }
+    connectFailures = 0;
+    retryAt = 0;
+    nextId += 1;
+    const id = `clio-${nextId}`;
+    const budget = timeoutMs ?? requestTimeoutMs;
+    try {
+      const result = await new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (settle) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          socket.destroy();
+          settle();
+        };
+        const timer = setTimeout(() => finish(() => reject(new MuxRequestTimeout(method, budget))), budget);
+        timer.unref?.();
+        readJsonLines(
+          socket,
+          (line) => {
+            const responseId = line.id;
+            if (typeof responseId !== "string") return;
+            const error = asRecord(line.error);
+            if (responseId !== id && !(responseId === "" && error)) return;
+            if (error) {
+              const code = typeof error.code === "string" ? error.code : "unknown";
+              const message = typeof error.message === "string" ? error.message : code;
+              finish(() => reject(new MuxError(muxErrorKind(code), message, { wireCode: code, method })));
+              return;
+            }
+            finish(() => resolve(line.result));
+          },
+          () => finish(() => reject(new MuxError("protocol", `mux ${method} response line was oversized`, { method })))
+        );
+        socket.on(
+          "error",
+          (error) => finish(() => reject(new MuxError("transport", `mux request ${method} failed: ${error.message}`, { method })))
+        );
+        socket.on(
+          "close",
+          () => finish(() => reject(new MuxError("transport", `mux request ${method} lost its connection`, { method })))
+        );
+        socket.write(`${JSON.stringify({ id, method, params: callParams })}
+`, (error) => {
+          if (!error) return;
+          finish(
+            () => reject(new MuxError("transport", `mux request ${method} failed to write: ${error.message}`, { method }))
+          );
+        });
+      });
+      reachable = true;
+      return result;
+    } catch (error) {
+      if (error instanceof MuxError && error.kind === "transport") reachable = false;
+      throw error;
+    }
+  };
+  const callObject = async (method, callParams, timeoutMs) => {
+    const result = asRecord(await call(method, callParams, timeoutMs));
+    if (!result) throw new MuxError("protocol", `mux ${method} returned a non-object result`, { method });
+    return result;
+  };
+  const snapshot = async () => {
+    const result = await callObject("session.snapshot", {});
+    const parsed = readSnapshot(result.snapshot);
+    snapshotCache = parsed;
+    serverInfo = parsed.server;
+    return parsed;
+  };
+  const subscribe = async (kinds, handler, subscribeOptions = {}) => {
+    let closed = false;
+    let socket = null;
+    let retryTimer = null;
+    let failures = 0;
+    const scheduleReopen = () => {
+      if (closed || disposed) return;
+      failures += 1;
+      const delay = delayFor(failures);
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        void open(true);
+      }, delay);
+      retryTimer.unref?.();
+    };
+    const open = async (isReconnect) => {
+      if (closed || disposed) return;
+      let stream;
+      try {
+        stream = await connectSocket(socketPath, connectTimeoutMs);
+      } catch (error) {
+        log("debug", `mux event stream connect failed: ${error instanceof Error ? error.message : String(error)}`);
+        scheduleReopen();
+        return;
+      }
+      if (closed || disposed) {
+        stream.destroy();
+        return;
+      }
+      socket = stream;
+      let acknowledged = false;
+      readJsonLines(
+        stream,
+        (line) => {
+          if (!acknowledged && typeof line.id === "string") {
+            acknowledged = true;
+            failures = 0;
+            if (isReconnect) {
+              void snapshot().then(
+                (fresh) => subscribeOptions.onResync?.(fresh),
+                (error) => log("debug", `mux snapshot re-bootstrap failed: ${error instanceof Error ? error.message : String(error)}`)
+              );
+            }
+            return;
+          }
+          const event = readEvent(line);
+          if (event) handler(event);
+        },
+        () => stream.destroy()
+      );
+      const onGone = () => {
+        if (socket !== stream) return;
+        socket = null;
+        stream.destroy();
+        scheduleReopen();
+      };
+      stream.on("error", onGone);
+      stream.on("close", onGone);
+      stream.write(
+        `${JSON.stringify({
+          id: `clio-sub-${kinds.join("+")}`,
+          method: "events.subscribe",
+          params: { subscriptions: kinds.map((kind) => ({ type: kind })) }
+        })}
+`
+      );
+    };
+    await open(false);
+    return {
+      close() {
+        closed = true;
+        if (retryTimer) clearTimeout(retryTimer);
+        retryTimer = null;
+        socket?.destroy();
+        socket = null;
+      }
+    };
+  };
+  return {
+    socketPath,
+    connected() {
+      return reachable;
+    },
+    server() {
+      return serverInfo;
+    },
+    cachedSnapshot() {
+      return snapshotCache;
+    },
+    async ping(pingOptions = {}) {
+      const result = await callObject("ping", {}, pingOptions.timeoutMs);
+      const info = readServerInfo(result);
+      serverInfo = info;
+      return info;
+    },
+    snapshot,
+    async paneCurrent(callerPaneId) {
+      const result = await callObject("pane.current", params({ caller_pane_id: callerPaneId }));
+      return readPane(result.pane);
+    },
+    async paneList(workspaceId) {
+      const result = await callObject("pane.list", params({ workspace_id: workspaceId }));
+      return readArray(result, "panes").map(readPane);
+    },
+    async paneSplit(request) {
+      const result = await callObject(
+        "pane.split",
+        params({
+          direction: request.direction,
+          target_pane_id: request.targetPaneId,
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          env: request.env,
+          focus: request.focus ?? false,
+          ratio: request.ratio
+        })
+      );
+      return readPane(result.pane);
+    },
+    async paneRename(paneId, label) {
+      await call("pane.rename", { pane_id: paneId, label });
+    },
+    async paneClose(paneId) {
+      await call("pane.close", { pane_id: paneId });
+    },
+    async paneLayout(paneId) {
+      const result = await callObject("pane.layout", params({ pane_id: paneId }));
+      const layout = asRecord(result.layout);
+      if (!layout) throw new MuxError("protocol", "mux pane.layout returned no layout");
+      const ids = [];
+      for (const entry of readArray(layout, "panes")) {
+        const pane = asRecord(entry);
+        const id = pane ? pane.pane_id : void 0;
+        if (typeof id === "string") ids.push(id);
+      }
+      return ids;
+    },
+    async worktreeList(request = {}) {
+      const result = await callObject("worktree.list", params({ workspace_id: request.workspaceId, cwd: request.cwd }));
+      return { source: readWorktreeSource(result.source), worktrees: readArray(result, "worktrees").map(readWorktree) };
+    },
+    async worktreeCreate(request) {
+      const result = await callObject(
+        "worktree.create",
+        params({
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          branch: request.branch,
+          base: request.base,
+          path: request.path,
+          label: request.label,
+          focus: request.focus ?? false
+        })
+      );
+      const workspace = asRecord(result.workspace);
+      if (!workspace) throw new MuxError("protocol", "mux worktree.create returned no workspace");
+      return {
+        workspaceId: requireString(workspace, "workspace_id", "workspace"),
+        tab: readTab(result.tab),
+        rootPane: readPane(result.root_pane),
+        worktree: readWorktree(result.worktree)
+      };
+    },
+    async worktreeOpen(request) {
+      const result = await callObject(
+        "worktree.open",
+        params({
+          workspace_id: request.workspaceId,
+          cwd: request.cwd,
+          branch: request.branch,
+          path: request.path,
+          label: request.label,
+          focus: request.focus ?? false
+        })
+      );
+      const workspace = asRecord(result.workspace);
+      if (!workspace) throw new MuxError("protocol", "mux worktree.open returned no workspace");
+      return {
+        workspaceId: requireString(workspace, "workspace_id", "workspace"),
+        tab: readTab(result.tab),
+        rootPane: readPane(result.root_pane),
+        worktree: readWorktree(result.worktree),
+        alreadyOpen: result.already_open === true
+      };
+    },
+    async worktreeRemove(workspaceId, removeOptions = {}) {
+      const result = await callObject("worktree.remove", {
+        workspace_id: workspaceId,
+        force: removeOptions.force ?? false
+      });
+      return {
+        workspaceId: requireString(result, "workspace_id", "worktree.remove"),
+        path: requireString(result, "path", "worktree.remove"),
+        forced: result.forced === true
+      };
+    },
+    async paneSendText(paneId, text) {
+      await call("pane.send_text", { pane_id: paneId, text });
+    },
+    async paneReportAgent(request) {
+      await call(
+        "pane.report_agent",
+        params({
+          pane_id: request.paneId,
+          source: request.source,
+          agent: request.agent,
+          state: request.state,
+          message: request.message
+        })
+      );
+    },
+    async paneReportMetadata(request) {
+      await call(
+        "pane.report_metadata",
+        params({
+          pane_id: request.paneId,
+          source: request.source,
+          agent: request.agent,
+          title: request.title,
+          display_agent: request.displayAgent,
+          tokens: request.tokens,
+          state_labels: request.stateLabels,
+          ttl_ms: request.ttlMs
+        })
+      );
+    },
+    async notificationShow(request) {
+      const result = await callObject(
+        "notification.show",
+        params({ title: request.title, body: request.body, sound: request.sound })
+      );
+      return {
+        shown: result.shown === true,
+        reason: optionalString(result, "reason") ?? (result.shown === true ? "shown" : "unknown")
+      };
+    },
+    subscribe,
+    async close() {
+      disposed = true;
+      reachable = false;
+    }
+  };
+}
+
+// src/domains/mux/detect.ts
+var PING_TIMEOUT_MS = 1e3;
+function herdrConfigDir(env) {
+  const xdg = env.XDG_CONFIG_HOME;
+  if (typeof xdg === "string" && xdg.length > 0) return join2(xdg, "herdr");
+  const home = typeof env.HOME === "string" && env.HOME.length > 0 ? env.HOME : homedir2();
+  return join2(home, ".config", "herdr");
+}
+function resolveSocketCandidates(env) {
+  const candidates = [];
+  const explicit = env.HERDR_SOCKET_PATH;
+  if (typeof explicit === "string" && explicit.length > 0) candidates.push(explicit);
+  const configDir = herdrConfigDir(env);
+  const session = env.HERDR_SESSION;
+  if (typeof session === "string" && session.length > 0) {
+    candidates.push(join2(configDir, "sessions", session, "herdr.sock"));
+  }
+  candidates.push(join2(configDir, "herdr.sock"));
+  return [...new Set(candidates)];
+}
+function readSelfLocation(env) {
+  const read = (key) => {
+    const value = env[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+  };
+  return {
+    workspaceId: read("HERDR_WORKSPACE_ID"),
+    tabId: read("HERDR_TAB_ID"),
+    paneId: read("HERDR_PANE_ID")
+  };
+}
+function none(reason, candidates = []) {
+  return {
+    mode: "none",
+    socketPath: null,
+    server: null,
+    self: { workspaceId: null, tabId: null, paneId: null },
+    candidates,
+    reason
+  };
+}
+async function detectMux(options = {}) {
+  const env = options.env ?? process.env;
+  const enabled = options.enabled ?? "auto";
+  const log = options.log ?? (() => void 0);
+  if (enabled === "off") {
+    return { detection: none("panes are turned off"), client: null };
+  }
+  if (enabled === "embedded") {
+    return { detection: none("embedded mode is not implemented yet; it ships in phase 5"), client: null };
+  }
+  if (env.HERDR_ENV !== "1") {
+    return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };
+  }
+  const candidates = resolveSocketCandidates(env);
+  const openClient = options.openClient ?? ((socketPath) => createMuxClient({ socketPath, log }));
+  const pingTimeoutMs = options.pingTimeoutMs ?? PING_TIMEOUT_MS;
+  for (const socketPath of candidates) {
+    const client = openClient(socketPath);
+    try {
+      const server = await client.ping({ timeoutMs: pingTimeoutMs });
+      return {
+        detection: {
+          mode: "guest",
+          socketPath,
+          server,
+          self: readSelfLocation(env),
+          candidates,
+          reason: `guest mode on ${socketPath} (herdr ${server.version}, protocol ${server.protocol})`
+        },
+        client
+      };
+    } catch (error) {
+      log("debug", `mux ping ${socketPath} failed: ${error instanceof Error ? error.message : String(error)}`);
+      await client.close().catch(() => void 0);
+    }
+  }
+  return {
+    detection: none(
+      candidates.length > 0 ? `no herdr socket answered a ping: tried ${candidates.join(", ")}` : "no herdr socket candidates resolved",
+      candidates
+    ),
+    client: null
+  };
+}
+
+// src/domains/mux/extension.ts
+async function createMuxBundle(_context, options = {}) {
+  const log = options.log ?? (() => void 0);
+  const { detection, client } = await detectMux({
+    ...options.enabled ? { enabled: options.enabled } : {},
+    ...options.env ? { env: options.env } : {},
+    log
+  });
+  log(detection.mode === "none" ? "debug" : "info", `mux mode ${detection.mode}: ${detection.reason}`);
+  const runtime = createMuxRuntime({ detection, client, log });
+  const extension = {
+    async start() {
+      await runtime.start();
+    },
+    async stop() {
+      await runtime.stop();
+    }
+  };
+  return { extension, contract: runtime.contract };
+}
+
+// src/domains/mux/manifest.ts
+init_esm_shims();
+var MuxManifest = {
+  name: "mux",
+  dependsOn: []
+};
+
+// src/domains/mux/viewer-command.ts
+init_esm_shims();
+import { join as join3 } from "node:path";
+function clioCliEntryPath() {
+  return join3(resolvePackageRoot(), "dist/cli/index.js");
+}
+function watchViewerCommand(selectionPath, options = {}) {
+  const layout = options.dirs === void 0 ? [] : [
+    "--config-dir",
+    options.dirs.config,
+    "--data-dir",
+    options.dirs.data,
+    "--state-dir",
+    options.dirs.state,
+    "--cache-dir",
+    options.dirs.cache
+  ];
+  return [
+    options.execPath ?? process.execPath,
+    options.entryPath ?? clioCliEntryPath(),
+    "fleet",
+    "view",
+    ...layout,
+    "--watch",
+    selectionPath
+  ];
+}
+
+// src/domains/mux/yazi/event-stream.ts
+init_esm_shims();
+import { closeSync, openSync, readSync, statSync as statSync2 } from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+var YAZI_STREAM_POLL_MS = 250;
+var YAZI_STREAM_MAX_BYTES = 1024 * 1024;
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseYaziEventLine(line) {
+  const first = line.indexOf(",");
+  const second = first < 0 ? -1 : line.indexOf(",", first + 1);
+  const third = second < 0 ? -1 : line.indexOf(",", second + 1);
+  if (first <= 0 || second <= first + 1 || third <= second + 1) return null;
+  const kind = line.slice(0, first);
+  if (kind !== "cd" && kind !== "clio-pick") return null;
+  const receiver = line.slice(first + 1, second);
+  const sender = line.slice(second + 1, third);
+  try {
+    const body = JSON.parse(line.slice(third + 1));
+    if (kind === "cd") {
+      if (!record(body) || typeof body.url !== "string") return null;
+      const tab = body.tab;
+      if (typeof tab !== "number" && typeof tab !== "string") return null;
+      return { kind, receiver, sender, tab: String(tab), cwd: body.url };
+    }
+    if (!Array.isArray(body) || !body.every((value) => typeof value === "string")) return null;
+    return { kind, receiver, sender, values: body };
+  } catch {
+    return null;
+  }
+}
+function createYaziEventStream(options) {
+  const log = options.log ?? (() => void 0);
+  const now = options.now ?? Date.now;
+  const maxBytes = options.maxBytes ?? YAZI_STREAM_MAX_BYTES;
+  let offset = 0;
+  let carry = "";
+  let decoder = new StringDecoder("utf8");
+  let stopped = false;
+  let polling = false;
+  let interval = null;
+  let settleDone = () => {
+  };
+  const done = new Promise((resolve) => {
+    settleDone = resolve;
+  });
+  const state = {
+    bytesRead: 0,
+    linesRead: 0,
+    malformedLines: 0,
+    lastLineAt: null,
+    stopReason: null
+  };
+  const stop = (reason = "stopped") => {
+    if (stopped) return;
+    stopped = true;
+    state.stopReason = reason;
+    if (interval) clearInterval(interval);
+    interval = null;
+    log(reason === "size-cap" ? "warning" : "debug", `yazi event stream stopped (${reason}): ${options.path}`);
+    settleDone(reason);
+  };
+  const poll = async () => {
+    if (stopped || polling) return;
+    polling = true;
+    try {
+      if (!await options.isAlive()) {
+        stop("pane-gone");
+        return;
+      }
+      const stat = statSync2(options.path, { throwIfNoEntry: false });
+      if (!stat?.isFile()) {
+        stop("file-missing");
+        return;
+      }
+      if (stat.size > maxBytes) {
+        stop("size-cap");
+        return;
+      }
+      if (stat.size < offset) {
+        offset = 0;
+        carry = "";
+        decoder = new StringDecoder("utf8");
+      }
+      const remaining = stat.size - offset;
+      if (remaining <= 0) return;
+      const bytes = Buffer.allocUnsafe(remaining);
+      const fd = openSync(options.path, "r");
+      let read = 0;
+      try {
+        read = readSync(fd, bytes, 0, remaining, offset);
+      } finally {
+        closeSync(fd);
+      }
+      offset += read;
+      state.bytesRead += read;
+      const complete = `${carry}${decoder.write(bytes.subarray(0, read))}`.split("\n");
+      carry = complete.pop() ?? "";
+      for (const raw of complete) {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line.length === 0) continue;
+        const kind = line.slice(0, line.indexOf(","));
+        if (kind !== "cd" && kind !== "clio-pick") continue;
+        const event = parseYaziEventLine(line);
+        if (!event) {
+          state.malformedLines += 1;
+          continue;
+        }
+        state.linesRead += 1;
+        state.lastLineAt = now();
+        try {
+          options.onEvent(event);
+        } catch (error) {
+          log("warning", `yazi event consumer failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    } finally {
+      polling = false;
+    }
+  };
+  if (options.autoStart !== false) {
+    interval = setInterval(() => void poll(), options.pollMs ?? YAZI_STREAM_POLL_MS);
+    interval.unref();
+    void poll();
+  }
+  return { poll, stop, stats: () => ({ ...state }), done };
+}
+
+// src/domains/mux/yazi/session.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+function resolveYaziBinaries() {
+  const entry = findPinnedTool("yazi");
+  const status = entry ? toolStatus(entry) : null;
+  return {
+    yaziPath: status?.resolution.binaryPath ?? null,
+    yaPath: resolveToolBinary("ya").binaryPath,
+    missingYaziDetail: status ? describeResolution(status) : "yazi is not in the pinned tool registry"
+  };
+}
+function runYa(file, args, env) {
+  return new Promise((resolve) => {
+    const child = spawn(file, args, { env: { ...env }, stdio: "ignore" });
+    child.once("error", () => resolve(false));
+    child.once("exit", (code) => resolve(code === 0));
+  });
+}
+function readOptional(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function createYaziSession(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 sessionId = options.sessionId ?? randomUUID();
+  const sessionsDir = join4(cacheDir, "yazi", "sessions");
+  mkdirSync2(sessionsDir, { recursive: true });
+  const managedProfile = options.profileMode === "managed" ? (options.ensureProfile ?? ensureYaziProfile)({
+    yaPath: binaries.yaPath,
+    yaziPath: binaries.yaziPath,
+    profileDir: yaziProfileDir(cacheDir)
+  }) : null;
+  if (options.profileMode === "managed" && !managedProfile) {
+    return { status: "profile-error", reason: "Clio could not generate a valid managed Yazi profile" };
+  }
+  const streamPath = join4(sessionsDir, `${sessionId}.stream`);
+  const chooserPath = join4(sessionsDir, `${sessionId}.chooser`);
+  const cwdPath = join4(sessionsDir, `${sessionId}.cwd`);
+  const token2 = options.mode === "companion" ? options.pickToken ?? randomUUID() : null;
+  const env = {
+    ...managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {},
+    ...token2 ? { CLIO_YAZI_PICK_TOKEN: token2 } : {}
+  };
+  let argv;
+  let stdoutPath;
+  if (options.mode === "companion") {
+    writeFileSync2(streamPath, "");
+    argv = [binaries.yaziPath, "--local-events", "cd,clio-pick", "--remote-events", "clio-pick"];
+    stdoutPath = streamPath;
+  } else {
+    writeFileSync2(chooserPath, "");
+    writeFileSync2(cwdPath, "");
+    argv = [binaries.yaziPath, options.cwd, "--chooser-file", chooserPath, "--cwd-file", cwdPath];
+  }
+  const pane = await options.mux.openUtilityPane({
+    argv,
+    cwd: options.cwd,
+    label: "yazi",
+    ...Object.keys(env).length > 0 ? { env } : {},
+    ...stdoutPath ? { stdoutPath } : {}
+  });
+  if (!pane) return { status: "unavailable", reason: "pane host refused to open yazi" };
+  let paneCwd = options.cwd;
+  let instanceId = null;
+  let stream = null;
+  let chooserTimer = null;
+  let stopped = false;
+  const alive = () => options.mux.list().some((record2) => record2.ref.paneId === pane.paneId);
+  const stop = (reason) => {
+    if (stopped) return;
+    stopped = true;
+    if (chooserTimer) clearInterval(chooserTimer);
+    chooserTimer = null;
+    options.onStopped?.(reason);
+  };
+  if (options.mode === "companion") {
+    stream = createYaziEventStream({
+      path: streamPath,
+      isAlive: alive,
+      ...options.pollMs !== void 0 ? { pollMs: options.pollMs } : {},
+      ...options.log ? { log: options.log } : {},
+      onEvent: (event) => {
+        if (event.kind === "cd") {
+          paneCwd = event.cwd;
+          instanceId = event.sender;
+        }
+        options.onEvent(event);
+      }
+    });
+    void stream.done.then((reason) => stop(reason));
+  } else {
+    const pollChooser = () => {
+      if (stopped || alive()) return;
+      const raw = readOptional(chooserPath);
+      const cwd = readOptional(cwdPath).trim() || paneCwd;
+      paneCwd = cwd;
+      const paths = raw.length === 0 ? [] : raw.split("\n").filter((path) => path.length > 0);
+      options.onChooser({ paths, cwd });
+      stop("pane-gone");
+    };
+    chooserTimer = setInterval(pollChooser, options.pollMs ?? YAZI_STREAM_POLL_MS);
+    chooserTimer.unref();
+  }
+  const session = {
+    mode: options.mode,
+    pane,
+    token: token2,
+    profile: managedProfile,
+    snapshot: () => ({
+      mode: options.mode,
+      paneId: pane.paneId,
+      paneCwd,
+      instanceId,
+      lastLineAt: stream?.stats().lastLineAt ?? null,
+      streamPath: options.mode === "companion" ? streamPath : null,
+      chooserPath: options.mode === "chooser" ? chooserPath : null
+    }),
+    async pushCwd(cwd) {
+      if (!instanceId || !binaries.yaPath) return false;
+      const pushed = await (options.runYa ?? runYa)(binaries.yaPath, ["emit-to", instanceId, "cd", cwd], {
+        ...process.env,
+        ...managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {}
+      });
+      return pushed;
+    },
+    async close() {
+      stream?.stop();
+      stop("stopped");
+      await options.mux.closePane(pane.paneId);
+    }
+  };
+  return { status: "opened", session };
+}
+
+// src/domains/mux/index.ts
+function createMuxDomainModule(options) {
+  return {
+    manifest: MuxManifest,
+    createExtension: (context) => createMuxBundle(context, options)
+  };
+}
+
+export {
+  MUX_METHOD_MIN_PROTOCOL,
+  resolveSocketCandidates,
+  detectMux,
+  watchViewerCommand,
+  yaziProfileDir,
+  userYaziConfigDir,
+  resetYaziProfile,
+  inspectCurrentYaziProfile,
+  describeYaziProfile,
+  ensureYaziProfile,
+  resolveYaziBinaries,
+  createYaziSession,
+  createMuxDomainModule
+};
+//# sourceMappingURL=chunk-HZHHCK24.js.map