@botiverse/raft-computer 0.0.57 → 0.0.58

package/dist/index.js

@@ -5874,7 +5874,7 @@ var require_connect = __commonJS({
       const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions);
       timeout = timeout == null ? 1e4 : timeout;
       allowH2 = allowH2 != null ? allowH2 : false;
-      return function connect({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+      return function connect2({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
         let socket;
         if (protocol === "https:") {
           if (!tls) {
@@ -11552,7 +11552,7 @@ var require_client = __commonJS({
         tls,
         strictContentLength,
         maxCachedSessions,
-        connect: connect2,
+        connect: connect3,
         maxRequestsPerClient,
         localAddress,
         maxResponseSize,
@@ -11609,7 +11609,7 @@ var require_client = __commonJS({
         if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
           throw new InvalidArgumentError2("bodyTimeout must be a positive integer or zero");
         }
-        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
+        if (connect3 != null && typeof connect3 !== "function" && typeof connect3 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
@@ -11643,8 +11643,8 @@ var require_client = __commonJS({
           throw new InvalidArgumentError2("pingInterval must be a positive integer, greater or equal to 0");
         }
         super();
-        if (typeof connect2 !== "function") {
-          connect2 = buildConnector({
+        if (typeof connect3 !== "function") {
+          connect3 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
@@ -11652,14 +11652,14 @@ var require_client = __commonJS({
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect2
+            ...connect3
           });
         } else if (socketPath != null) {
-          const customConnect = connect2;
-          connect2 = (opts, callback) => customConnect({ ...opts, socketPath }, callback);
+          const customConnect = connect3;
+          connect3 = (opts, callback) => customConnect({ ...opts, socketPath }, callback);
         }
         this[kUrl] = util.parseOrigin(url);
-        this[kConnector] = connect2;
+        this[kConnector] = connect3;
         this[kPipelining] = pipelining != null ? pipelining : 1;
         this[kMaxHeadersSize] = maxHeaderSize;
         this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout;
@@ -11717,7 +11717,7 @@ var require_client = __commonJS({
         );
       }
       [kConnect](cb) {
-        connect(this);
+        connect2(this);
         this.once("connect", cb);
       }
       [kDispatch](opts, handler) {
@@ -11779,7 +11779,7 @@ var require_client = __commonJS({
         assert(client[kSize] === 0);
       }
     }
-    function connect(client) {
+    function connect2(client) {
       assert(!client[kConnecting]);
       assert(!client[kHTTPContext]);
       let { host, hostname, protocol, port } = client[kUrl];
@@ -11958,7 +11958,7 @@ var require_client = __commonJS({
           return;
         }
         if (!client[kHTTPContext]) {
-          connect(client);
+          connect2(client);
           return;
         }
         if (client[kHTTPContext].destroyed) {
@@ -12257,7 +12257,7 @@ var require_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect,
+        connect: connect2,
         connectTimeout,
         tls,
         maxCachedSessions,
@@ -12274,24 +12274,24 @@ var require_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
+        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect !== "function") {
-          connect = buildConnector({
+        if (typeof connect2 !== "function") {
+          connect2 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect
+            ...connect2
           });
         }
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this.on("connect", (origin2, targets) => {
@@ -12510,7 +12510,7 @@ var require_round_robin_pool = __commonJS({
       constructor(origin, {
         connections,
         factory = defaultFactory,
-        connect,
+        connect: connect2,
         connectTimeout,
         tls,
         maxCachedSessions,
@@ -12527,24 +12527,24 @@ var require_round_robin_pool = __commonJS({
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
+        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
-        if (typeof connect !== "function") {
-          connect = buildConnector({
+        if (typeof connect2 !== "function") {
+          connect2 = buildConnector({
             ...tls,
             maxCachedSessions,
             allowH2,
             socketPath,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
-            ...connect
+            ...connect2
           });
         }
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath };
+        this[kOptions] = { ...util.deepClone(options), connect: connect2, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this[kIndex] = -1;
@@ -12619,21 +12619,21 @@ var require_agent = __commonJS({
       return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
     }
     var Agent = class extends DispatcherBase {
-      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+      constructor({ factory = defaultFactory, maxOrigins = Infinity, connect: connect2, ...options } = {}) {
         if (typeof factory !== "function") {
           throw new InvalidArgumentError2("factory must be a function.");
         }
-        if (connect != null && typeof connect !== "function" && typeof connect !== "object") {
+        if (connect2 != null && typeof connect2 !== "function" && typeof connect2 !== "object") {
           throw new InvalidArgumentError2("connect must be a function or an object");
         }
         if (typeof maxOrigins !== "number" || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
           throw new InvalidArgumentError2("maxOrigins must be a number greater than 0");
         }
         super();
-        if (connect && typeof connect !== "function") {
-          connect = { ...connect };
+        if (connect2 && typeof connect2 !== "function") {
+          connect2 = { ...connect2 };
         }
-        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect };
+        this[kOptions] = { ...util.deepClone(options), maxOrigins, connect: connect2 };
         this[kFactory] = factory;
         this[kClients] = /* @__PURE__ */ new Map();
         this[kOrigins] = /* @__PURE__ */ new Set();
@@ -13432,16 +13432,16 @@ var require_proxy_agent = __commonJS({
     }
     var Http1ProxyWrapper = class extends DispatcherBase {
       #client;
-      constructor(proxyUrl, { headers = {}, connect, factory }) {
+      constructor(proxyUrl, { headers = {}, connect: connect2, factory }) {
         if (!proxyUrl) {
           throw new InvalidArgumentError2("Proxy URL is mandatory");
         }
         super();
         this[kProxyHeaders] = headers;
         if (factory) {
-          this.#client = factory(proxyUrl, { connect });
+          this.#client = factory(proxyUrl, { connect: connect2 });
         } else {
-          this.#client = new Client(proxyUrl, { connect });
+          this.#client = new Client(proxyUrl, { connect: connect2 });
         }
       }
       [kDispatch](opts, handler) {
@@ -13502,7 +13502,7 @@ var require_proxy_agent = __commonJS({
         } else if (username && password) {
           this[kProxyHeaders]["proxy-authorization"] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString("base64")}`;
         }
-        const connect = buildConnector({ ...opts.proxyTls });
+        const connect2 = buildConnector({ ...opts.proxyTls });
         this[kConnectEndpoint] = buildConnector({ ...opts.requestTls });
         const agentFactory = opts.factory || defaultAgentFactory;
         const factory = (origin2, options) => {
@@ -13510,7 +13510,7 @@ var require_proxy_agent = __commonJS({
           if (this[kProxy].protocol === "socks5:" || this[kProxy].protocol === "socks:") {
             return new Socks5ProxyAgent(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect,
+              connect: connect2,
               factory: agentFactory,
               username: opts.username || username,
               password: opts.password || password,
@@ -13520,7 +13520,7 @@ var require_proxy_agent = __commonJS({
           if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
             return new Http1ProxyWrapper(this[kProxy].uri, {
               headers: this[kProxyHeaders],
-              connect,
+              connect: connect2,
               factory: agentFactory
             });
           }
@@ -13529,7 +13529,7 @@ var require_proxy_agent = __commonJS({
         if (protocol === "socks5:" || protocol === "socks:") {
           this[kClient] = null;
         } else {
-          this[kClient] = clientFactory(url, { connect });
+          this[kClient] = clientFactory(url, { connect: connect2 });
         }
         this[kAgent] = new Agent({
           ...opts,
@@ -14139,7 +14139,7 @@ var require_h2c_client = __commonJS({
             "h2c-client: Only h2c protocol is supported"
           );
         }
-        const { connect, maxConcurrentStreams, pipelining, ...opts } = clientOpts ?? {};
+        const { connect: connect2, maxConcurrentStreams, pipelining, ...opts } = clientOpts ?? {};
         let defaultMaxConcurrentStreams = 100;
         let defaultPipelining = 100;
         if (maxConcurrentStreams != null && Number.isInteger(maxConcurrentStreams) && maxConcurrentStreams > 0) {
@@ -15328,10 +15328,10 @@ var require_api_connect = __commonJS({
         }
       }
     };
-    function connect(opts, callback) {
+    function connect2(opts, callback) {
       if (callback === void 0) {
         return new Promise((resolve2, reject) => {
-          connect.call(this, opts, (err, data) => {
+          connect2.call(this, opts, (err, data) => {
             return err ? reject(err) : resolve2(data);
           });
         });
@@ -15348,7 +15348,7 @@ var require_api_connect = __commonJS({
         queueMicrotask(() => callback(err, { opaque }));
       }
     }
-    module.exports = connect;
+    module.exports = connect2;
   }
 });
 
@@ -16617,8 +16617,8 @@ var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@7.24.8/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
     init_esm_shims();
-    var { writeFile: writeFile12, readFile: readFile15, mkdir: mkdir15 } = __require("fs/promises");
-    var { dirname: dirname13, resolve: resolve2 } = __require("path");
+    var { writeFile: writeFile12, readFile: readFile15, mkdir: mkdir16 } = __require("fs/promises");
+    var { dirname: dirname14, resolve: resolve2 } = __require("path");
     var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("timers");
     var { InvalidArgumentError: InvalidArgumentError2, UndiciError } = require_errors();
     var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -16849,7 +16849,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError2("Snapshot path is required");
         }
         const resolvedPath = resolve2(path3);
-        await mkdir15(dirname13(resolvedPath), { recursive: true });
+        await mkdir16(dirname14(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
           snapshot
@@ -29193,11 +29193,11 @@ var require_mtime_precision = __commonJS({
     function probe(file, fs, callback) {
       const cachedPrecision = fs[cacheSymbol];
       if (cachedPrecision) {
-        return fs.stat(file, (err, stat4) => {
+        return fs.stat(file, (err, stat5) => {
           if (err) {
             return callback(err);
           }
-          callback(null, stat4.mtime, cachedPrecision);
+          callback(null, stat5.mtime, cachedPrecision);
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
@@ -29205,13 +29205,13 @@ var require_mtime_precision = __commonJS({
         if (err) {
           return callback(err);
         }
-        fs.stat(file, (err2, stat4) => {
+        fs.stat(file, (err2, stat5) => {
           if (err2) {
             return callback(err2);
           }
-          const precision = stat4.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+          const precision = stat5.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
           Object.defineProperty(fs, cacheSymbol, { value: precision });
-          callback(null, stat4.mtime, precision);
+          callback(null, stat5.mtime, precision);
         });
       });
     }
@@ -29266,14 +29266,14 @@ var require_lockfile = __commonJS({
         if (options.stale <= 0) {
           return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
         }
-        options.fs.stat(lockfilePath, (err2, stat4) => {
+        options.fs.stat(lockfilePath, (err2, stat5) => {
           if (err2) {
             if (err2.code === "ENOENT") {
               return acquireLock(file, { ...options, stale: 0 }, callback);
             }
             return callback(err2);
           }
-          if (!isLockStale(stat4, options)) {
+          if (!isLockStale(stat5, options)) {
             return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file }));
           }
           removeLock(file, options, (err3) => {
@@ -29285,8 +29285,8 @@ var require_lockfile = __commonJS({
         });
       });
     }
-    function isLockStale(stat4, options) {
-      return stat4.mtime.getTime() < Date.now() - options.stale;
+    function isLockStale(stat5, options) {
+      return stat5.mtime.getTime() < Date.now() - options.stale;
     }
     function removeLock(file, options, callback) {
       options.fs.rmdir(getLockFile(file, options), (err) => {
@@ -29304,7 +29304,7 @@ var require_lockfile = __commonJS({
       lock2.updateDelay = lock2.updateDelay || options.update;
       lock2.updateTimeout = setTimeout(() => {
         lock2.updateTimeout = null;
-        options.fs.stat(lock2.lockfilePath, (err, stat4) => {
+        options.fs.stat(lock2.lockfilePath, (err, stat5) => {
           const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
           if (err) {
             if (err.code === "ENOENT" || isOverThreshold) {
@@ -29313,7 +29313,7 @@ var require_lockfile = __commonJS({
             lock2.updateDelay = 1e3;
             return updateLock(file, options);
           }
-          const isMtimeOurs = lock2.mtime.getTime() === stat4.mtime.getTime();
+          const isMtimeOurs = lock2.mtime.getTime() === stat5.mtime.getTime();
           if (!isMtimeOurs) {
             return setLockAsCompromised(
               file,
@@ -29438,11 +29438,11 @@ var require_lockfile = __commonJS({
         if (err) {
           return callback(err);
         }
-        options.fs.stat(getLockFile(file2, options), (err2, stat4) => {
+        options.fs.stat(getLockFile(file2, options), (err2, stat5) => {
           if (err2) {
             return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
           }
-          return callback(null, !isLockStale(stat4, options));
+          return callback(null, !isLockStale(stat5, options));
         });
       });
     }
@@ -30011,6 +30011,13 @@ function servicePidReadFallback(slockHome) {
 function serviceLogPath(slockHome) {
   return path2.join(serviceRunDir(slockHome), "service.log");
 }
+function serviceSocketPath(slockHome) {
+  return path2.join(computerDir(slockHome), "run", "service.sock");
+}
+function serviceWindowsPipeName(slockHome) {
+  const hash = createHash("sha256").update(computerDir(slockHome)).digest("hex").slice(0, 16);
+  return `\\\\.\\pipe\\slock-computer-${hash}`;
+}
 function serviceVersionPath(slockHome) {
   return path2.join(computerDir(slockHome), "service-version.json");
 }
@@ -30505,8 +30512,8 @@ async function runAttach(opts) {
 // src/setup.ts
 init_esm_shims();
 var import_undici3 = __toESM(require_undici(), 1);
-import { chmod as chmod5, mkdir as mkdir11, readFile as readFile10, rename as rename4, rm as rm3, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { chmod as chmod6, mkdir as mkdir12, readFile as readFile11, rename as rename4, rm as rm3, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname11 } from "path";
 
 // src/lib/migration.ts
 init_esm_shims();
@@ -31032,8 +31039,8 @@ function readComputerVersion(moduleUrl = import.meta.url) {
 var COMPUTER_VERSION = readComputerVersion();
 
 // src/service.ts
-import { mkdir as mkdir10, readFile as readFile9, writeFile as writeFile9, open, rename as rename3 } from "fs/promises";
-import { dirname as dirname9, join as joinPath } from "path";
+import { mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9, open, rename as rename3 } from "fs/promises";
+import { dirname as dirname10, join as joinPath } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cleanup.ts
@@ -32081,6 +32088,493 @@ async function resolveAndRunSeaUpgrade(opts) {
   return { ...result, targetVersion };
 }
 
+// src/internal/ipc-server.ts
+init_esm_shims();
+import { connect, createServer } from "net";
+import { chmod as chmod5, mkdir as mkdir10, stat as stat4, unlink as unlink5 } from "fs/promises";
+import { dirname as dirname9 } from "path";
+
+// src/internal/ipc-codec.ts
+init_esm_shims();
+
+// src/lib/types.ts
+init_esm_shims();
+var ServiceClientError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "ServiceClientError";
+    this.code = code;
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var StateReaderError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "StateReaderError";
+    this.code = code;
+  }
+};
+
+// src/internal/ipc-codec.ts
+var MAX_FRAME_BYTES = 1024 * 1024;
+function encodeFrame(payload) {
+  const json = Buffer.from(JSON.stringify(payload), "utf8");
+  if (json.length > MAX_FRAME_BYTES) {
+    throw new ServiceClientError(
+      "IPC_FRAME_TOO_LARGE",
+      `outgoing frame ${json.length} bytes exceeds MAX_FRAME_BYTES ${MAX_FRAME_BYTES}`
+    );
+  }
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(json.length, 0);
+  return Buffer.concat([header, json]);
+}
+var FrameDecoder = class {
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.buffer = this.buffer.length === 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+  }
+  drain() {
+    const frames = [];
+    while (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32BE(0);
+      if (length > MAX_FRAME_BYTES) {
+        throw new ServiceClientError(
+          "IPC_FRAME_TOO_LARGE",
+          `incoming frame ${length} bytes exceeds MAX_FRAME_BYTES ${MAX_FRAME_BYTES}`
+        );
+      }
+      if (this.buffer.length < 4 + length) break;
+      const body = this.buffer.subarray(4, 4 + length);
+      this.buffer = this.buffer.subarray(4 + length);
+      let parsed;
+      try {
+        parsed = JSON.parse(body.toString("utf8"));
+      } catch (cause) {
+        throw new ServiceClientError("IPC_MALFORMED_FRAME", "frame body is not valid UTF-8 JSON", cause);
+      }
+      frames.push(parsed);
+    }
+    return frames;
+  }
+};
+
+// src/internal/ipc-server.ts
+var SUPPORTED_PROTOCOL_VERSIONS = [1];
+var SERVICE_VERSION = "0.0.0";
+function resolveTransportPath(installRoot) {
+  return process.platform === "win32" ? serviceWindowsPipeName(installRoot) : serviceSocketPath(installRoot);
+}
+async function probeAndClearStaleSocket(socketPath) {
+  if (process.platform === "win32") return;
+  let isSocket = false;
+  try {
+    const stats = await stat4(socketPath);
+    isSocket = stats.isSocket();
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return;
+    return;
+  }
+  if (!isSocket) {
+    return;
+  }
+  const outcome = await new Promise((resolve2) => {
+    const probe = connect({ path: socketPath });
+    const finalize = (o) => {
+      probe.removeAllListeners();
+      probe.destroy();
+      resolve2(o);
+    };
+    const timer = setTimeout(() => finalize("indeterminate"), 500);
+    probe.once("connect", () => {
+      clearTimeout(timer);
+      finalize("connected");
+    });
+    probe.once("error", (err) => {
+      clearTimeout(timer);
+      finalize(err.code === "ECONNREFUSED" ? "refused" : "indeterminate");
+    });
+  });
+  if (outcome !== "refused") {
+    return;
+  }
+  try {
+    await unlink5(socketPath);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function createIpcServer(options) {
+  const { installRoot, handlers } = options;
+  const transportPath = resolveTransportPath(installRoot);
+  const connections = /* @__PURE__ */ new Set();
+  let server = null;
+  let closed = false;
+  function dispatchFrame(conn, frame) {
+    if (!isRecord(frame) || typeof frame.type !== "string") {
+      writeError(conn, null, "IPC_MALFORMED_FRAME", "frame is missing required `type` field");
+      conn.socket.destroy();
+      return;
+    }
+    if (!conn.handshakeDone) {
+      handleHello(conn, frame);
+      return;
+    }
+    if (frame.type === "request") {
+      void handleRequest(conn, frame);
+      return;
+    }
+    if (frame.type === "ping") {
+      conn.socket.write(encodeFrame({ type: "pong" }));
+      return;
+    }
+    if (frame.type === "pong") {
+      return;
+    }
+  }
+  function handleHello(conn, frame) {
+    if (frame.type !== "hello") {
+      conn.socket.write(encodeFrame({
+        type: "hello-reject",
+        reason: "IPC_PROTOCOL_HANDSHAKE_FAILED",
+        message: `expected hello, got \`${String(frame.type)}\``
+      }));
+      conn.socket.destroy();
+      return;
+    }
+    const requested = Number(frame.protocolVersion);
+    if (!SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
+      conn.socket.write(encodeFrame({
+        type: "hello-reject",
+        reason: "IPC_PROTOCOL_VERSION_UNSUPPORTED",
+        supported: [...SUPPORTED_PROTOCOL_VERSIONS]
+      }));
+      conn.socket.destroy();
+      return;
+    }
+    conn.handshakeDone = true;
+    conn.socket.write(encodeFrame({
+      type: "hello-ack",
+      protocolVersion: requested,
+      serviceVersion: SERVICE_VERSION
+    }));
+  }
+  async function handleRequest(conn, frame) {
+    const id = typeof frame.id === "string" ? frame.id : "";
+    const method = typeof frame.method === "string" ? frame.method : "";
+    if (id === "" || method === "") {
+      writeError(conn, id || null, "IPC_MALFORMED_FRAME", "request missing `id` or `method`");
+      return;
+    }
+    const handler = handlers[method];
+    if (!handler) {
+      writeError(conn, id, "IPC_MALFORMED_FRAME", `unknown method \`${method}\``);
+      return;
+    }
+    try {
+      const result = await handler(
+        frame.params
+      );
+      if (conn.socket.destroyed) return;
+      conn.socket.write(encodeFrame({ type: "response", id, result }));
+    } catch (error) {
+      if (conn.socket.destroyed) return;
+      const { code, message } = normalizeHandlerError(error);
+      writeError(conn, id, code, message);
+    }
+  }
+  function writeError(conn, id, code, message) {
+    if (conn.socket.destroyed) return;
+    try {
+      conn.socket.write(encodeFrame({
+        type: "response",
+        id: id ?? "",
+        error: { code, message }
+      }));
+    } catch {
+    }
+  }
+  function attachConnection(socket) {
+    if (closed) {
+      socket.destroy();
+      return;
+    }
+    const conn = {
+      socket,
+      decoder: new FrameDecoder(),
+      handshakeDone: false
+    };
+    connections.add(conn);
+    socket.on("data", (chunk) => {
+      try {
+        conn.decoder.push(chunk);
+        const frames = conn.decoder.drain();
+        for (const frame of frames) dispatchFrame(conn, frame);
+      } catch (error) {
+        const { code, message } = normalizeHandlerError(error);
+        writeError(conn, null, code, message);
+        socket.destroy();
+      }
+    });
+    socket.on("close", () => connections.delete(conn));
+    socket.on("error", () => {
+    });
+  }
+  return {
+    async listen() {
+      if (server) throw new Error("ipc-server: listen() called twice");
+      if (process.platform !== "win32") {
+        await mkdir10(dirname9(transportPath), { recursive: true });
+        await probeAndClearStaleSocket(transportPath);
+      }
+      const s = createServer(attachConnection);
+      server = s;
+      await new Promise((resolve2, reject) => {
+        const onError = (err) => {
+          s.removeListener("error", onError);
+          reject(err);
+        };
+        s.once("error", onError);
+        s.listen(transportPath, () => {
+          s.removeListener("error", onError);
+          resolve2();
+        });
+      });
+      if (process.platform !== "win32") {
+        try {
+          await chmod5(transportPath, 384);
+        } catch {
+        }
+      }
+      return transportPath;
+    },
+    broadcast(event) {
+      if (closed) return;
+      const payload = encodeFrame({ type: "event", kind: event.kind, payload: event.payload });
+      for (const conn of connections) {
+        if (!conn.handshakeDone || conn.socket.destroyed) continue;
+        try {
+          conn.socket.write(payload);
+        } catch {
+        }
+      }
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      const s = server;
+      server = null;
+      for (const conn of connections) conn.socket.destroy();
+      connections.clear();
+      if (s) {
+        await new Promise((resolve2) => {
+          s.close(() => resolve2());
+        });
+      }
+    }
+  };
+}
+function normalizeHandlerError(error) {
+  if (error instanceof ServiceClientError) {
+    return { code: error.code, message: error.message };
+  }
+  const message = error instanceof Error ? error.message : "handler threw non-Error value";
+  return { code: "IPC_MALFORMED_FRAME", message };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isErrnoException(value) {
+  return value instanceof Error && typeof value.code === "string";
+}
+
+// src/lib/readers.ts
+init_esm_shims();
+
+// src/status.ts
+init_esm_shims();
+import { readFile as readFile9 } from "fs/promises";
+async function readUserSession(path3) {
+  try {
+    const parsed = JSON.parse(await readFile9(path3, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { state: "present", session: parsed, error: null };
+    }
+    return { state: "invalid", session: null, error: "not a JSON object" };
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return { state: "missing", session: null, error: null };
+    }
+    return {
+      state: "invalid",
+      session: null,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+async function pidStatus(pidfile) {
+  const pid = await readPidfileAt(pidfile);
+  return pid !== null && isProcessAlive2(pid) ? { running: true, pid } : { running: false };
+}
+async function serviceState(slockHome) {
+  const { pid } = await findLiveServicePidReadOnly(slockHome);
+  return pid !== null ? { running: true, pid } : { running: false };
+}
+async function deriveHealth(slockHome, serverId, daemon) {
+  if (!daemon.running) return "offline";
+  if (await isDegraded(slockHome, serverId)) return "degraded";
+  return "ok";
+}
+async function buildStatusReport(installRoot) {
+  const sessionRead = await readUserSession(userSessionPath(installRoot));
+  const session = sessionRead.session;
+  const attachments = await listServerAttachments(installRoot);
+  const service = {
+    ...await serviceState(installRoot),
+    logPath: serviceLogPath(installRoot)
+  };
+  const servers = [];
+  for (const a of attachments) {
+    const daemon = await pidStatus(serverRunnerPidPath(installRoot, a.serverId));
+    servers.push({
+      serverId: a.serverId,
+      serverSlug: a.serverSlug ?? null,
+      serverMachineId: a.serverMachineId,
+      serverUrl: a.serverUrl,
+      attachedAt: a.attachedAt ?? null,
+      serverRunnerLogPath: serverRunnerLogPath(installRoot, a.serverId),
+      daemon,
+      health: await deriveHealth(installRoot, a.serverId, daemon)
+    });
+  }
+  const loggedIn = session?.kind === "user-session" && typeof session.accessToken === "string" && session.accessToken.length > 0;
+  return {
+    slockHome: installRoot,
+    loggedIn,
+    userId: session ? str(session.userId) : null,
+    loginServerUrl: session ? str(session.serverUrl) : null,
+    userSessionError: sessionRead.state === "invalid" ? sessionRead.error : null,
+    service,
+    servers
+  };
+}
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+async function runStatus(opts) {
+  const report = await buildStatusReport(resolveSlockHome());
+  if (opts.json) {
+    info(JSON.stringify(report, null, 2));
+    return;
+  }
+  info("");
+  info(`SLOCK_HOME:   ${report.slockHome}`);
+  const loginDetail = report.userSessionError ? "no \u2014 user session file is invalid; re-run `slock-computer login`" : report.loggedIn ? `yes (user ${report.userId ?? "?"})` : "no \u2014 run `slock-computer login`";
+  info(
+    `Logged in:    ${loginDetail}`
+  );
+  if (report.loginServerUrl) info(`Login server: ${report.loginServerUrl}`);
+  info(
+    `Service:   ${report.service.running ? `running (pid ${report.service.pid})` : "stopped \u2014 run `slock-computer start`"}`
+  );
+  info(`Service log: ${report.service.logPath}`);
+  info("");
+  if (report.servers.length === 0) {
+    info("Attachments:  none \u2014 run `slock-computer attach /<serverSlug>` (e.g. `/myserver`).");
+  } else {
+    info("Attachments:");
+    info(`  ${pad("SERVER", 24)}${pad("HEALTH", 12)}${pad("DAEMON", 24)}${pad("MACHINE", 38)}URL`);
+    for (const s of report.servers) {
+      const dcol = s.daemon.running ? `running (pid ${s.daemon.pid})` : "stopped";
+      info(
+        `  ${pad(formatServerSlugDisplay(s.serverSlug), 24)}${pad(s.health, 12)}${pad(dcol, 24)}${pad(s.serverMachineId, 38)}${s.serverUrl}`
+      );
+      info(`    Server runner log: ${s.serverRunnerLogPath}`);
+    }
+    if (report.servers.some((s) => s.health === "degraded")) {
+      info("");
+      info(
+        "  Note: one or more servers are `degraded` (repeated crashes; auto-restart paused)."
+      );
+      info(
+        "  Run `slock-computer doctor /<serverSlug> --reset-health` (e.g. `/myserver`) after fixing the underlying issue."
+      );
+    }
+  }
+  info("");
+}
+
+// src/lib/readers.ts
+async function readServiceStatus(installRoot) {
+  return buildStatusReport(installRoot);
+}
+async function readRunnerStatus(installRoot, serverId) {
+  const report = await buildStatusReport(installRoot);
+  const server = report.servers.find((s) => s.serverId === serverId);
+  if (!server) {
+    throw new StateReaderError(
+      "NOT_ATTACHED",
+      `Server ${serverId} is not attached to this Computer.`
+    );
+  }
+  const attachment = await readServerAttachment(installRoot, serverId);
+  if (!attachment) {
+    throw new StateReaderError(
+      "INVALID_ATTACHMENT",
+      `Attachment for server ${serverId} is missing or invalid.`
+    );
+  }
+  const client = new RunnersClient(attachment.serverUrl, attachment.apiKey);
+  const result = await client.list();
+  if (result.status === "success") {
+    return { status: "ok", server, whitelist: result.whitelist, runners: result.runners };
+  }
+  if (result.status === "unauthorized") {
+    return { status: "unauthorized", server };
+  }
+  return { status: "error", server, code: result.code };
+}
+async function listRunners(installRoot, opts = {}) {
+  const all = await listServerAttachments(installRoot);
+  let subset = all;
+  if (opts.serverId !== void 0) {
+    const found = all.find((a) => a.serverId === opts.serverId);
+    if (!found) {
+      throw new StateReaderError(
+        "NOT_ATTACHED",
+        `Server ${opts.serverId} is not attached to this Computer.`
+      );
+    }
+    subset = [found];
+  }
+  const servers = [];
+  for (const a of subset) {
+    const client = new RunnersClient(a.serverUrl, a.apiKey);
+    const result = await client.list();
+    const idCols = { serverId: a.serverId, serverSlug: a.serverSlug ?? null };
+    if (result.status === "success") {
+      servers.push({
+        ...idCols,
+        status: "ok",
+        whitelist: result.whitelist,
+        runners: result.runners
+      });
+    } else if (result.status === "unauthorized") {
+      servers.push({ ...idCols, status: "unauthorized" });
+    } else {
+      servers.push({ ...idCols, status: "error", code: result.code });
+    }
+  }
+  return { servers };
+}
+
 // src/service.ts
 var seaRequire = createRequire2(import.meta.url);
 var cachedIsSea;
@@ -32102,7 +32596,7 @@ function buildResidentSpawn(mode, serverId, selfEntry = process.argv[1] ?? "", e
 }
 var PARENT_LOCK_HELD_ENV_VAR = "SLOCK_COMPUTER_PARENT_MUTATION_LOCK_HELD";
 async function spawnDetachedService(slockHome) {
-  await mkdir10(serviceRunDir(slockHome), { recursive: true });
+  await mkdir11(serviceRunDir(slockHome), { recursive: true });
   const supLogFd = await open(serviceLogPath(slockHome), "a");
   const { command, args } = buildResidentSpawn("__service", null);
   const child = spawn2(command, args, {
@@ -32131,7 +32625,7 @@ async function ensureSeaRuntimePackageDir() {
   if (!isSeaBinary() || process.env.PI_PACKAGE_DIR) return;
   try {
     const dir = joinPath(resolveSlockHome(), "runtime-pkg");
-    await mkdir10(dir, { recursive: true });
+    await mkdir11(dir, { recursive: true });
     await writeFile9(
       joinPath(dir, "package.json"),
       `${JSON.stringify({ name: "slock-computer-sea-runtime", version: COMPUTER_VERSION })}
@@ -32327,10 +32821,10 @@ async function runServiceStartupRecovery(slockHome) {
 }
 async function resolveServiceIdentity() {
   const here = fileURLToPath2(import.meta.url);
-  const installRoot = dirname9(dirname9(here));
+  const installRoot = dirname10(dirname10(here));
   let version = null;
   try {
-    const raw = await readFile9(joinPath(installRoot, "package.json"), "utf8");
+    const raw = await readFile10(joinPath(installRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
       version = parsed.version;
@@ -32363,9 +32857,38 @@ async function writeServiceVersionEvidence(slockHome) {
     );
   }
 }
+async function startServiceIpcSeam(slockHome) {
+  const handlers = {
+    "service-status": async () => readServiceStatus(slockHome),
+    "runner-status": async ({ serverId }) => {
+      try {
+        return await readRunnerStatus(slockHome, serverId);
+      } catch (err) {
+        if (err instanceof StateReaderError) {
+          throw new ServiceClientError("IPC_MALFORMED_FRAME", `${err.code}: ${err.message}`);
+        }
+        throw err;
+      }
+    },
+    "list-runners": async () => listRunners(slockHome)
+  };
+  const ipc = createIpcServer({ installRoot: slockHome, handlers });
+  try {
+    const transportPath = await ipc.listen();
+    process.stderr.write(`Service: IPC seam listening at ${transportPath}
+`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `Service: IPC seam failed to bind (${msg}); continuing without typed-RPC surface.
+`
+    );
+  }
+  return ipc;
+}
 async function runService() {
   const slockHome = resolveSlockHome();
-  await mkdir10(serviceRunDir(slockHome), { recursive: true });
+  await mkdir11(serviceRunDir(slockHome), { recursive: true });
   await runServiceStartupRecovery(slockHome);
   await writePidfileAt(servicePidPath(slockHome), process.pid);
   await writeServiceVersionEvidence(slockHome);
@@ -32375,7 +32898,7 @@ async function runService() {
   const spawnChild = async (serverId) => {
     if (children.has(serverId)) return;
     const logPath = serverRunnerLogPath(slockHome, serverId);
-    await mkdir10(dirname9(logPath), { recursive: true });
+    await mkdir11(dirname10(logPath), { recursive: true });
     const logFd = await open(logPath, "a");
     const { command, args } = buildResidentSpawn("__run", serverId);
     const child = spawn2(command, args, {
@@ -32456,11 +32979,13 @@ async function runService() {
       if (!wanted.has(id)) killChild(handle);
     }
   };
+  const ipc = await startServiceIpcSeam(slockHome);
   let shuttingDown = false;
   const shutdown = () => {
     if (shuttingDown) return;
     shuttingDown = true;
     for (const handle of children.values()) killChild(handle);
+    void ipc.close();
     void clearPidfileAt(servicePidPath(slockHome)).then(() => process.exit(0));
   };
   process.on("SIGTERM", shutdown);
@@ -32586,7 +33111,7 @@ async function runDetach(serverId, serverLabel = serverId) {
 var USER_SESSION_EXPIRY_LEEWAY_MS = 3e4;
 async function readUserSessionAuth(slockHome) {
   try {
-    const parsed = JSON.parse(await readFile10(userSessionPath(slockHome), "utf8"));
+    const parsed = JSON.parse(await readFile11(userSessionPath(slockHome), "utf8"));
     return {
       accessToken: typeof parsed.accessToken === "string" ? parsed.accessToken : "",
       ...typeof parsed.serverUrl === "string" ? { serverUrl: parsed.serverUrl } : {}
@@ -32597,7 +33122,7 @@ async function readUserSessionAuth(slockHome) {
 }
 async function hasValidUserSession(slockHome) {
   try {
-    const parsed = JSON.parse(await readFile10(userSessionPath(slockHome), "utf8"));
+    const parsed = JSON.parse(await readFile11(userSessionPath(slockHome), "utf8"));
     return parsed.kind === "user-session" && typeof parsed.accessToken === "string" && parsed.accessToken.length > 0 && !isJwtExpired(parsed.accessToken);
   } catch {
     return false;
@@ -32617,7 +33142,7 @@ async function refreshUserSession(slockHome, serverUrl) {
   const file = userSessionPath(slockHome);
   let session;
   try {
-    session = JSON.parse(await readFile10(file, "utf8"));
+    session = JSON.parse(await readFile11(file, "utf8"));
   } catch {
     return false;
   }
@@ -32636,7 +33161,7 @@ async function refreshUserSession(slockHome, serverUrl) {
     if (res.status !== 200 || typeof body?.accessToken !== "string" || typeof body.refreshToken !== "string") {
       return false;
     }
-    await mkdir11(dirname10(file), { recursive: true });
+    await mkdir12(dirname11(file), { recursive: true });
     await writeFile10(
       tmpFile,
       JSON.stringify(
@@ -32654,7 +33179,7 @@ async function refreshUserSession(slockHome, serverUrl) {
       ),
       { mode: 384 }
     );
-    await chmod5(tmpFile, 384);
+    await chmod6(tmpFile, 384);
     await rename4(tmpFile, file);
     return true;
   } catch {
@@ -32964,122 +33489,6 @@ async function runSetup(opts, deps = {}) {
   });
 }
 
-// src/status.ts
-init_esm_shims();
-import { readFile as readFile11 } from "fs/promises";
-async function readUserSession(path3) {
-  try {
-    const parsed = JSON.parse(await readFile11(path3, "utf8"));
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return { state: "present", session: parsed, error: null };
-    }
-    return { state: "invalid", session: null, error: "not a JSON object" };
-  } catch (err) {
-    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
-      return { state: "missing", session: null, error: null };
-    }
-    return {
-      state: "invalid",
-      session: null,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function str(v) {
-  return typeof v === "string" && v.length > 0 ? v : null;
-}
-async function pidStatus(pidfile) {
-  const pid = await readPidfileAt(pidfile);
-  return pid !== null && isProcessAlive2(pid) ? { running: true, pid } : { running: false };
-}
-async function serviceState(slockHome) {
-  const { pid } = await findLiveServicePidReadOnly(slockHome);
-  return pid !== null ? { running: true, pid } : { running: false };
-}
-async function deriveHealth(slockHome, serverId, daemon) {
-  if (!daemon.running) return "offline";
-  if (await isDegraded(slockHome, serverId)) return "degraded";
-  return "ok";
-}
-async function buildStatusReport(installRoot) {
-  const sessionRead = await readUserSession(userSessionPath(installRoot));
-  const session = sessionRead.session;
-  const attachments = await listServerAttachments(installRoot);
-  const service = {
-    ...await serviceState(installRoot),
-    logPath: serviceLogPath(installRoot)
-  };
-  const servers = [];
-  for (const a of attachments) {
-    const daemon = await pidStatus(serverRunnerPidPath(installRoot, a.serverId));
-    servers.push({
-      serverId: a.serverId,
-      serverSlug: a.serverSlug ?? null,
-      serverMachineId: a.serverMachineId,
-      serverUrl: a.serverUrl,
-      attachedAt: a.attachedAt ?? null,
-      serverRunnerLogPath: serverRunnerLogPath(installRoot, a.serverId),
-      daemon,
-      health: await deriveHealth(installRoot, a.serverId, daemon)
-    });
-  }
-  const loggedIn = session?.kind === "user-session" && typeof session.accessToken === "string" && session.accessToken.length > 0;
-  return {
-    slockHome: installRoot,
-    loggedIn,
-    userId: session ? str(session.userId) : null,
-    loginServerUrl: session ? str(session.serverUrl) : null,
-    userSessionError: sessionRead.state === "invalid" ? sessionRead.error : null,
-    service,
-    servers
-  };
-}
-function pad(s, n) {
-  return s.length >= n ? s : s + " ".repeat(n - s.length);
-}
-async function runStatus(opts) {
-  const report = await buildStatusReport(resolveSlockHome());
-  if (opts.json) {
-    info(JSON.stringify(report, null, 2));
-    return;
-  }
-  info("");
-  info(`SLOCK_HOME:   ${report.slockHome}`);
-  const loginDetail = report.userSessionError ? "no \u2014 user session file is invalid; re-run `slock-computer login`" : report.loggedIn ? `yes (user ${report.userId ?? "?"})` : "no \u2014 run `slock-computer login`";
-  info(
-    `Logged in:    ${loginDetail}`
-  );
-  if (report.loginServerUrl) info(`Login server: ${report.loginServerUrl}`);
-  info(
-    `Service:   ${report.service.running ? `running (pid ${report.service.pid})` : "stopped \u2014 run `slock-computer start`"}`
-  );
-  info(`Service log: ${report.service.logPath}`);
-  info("");
-  if (report.servers.length === 0) {
-    info("Attachments:  none \u2014 run `slock-computer attach /<serverSlug>` (e.g. `/myserver`).");
-  } else {
-    info("Attachments:");
-    info(`  ${pad("SERVER", 24)}${pad("HEALTH", 12)}${pad("DAEMON", 24)}${pad("MACHINE", 38)}URL`);
-    for (const s of report.servers) {
-      const dcol = s.daemon.running ? `running (pid ${s.daemon.pid})` : "stopped";
-      info(
-        `  ${pad(formatServerSlugDisplay(s.serverSlug), 24)}${pad(s.health, 12)}${pad(dcol, 24)}${pad(s.serverMachineId, 38)}${s.serverUrl}`
-      );
-      info(`    Server runner log: ${s.serverRunnerLogPath}`);
-    }
-    if (report.servers.some((s) => s.health === "degraded")) {
-      info("");
-      info(
-        "  Note: one or more servers are `degraded` (repeated crashes; auto-restart paused)."
-      );
-      info(
-        "  Run `slock-computer doctor /<serverSlug> --reset-health` (e.g. `/myserver`) after fixing the underlying issue."
-      );
-    }
-  }
-  info("");
-}
-
 // src/runners.ts
 init_esm_shims();
 
@@ -33143,55 +33552,6 @@ async function resolveTargetAttachment(opts) {
   return a;
 }
 
-// src/lib/readers.ts
-init_esm_shims();
-
-// src/lib/types.ts
-init_esm_shims();
-var StateReaderError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "StateReaderError";
-    this.code = code;
-  }
-};
-
-// src/lib/readers.ts
-async function listRunners(installRoot, opts = {}) {
-  const all = await listServerAttachments(installRoot);
-  let subset = all;
-  if (opts.serverId !== void 0) {
-    const found = all.find((a) => a.serverId === opts.serverId);
-    if (!found) {
-      throw new StateReaderError(
-        "NOT_ATTACHED",
-        `Server ${opts.serverId} is not attached to this Computer.`
-      );
-    }
-    subset = [found];
-  }
-  const servers = [];
-  for (const a of subset) {
-    const client = new RunnersClient(a.serverUrl, a.apiKey);
-    const result = await client.list();
-    const idCols = { serverId: a.serverId, serverSlug: a.serverSlug ?? null };
-    if (result.status === "success") {
-      servers.push({
-        ...idCols,
-        status: "ok",
-        whitelist: result.whitelist,
-        runners: result.runners
-      });
-    } else if (result.status === "unauthorized") {
-      servers.push({ ...idCols, status: "unauthorized" });
-    } else {
-      servers.push({ ...idCols, status: "error", code: result.code });
-    }
-  }
-  return { servers };
-}
-
 // src/runners.ts
 async function runRunnersList(opts) {
   const serverId = await resolveTargetServerId({ server: opts.server });
@@ -33423,8 +33783,8 @@ init_esm_shims();
 
 // src/serviceState.ts
 init_esm_shims();
-import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile11, appendFile as appendFile3 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile11, appendFile as appendFile3 } from "fs/promises";
+import { dirname as dirname12 } from "path";
 
 // src/lib/state.ts
 init_esm_shims();
@@ -33459,7 +33819,7 @@ async function readServiceState(slockHome) {
 }
 async function writeServiceState(slockHome, file) {
   const path3 = serviceStatePath(slockHome);
-  await mkdir12(dirname11(path3), { recursive: true });
+  await mkdir13(dirname12(path3), { recursive: true });
   await writeFile11(path3, JSON.stringify(file), { mode: 384 });
 }
 function isCrashEntry(value) {
@@ -33477,7 +33837,7 @@ async function emitServiceStateTransition(slockHome, fromState, toState, trigger
   };
   try {
     const path3 = serviceLogPath(slockHome);
-    await mkdir12(dirname11(path3), { recursive: true });
+    await mkdir13(dirname12(path3), { recursive: true });
     await appendFile3(path3, JSON.stringify(entry) + "\n");
   } catch {
   }
@@ -33571,13 +33931,13 @@ async function runReset(opts) {
 // src/concurrency.ts
 init_esm_shims();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { mkdir as mkdir13 } from "fs/promises";
+import { mkdir as mkdir14 } from "fs/promises";
 import { join as join5 } from "path";
 var STALE_LOCK_THRESHOLD_MS = 6e4;
 async function withMutationLock(fn) {
   const slockHome = resolveSlockHome();
   const lockTarget = computerDir(slockHome);
-  await mkdir13(lockTarget, { recursive: true });
+  await mkdir14(lockTarget, { recursive: true });
   const lockfilePath = join5(lockTarget, ".lock");
   let release = null;
   try {
@@ -33618,11 +33978,11 @@ async function withMutationLock(fn) {
 init_esm_shims();
 import { readFile as readFile14, rm as rm4 } from "fs/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname12, join as join6 } from "path";
+import { dirname as dirname13, join as join6 } from "path";
 
 // src/upgradeLog.ts
 init_esm_shims();
-import { chmod as chmod6, mkdir as mkdir14, open as open2 } from "fs/promises";
+import { chmod as chmod7, mkdir as mkdir15, open as open2 } from "fs/promises";
 var FILE_MODE = 384;
 function resolveUpgradeTrigger(raw) {
   return raw === "web" || raw === "tray" ? raw : "cli";
@@ -33670,7 +34030,7 @@ function assertUpgradeLogEntry(entry) {
 }
 async function appendUpgradeLogEntry(slockHome, entry) {
   assertUpgradeLogEntry(entry);
-  await mkdir14(computerDir(slockHome), { recursive: true });
+  await mkdir15(computerDir(slockHome), { recursive: true });
   const path3 = upgradeLogPath(slockHome);
   const at = entry.at ?? formatUpgradeLogTimestamp();
   const fullEntry = { ...entry, at };
@@ -33682,7 +34042,7 @@ async function appendUpgradeLogEntry(slockHome, entry) {
     await handle.close();
   }
   if (process.platform !== "win32") {
-    await chmod6(path3, FILE_MODE);
+    await chmod7(path3, FILE_MODE);
   }
 }
 
@@ -33840,7 +34200,7 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
 }
 function defaultCurrentBinaryDir() {
   const here = fileURLToPath3(import.meta.url);
-  return dirname12(dirname12(here));
+  return dirname13(dirname13(here));
 }
 async function defaultCurrentVersion() {
   if (isSeaBinary()) return COMPUTER_VERSION;