zidane 7.2.5 → 8.0.4

package/dist/settings-keys-Ckf29NeM.js

@@ -0,0 +1,677 @@
+import { t as resolveStorageDirs } from "./xdg-zweed0-t.js";
+import { n as JsonRpcRemoteError, t as JsonRpcConnectionClosedError } from "./json-rpc--HXQti1E.js";
+import { a as HOST_ENABLED_LISTS, s as isWindowOnlySetting } from "./registry-D6ShBWJU.js";
+import { g as isMethodNotFound } from "./types-CH5XpIHw.js";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
+import { connect } from "node:net";
+//#region src/ipc/daemon/lifecycle.ts
+/**
+* Daemon lifecycle: socket-path resolution, liveness probing, stale-socket
+* cleanup, and spawn-on-demand.
+*
+* The socket lives in a dedicated daemon subdir of the resolved state dir
+* (`~/.zidane/daemon/daemon.sock` by default, honoring the same
+* `ZIDANE_STORAGE_DIR` / `ZIDANE_PREFIX` env knobs every other surface
+* uses), overridable via `ZIDANE_DAEMON_SOCKET` for parallel installs and
+* tests.
+*/
+/**
+* Build fingerprint for the handshake — the mtime of this module's file
+* at import time. Client and daemon load the same file from disk, so a
+* daemon spawned before a rebuild (or a source edit in dev) reports a
+* different id than a freshly-started client, and the client drains +
+* respawns it. This closes the "same protocol version, different code"
+* gap that a hand-bumped version constant can't: during development the
+* daemon process is frozen at spawn while the tree keeps moving.
+*
+* Compiled binaries (`/$bunfs/…` virtual paths) can't be stat'ed and
+* report `'unknown'`; the check is skipped when EITHER side is unknown,
+* so released builds rely on `IPC_PROTOCOL_VERSION` alone — correct,
+* since their code only changes when the version does.
+*/
+const IPC_BUILD_ID = (() => {
+	try {
+		const selfPath = fileURLToPath(import.meta.url);
+		const ipcRoot = dirname(dirname(selfPath));
+		if (!existsSync(join(ipcRoot, "protocol.ts"))) return String(Math.floor(statSync(selfPath).mtimeMs));
+		const srcRoot = dirname(ipcRoot);
+		let newest = 0;
+		const walk = (dir) => {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				const full = join(dir, entry.name);
+				if (entry.isDirectory()) walk(full);
+				else newest = Math.max(newest, statSync(full).mtimeMs);
+			}
+		};
+		try {
+			walk(srcRoot);
+		} catch {
+			newest = statSync(selfPath).mtimeMs;
+		}
+		return String(Math.floor(newest));
+	} catch {
+		return "unknown";
+	}
+})();
+/**
+* Socket file name. Dev builds (`ZIDANE_DEV=1`, set by every `dev` script
+* in the repo) get their OWN socket so a checkout's TUI, GUI and `zidane
+* daemon` pair up among themselves and never attach to — or get refused by
+* — the installed daemon. Without this, a protocol bump in the working
+* tree turned the dev GUI's dot red against the stable daemon, and a dev
+* daemon could drain the one the installed TUI relies on.
+*/
+function daemonSocketName(env = process.env) {
+	return env.ZIDANE_DEV && env.ZIDANE_DEV !== "0" ? "dev.sock" : "daemon.sock";
+}
+function defaultSocketPath() {
+	const explicit = process.env.ZIDANE_DAEMON_SOCKET;
+	if (explicit) return explicit;
+	const dirs = resolveStorageDirs({ ...process.env.ZIDANE_PREFIX !== void 0 ? { prefix: process.env.ZIDANE_PREFIX } : {} });
+	return join(dirs.stateDir, "daemon", daemonSocketName());
+}
+/**
+* Pre-v6 socket location for the given (v6) socket path, or null when the
+* path isn't the default `<stateDir>/daemon/daemon.sock` layout (explicit
+* `ZIDANE_DAEMON_SOCKET` users never had a migration to run). A daemon
+* still serving the old path would be ORPHANED by the move — new clients
+* never probe it, and a service-style `--idle-exit 0` daemon would hold
+* agents and run-guard markers against the same sessions.db forever —
+* so daemon startup probes this path and drains any survivor.
+*/
+function legacySocketPath(socketPath) {
+	const dir = dirname(socketPath);
+	if (basename(socketPath) !== "daemon.sock" || basename(dir) !== "daemon") return null;
+	return join(dirname(dir), "daemon.sock");
+}
+/**
+* Spawn command that re-enters the CURRENT zidane program as `… daemon`.
+*
+* Three launch shapes:
+*   - compiled Bun binary — `Bun.main` is the virtual `/$bunfs/…` entry the
+*     binary self-inserts as argv[1], so the spawn must NOT repeat it
+*     (verified: repeating it makes the child parse the junk path as its
+*     subcommand and boot the full TUI instead of the daemon).
+*   - dev (`bun run cli.ts`) — the script path must ride along.
+*   - Node hosts (no `Bun` global) — fall back to the published bin.
+*/
+function selfDaemonSpawnCommand() {
+	const bunMain = globalThis.Bun?.main;
+	if (bunMain?.startsWith("/$bunfs")) return [process.execPath, "daemon"];
+	if (bunMain && /(?:^|[/\\])cli\.[cm]?[jt]s$/.test(bunMain)) return [
+		process.execPath,
+		bunMain,
+		"daemon"
+	];
+	return ["zidane-daemon"];
+}
+/**
+* True when something accepts connections on `socketPath`. Distinguishes a
+* live daemon from a stale socket file left by a crashed one.
+*/
+function probeSocket(socketPath, timeoutMs = 1e3) {
+	return new Promise((resolve) => {
+		try {
+			if (!existsSync(socketPath) || !statSync(socketPath).isSocket()) {
+				resolve(false);
+				return;
+			}
+		} catch {
+			resolve(false);
+			return;
+		}
+		let socket;
+		try {
+			socket = connect(socketPath);
+		} catch {
+			resolve(false);
+			return;
+		}
+		const done = (alive) => {
+			socket.destroy();
+			resolve(alive);
+		};
+		socket.once("connect", () => done(true));
+		socket.once("error", () => done(false));
+		socket.setTimeout(timeoutMs, () => done(false));
+	});
+}
+/**
+* Make sure a daemon is listening, spawning one if needed. Resolves with
+* the socket path once a connection succeeds; rejects when the daemon
+* failed to come up within `timeoutMs`.
+*/
+const pendingStarts = /* @__PURE__ */ new Map();
+function ensureDaemonRunning(options = {}) {
+	const socketPath = options.socketPath ?? defaultSocketPath();
+	const pending = pendingStarts.get(socketPath);
+	if (pending) return pending;
+	const start = startDaemon({
+		...options,
+		socketPath
+	}).finally(() => pendingStarts.delete(socketPath));
+	pendingStarts.set(socketPath, start);
+	return start;
+}
+async function startDaemon(options) {
+	const socketPath = options.socketPath;
+	if (await probeSocket(socketPath)) return socketPath;
+	const [cmd, ...args] = options.spawnCommand ?? ["zidane-daemon"];
+	const child = spawn(cmd, args, {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			ZIDANE_DAEMON_SOCKET: socketPath
+		}
+	});
+	let spawnError;
+	child.once("error", (err) => {
+		spawnError = err;
+	});
+	child.unref();
+	const deadline = Date.now() + (options.timeoutMs ?? 8e3);
+	for (;;) {
+		if (spawnError !== void 0) throw new Error(`Failed to spawn zidane daemon (${cmd}): ${spawnError.message}`);
+		if (await probeSocket(socketPath)) return socketPath;
+		if (Date.now() > deadline) throw new Error(`zidane daemon did not come up on ${socketPath} within ${options.timeoutMs ?? 8e3}ms.`);
+		await new Promise((r) => setTimeout(r, 150));
+	}
+}
+//#endregion
+//#region src/version.ts
+/**
+* The version of the zidane code this process is running — `package.json`
+* inlined at build time (Bun `--compile`, tsdown for `dist/`, and Vite for
+* the GUI main all fold JSON imports into the bundle, so this never reads
+* the filesystem at runtime and cannot report a NEIGHBOUR package's version
+* the way a `require('../package.json')` from a bundled chunk can).
+*
+* Used by the daemon handshake: a client running newer code than the daemon
+* retires it, so an upgrade can never leave windows silently executing on a
+* process started from the previous release.
+*/
+const ZIDANE_VERSION = "8.0.4";
+/**
+* Compare two dotted versions (`7.0.19`, `7.1.0-beta.1`): negative when `a`
+* is older, positive when newer, 0 when equal. Pre-release tags are ignored
+* — same release train, same code as far as the daemon fence is concerned.
+* Unparseable input compares equal (never fences on garbage).
+*/
+function compareVersions(a, b) {
+	const pa = parse(a);
+	const pb = parse(b);
+	if (!pa || !pb) return 0;
+	for (let i = 0; i < 3; i++) {
+		const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+		if (d !== 0) return d;
+	}
+	return 0;
+}
+function parse(v) {
+	const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+	return m ? [
+		Number(m[1]),
+		Number(m[2]),
+		Number(m[3])
+	] : null;
+}
+//#endregion
+//#region src/ipc/protocol.ts
+/**
+* v6 (changes since v5):
+*   - `event` signals carry an optional `echo` flag marking host-generated
+*     SEND/STEER echoes of the user's own message.
+*   - `chat.pushQueued` result gained the `'queued'` delivered variant.
+*   - `sessions.setModel` now honors `fallbacks`: it persists the canonical
+*     `metadata.modelChain` and CLEARS a previously persisted chain when
+*     omitted/empty. It also accepts `effort` / `modelOptions` and resets
+*     both when omitted (a pick is atomic — no stale per-model knobs).
+*   - additive: `extension.emit` notification + `extension:signal` fan-out
+*     (the permission-gated per-extension cross-window bus, `ctx.bus`).
+*     Older daemons ignore the unknown notification; older clients drop the
+*     unknown signal kind — no version bump needed.
+*   - additive: `extension.emit` / `extension:signal` carry an optional
+*     `nonce` (the emitter's per-process random id) so receivers dedupe on
+*     `(extensionId, nonce, seq)` instead of the collision-prone
+*     `(extensionId, seq)`. Older peers omit it and fall back to the
+*     seq-only key — no version bump needed.
+*   - `SessionRow.modelFallbacks` is now populated from the session's
+*     persisted `metadata.modelChain`.
+*   - Default socket path moved from `<stateDir>/daemon.sock` to the
+*     dedicated `<stateDir>/daemon/daemon.sock` (dir chmod'd 0700) so the
+*     daemon can harden its socket dir without touching shared state files.
+*   - ADDITIVE (no version bump — older daemons answer "method not
+*     found", clients degrade to local compute): `suggest.resolve` RPC
+*     resolves inline ghost-text autocomplete daemon-side, and the
+*     `suggest:changed` signal fans the result out to every OTHER peer
+*     on the session so mirroring windows paint the same ghost without
+*     recomputing.
+*   - ADDITIVE (no version bump — optional field, older daemons simply
+*     omit it and clients fall back to the single `suggestion`):
+*     `suggest.resolve` results and `suggest:changed` signals carry the
+*     resolver's full ordered `candidates` list so daemon mode keeps
+*     ↑/↓ candidate rotation instead of degrading to one suggestion.
+*   - ADDITIVE (no version bump — `optional()` swallows "method not
+*     found" on an older daemon, which then simply keeps its stale
+*     registries as before): `runtime.reload` RPC drops the daemon's
+*     cached extension registries and retires live agents after a window
+*     reloaded its extensions.
+*   - ADDITIVE (no version bump): `terminal.registerViewer` /
+*     `terminal.unregisterViewer`. The desktop app registers as a client that
+*     can show terminals; agents only get terminal tools while one is
+*     attached. An older daemon answers "method not found" (and keeps giving
+*     every agent the tools, as before); an older desktop app on a newer
+*     daemon never registers, so its agents run without terminal tools.
+*   - ADDITIVE (no version bump): `queue.attachments` returns a queued
+*     entry's attachments with their bytes, and `queue.update` accepts
+*     `attachments` to replace them. An older daemon answers "method not
+*     found" / ignores the field: the entry's attachments stay as queued.
+*   - ADDITIVE (no version bump): `chat.steer` / `chat.followUp` resolve to
+*     whether the message reached a live run. Older daemons resolve `null`,
+*     which clients treat as delivered (the pre-existing behavior).
+*   - ADDITIVE (no version bump): `sessions.fork`, `sessions.deleteTurn`,
+*     `sessions.editTurnText`, `sessions.setFolder`, `sessions.appendTurns`.
+*     History and folder edits run in the host instead of being written to
+*     the store by the client (then `sessions.touch` + `chat.rebuildAgent`).
+*     Older clients keep the old path, which still works on a shared disk.
+*     A newer client only meets an older daemon while it retires (the
+*     release fence drains it otherwise), and then gets "method not found".
+*   - ADDITIVE (no version bump): `sessions.listMeta`, `sessions.getMeta`,
+*     `sessions.get`, `sessions.setExtensionState` serve a client the
+*     session data it used to read and write in its own store, so a window
+*     on another machine sees the host's sessions. `sessions.create` accepts `id`, `effort`, `modelOptions` and
+*     `pinnedSkills`; `todos.set` accepts `persistIdle`. An older host answers
+*     "method not found" / ignores the fields: a window falls back to the
+*     store it shares with a local daemon, and refuses a remote host.
+*/
+const IPC_PROTOCOL_VERSION = 13;
+/**
+* JSON-RPC error codes specific to the zidane daemon. Lives here (not in
+* `daemon/server.ts`) so clients can import the codes without pulling the
+* server's module graph.
+*/
+const IpcErrorCode = {
+	VersionMismatch: -32010,
+	NotHandshaken: -32011,
+	/** A network transport's per-connection request budget is spent; retry later. */
+	RateLimited: -32012,
+	/**
+	* The reply would exceed the transport's message size: nothing was sent
+	* but this error (the connection stays). Ask for less (a transcript: a
+	* smaller page, see {@link loadAllEvents}).
+	*/
+	ResponseTooLarge: -32013,
+	/**
+	* The handler threw: the host refused or failed the call (`message` says
+	* why). Hosts before it answered -32000, which ACP uses for
+	* `AuthenticationRequired`; clients treat both as a plain remote error.
+	*/
+	HandlerFailed: -32014
+};
+/**
+* Client heartbeat request (`{}` → `{}`), outside the method table: every
+* host answers it, before the handshake too. A host predating it answers
+* "method not found", which still proves it alive.
+*/
+const PING_METHOD = "$/ping";
+/**
+* Session-scoped signals fanned out to every peer carry their number in
+* their session as this extra field on the `ipc.signal` params (clients
+* predating it ignore it; `IpcClient` strips it and hands it to listeners as
+* {@link SignalMeta}). Per session, from 1, gap-free within one host process.
+*/
+const SIGNAL_SEQ_FIELD = "$seq";
+/** The host's identity from a hello (or `daemon.info`) reply; `null` from a host that predates it. */
+function hostRefOf(hello) {
+	if (typeof hello.hostId !== "string" || !hello.hostKind) return null;
+	return {
+		id: hello.hostId,
+		kind: hello.hostKind,
+		name: hello.hostName ?? hello.hostId
+	};
+}
+/** Turns per `sessions.loadEvents` page when only `before` is given. */
+const LOAD_EVENTS_PAGE_TURNS = 200;
+/** Largest `limit` a host honors. */
+const LOAD_EVENTS_MAX_PAGE_TURNS = 1e3;
+/**
+* One page of `sessions.loadEvents` (see its paging). An older host answers
+* the whole transcript: it comes back as one page with no cursor.
+*/
+async function loadEventsPage(request, params) {
+	const result = await request("sessions.loadEvents", params);
+	return Array.isArray(result) ? { events: result } : result;
+}
+function isResponseTooLarge(err) {
+	return typeof err === "object" && err !== null && err.code === IpcErrorCode.ResponseTooLarge;
+}
+/**
+* A session's whole transcript, loaded a page at a time from the end so no
+* single reply carries it all (a long session with images can outgrow a
+* transport's message size). A page refused as too large is asked again at
+* half the turns, down to one; a single turn that still doesn't fit fails
+* the load. An older host answers the whole transcript to the first call.
+*/
+async function loadAllEvents(request, sessionId, options = {}) {
+	return (await loadEventsFromEnd(request, sessionId, options.pageTurns ?? 200)).events;
+}
+/**
+* The end of a session's transcript: pages from the end until `enough`
+* holds for what was loaded (or the first turn is in), and how many events
+* of the whole replay come before it (`earlier`). Only exact pages can stop
+* early, since only they say where they start: an older host's transcript
+* loads whole, with `earlier` 0.
+*/
+async function loadEventsTail(request, sessionId, enough, options = {}) {
+	return loadEventsFromEnd(request, sessionId, options.pageTurns ?? 200, enough);
+}
+async function loadEventsFromEnd(request, sessionId, pageTurns, enough) {
+	let limit = pageTurns;
+	const pages = [];
+	let newerExact = false;
+	let allExact = true;
+	let before;
+	for (;;) {
+		let page;
+		try {
+			page = await loadEventsPage(request, {
+				sessionId,
+				limit,
+				...before !== void 0 ? { before } : {}
+			});
+		} catch (err) {
+			if (isResponseTooLarge(err) && limit > 1) {
+				limit = Math.max(1, Math.floor(limit / 2));
+				continue;
+			}
+			throw err;
+		}
+		const newer = pages[0];
+		if (newer && !newerExact && newer[0]?.kind === "user-prompt" && page.events.length > 0) newer.unshift({
+			kind: "separator",
+			text: ""
+		});
+		newerExact = page.exact === true;
+		allExact &&= newerExact && page.start !== void 0;
+		pages.unshift(page.events);
+		if (page.cursor === void 0 || page.cursor <= 0 || before !== void 0 && page.cursor >= before) break;
+		if (enough && allExact) {
+			const events = pages.flat();
+			if (enough(events)) return {
+				events,
+				earlier: page.start
+			};
+		}
+		before = page.cursor;
+	}
+	return {
+		events: pages.flat(),
+		earlier: 0
+	};
+}
+/** Turns per `sessions.getTurns` page by default. */
+const SESSION_TURNS_PAGE = 200;
+/** Largest `limit` a host honors for `sessions.getTurns`. */
+const SESSION_TURNS_MAX_PAGE = 1e3;
+/** How many times a paged read starts over because the session changed under it, before it asks for the whole document in one reply. */
+const SESSION_DOCUMENT_RESTARTS = 3;
+/**
+* A session's whole document, read a page of turns at a time so no reply
+* carries it all (`sessions.getTurns` pages, then the `sessions.get`
+* `turns: false` head; a page refused as too large is asked again at half
+* the turns). Every page and the head name the snapshot they come from: a
+* version change mid-read (a turn appended, a compaction) starts the read
+* over, so the result is one version, never pages of two. After
+* {@link SESSION_DOCUMENT_RESTARTS} restarts (a session busier than the
+* read), the whole document comes in one reply. A host that predates
+* `sessions.getTurns` sends it that way too; one that names no version is
+* read as before. `null` when the host doesn't know the session.
+*/
+async function loadSessionDocument(request, sessionId, options = {}) {
+	const paging = { limit: options.pageTurns ?? 200 };
+	for (let attempt = 0; attempt <= SESSION_DOCUMENT_RESTARTS; attempt++) {
+		const read = await readSessionDocumentOnce(request, sessionId, paging);
+		if (read !== "changed") return read;
+	}
+	return withoutVersion(await request("sessions.get", { sessionId }));
+}
+function withoutVersion(head) {
+	if (!head) return null;
+	const { version: _version, ...data } = head;
+	return data;
+}
+/** One paged read; `'changed'`: the version moved between two of its replies. */
+async function readSessionDocumentOnce(request, sessionId, paging) {
+	const turns = [];
+	let total = Infinity;
+	let version = null;
+	while (turns.length < total) {
+		let page;
+		try {
+			page = await request("sessions.getTurns", {
+				sessionId,
+				from: turns.length,
+				limit: paging.limit
+			});
+		} catch (err) {
+			if (turns.length === 0 && isMethodNotFound(err)) return withoutVersion(await request("sessions.get", { sessionId }));
+			if (isResponseTooLarge(err) && paging.limit > 1) {
+				paging.limit = Math.max(1, Math.floor(paging.limit / 2));
+				continue;
+			}
+			throw err;
+		}
+		if (!page) return null;
+		if (version === null) version = { ...page.version !== void 0 ? { of: page.version } : {} };
+		else if (page.version !== version.of) return "changed";
+		total = page.total;
+		if (page.turns.length === 0) break;
+		turns.push(...page.turns);
+	}
+	const head = await request("sessions.get", {
+		sessionId,
+		turns: false
+	});
+	if (!head) return null;
+	if (version !== null && head.version !== version.of) return "changed";
+	return {
+		...withoutVersion(head),
+		turns
+	};
+}
+/** Every secret-bearing value of a catalog entry is replaced by this. */
+const REDACTED = "<redacted>";
+//#endregion
+//#region src/ipc/transports/client-core.ts
+var IpcVersionMismatchError = class extends Error {
+	daemon;
+	constructor(message, daemon) {
+		super(message);
+		this.daemon = daemon;
+		this.name = "IpcVersionMismatchError";
+	}
+};
+/** Starts the client heartbeat on `channel`; returns its stop. Stops itself once the channel closes. */
+function startHeartbeat(channel, intervalMs) {
+	let awaiting = false;
+	let missed = 0;
+	const timer = setInterval(() => {
+		if (awaiting && ++missed >= 2) {
+			clearInterval(timer);
+			channel.abort();
+			return;
+		}
+		awaiting = true;
+		channel.rpc.sendRequest(PING_METHOD, {}).then(() => {
+			awaiting = false;
+			missed = 0;
+		}, (err) => {
+			if (err instanceof JsonRpcConnectionClosedError) {
+				clearInterval(timer);
+				return;
+			}
+			awaiting = false;
+			missed = 0;
+		});
+	}, intervalMs);
+	timer.unref?.();
+	return () => clearInterval(timer);
+}
+/** The signal listeners of one client, and the JSON-RPC notification handler that feeds them. */
+function createSignalListeners() {
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		listeners,
+		onNotification(message) {
+			if (message.method !== "ipc.signal") return;
+			const params = message.params;
+			if (!params) return;
+			const { [SIGNAL_SEQ_FIELD]: seq, ...signal } = params;
+			const meta = typeof seq === "number" ? { seq } : void 0;
+			for (const cb of listeners) cb(signal, meta);
+		}
+	};
+}
+function hostRelease(hello) {
+	for (const value of [hello.codeVersion, hello.appVersion]) {
+		if (typeof value !== "string") continue;
+		const match = /^(?:zidane-gui\/)?(v?\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?)$/.exec(value.trim());
+		if (match) return match[1];
+	}
+}
+const HELLO_TIMEOUT_MS = 5e3;
+const LONG_REQUEST_TIMEOUT_MS = 6e5;
+/** RPCs that legitimately run long — full compaction, index-backed cross-session search. */
+const LONG_REQUEST_METHODS = /* @__PURE__ */ new Set([
+	"sessions.compact",
+	"history.searchAll",
+	"history.searchSession"
+]);
+/**
+* A refused handshake. Asks the host to drain when `drain` allows it, closes
+* the channel, and returns the error to throw.
+*/
+async function refusedHello(channel, err, drain) {
+	const daemon = err.data?.daemon;
+	if (daemon?.hostKind === "server") {
+		channel.close();
+		return new IpcVersionMismatchError(serverMismatchMessage(daemon, channel.where) ?? err.message, daemon);
+	}
+	const daemonIsOlderRelease = typeof daemon?.codeVersion === "string" && compareVersions(daemon.codeVersion, ZIDANE_VERSION) < 0;
+	const release = daemon && hostRelease(daemon);
+	const daemonIsNewerRelease = release !== void 0 && compareVersions(release, ZIDANE_VERSION) > 0;
+	const daemonSpeaksOlderProtocol = typeof daemon?.protocolVersion === "number" && daemon.protocolVersion < 13;
+	if (drain !== "never" && !daemonIsNewerRelease && (drain === "always" || daemonIsOlderRelease || daemonSpeaksOlderProtocol)) await Promise.race([channel.rpc.sendRequest("daemon.shutdown", { whenIdle: true }).catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 1500))]);
+	channel.close();
+	return new IpcVersionMismatchError(err.message, daemon);
+}
+/** A server's protocol refusal, from this client's side: both versions and which side to upgrade. */
+function serverMismatchMessage(server, where) {
+	if (typeof server.protocolVersion !== "number" || server.protocolVersion === 13) return null;
+	const upgrade = server.protocolVersion < 13 ? "server" : "client";
+	return `Protocol version mismatch with ${where}: the server speaks v${server.protocolVersion}, this client v13. Upgrade the ${upgrade}.`;
+}
+async function handshake(channel, options) {
+	let helloTimer;
+	try {
+		return await Promise.race([channel.rpc.sendRequest("ipc.hello", {
+			protocolVersion: 13,
+			appVersion: options.appVersion ?? "dev",
+			pid: process.pid,
+			buildId: options.buildFence ? IPC_BUILD_ID : "unknown",
+			codeVersion: ZIDANE_VERSION
+		}), new Promise((_, reject) => {
+			helloTimer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Daemon handshake timed out after ${HELLO_TIMEOUT_MS}ms on ${channel.where}.`)), HELLO_TIMEOUT_MS);
+		})]);
+	} catch (err) {
+		if (err instanceof JsonRpcRemoteError && err.code === IpcErrorCode.VersionMismatch) throw await refusedHello(channel, err, options.drain);
+		channel.close();
+		throw err;
+	} finally {
+		clearTimeout(helloTimer);
+	}
+}
+/** Handshake over `channel`, then the typed client around it. On failure the channel is closed. */
+async function openIpcClient(channel, listeners, options) {
+	const hello = await handshake(channel, options);
+	const release = hostRelease(hello);
+	if (!hello.retiring && hello.hostKind !== "server" && release !== void 0 && compareVersions(release, ZIDANE_VERSION) < 0) {
+		channel.close();
+		throw new IpcVersionMismatchError(`Daemon release ${release} is older than client ${ZIDANE_VERSION}. Restart the daemon when active runs have finished.`, hello);
+	}
+	const requestTimeoutMs = Number(process.env.ZIDANE_IPC_REQUEST_TIMEOUT_MS) || 3e4;
+	const stopHeartbeat = options.heartbeatMs ? startHeartbeat(channel, options.heartbeatMs) : () => void 0;
+	return {
+		hello,
+		notify: (method, params) => {
+			try {
+				channel.rpc.sendNotification(method, params);
+			} catch {}
+		},
+		request: async (method, params) => {
+			if (method === "machine.call") return channel.rpc.sendRequest(method, params);
+			const timeoutMs = LONG_REQUEST_METHODS.has(method) ? LONG_REQUEST_TIMEOUT_MS : requestTimeoutMs;
+			let timer;
+			try {
+				return await Promise.race([channel.rpc.sendRequest(method, params), new Promise((_, reject) => {
+					timer = setTimeout(() => {
+						reject(/* @__PURE__ */ new Error(`Daemon request ${method} timed out after ${timeoutMs}ms, closing the connection.`));
+						channel.abort();
+					}, timeoutMs);
+					timer.unref?.();
+				})]);
+			} finally {
+				clearTimeout(timer);
+			}
+		},
+		onSignal: (cb) => {
+			listeners.add(cb);
+			return () => listeners.delete(cb);
+		},
+		close: () => {
+			stopHeartbeat();
+			channel.close();
+		}
+	};
+}
+//#endregion
+//#region src/chat/sync/hash.ts
+/** Stable hashes of sync values: equal values (whatever their key order) hash the same, on both sides. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** JSON with sorted keys (undefined members dropped). */
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isRecord(value)) return `{${Object.keys(value).sort().filter((k) => value[k] !== void 0).map((k) => `${JSON.stringify(k)}:${stableStringify(value[k])}`).join(",")}}`;
+	return JSON.stringify(value) ?? "undefined";
+}
+function hashValue(value) {
+	return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+//#endregion
+//#region src/chat/sync/settings-keys.ts
+/**
+* Host-scoped settings that still don't sync: they describe this computer
+* (its environments, its daemon, remote hosts on it) or would turn off what
+* the server has that this computer doesn't (the enabled allowlists, its OS
+* sandbox). Every `sandbox*` key, present and future, is the server's own:
+* a client turning it off there would be a sandbox escape.
+*/
+const NOT_SYNCED_SETTINGS = /* @__PURE__ */ new Set([
+	"environments",
+	"useDaemon",
+	"remoteHosts",
+	...HOST_ENABLED_LISTS
+]);
+/** A setting the `settings` category carries: host-scoped (never window-only) and not machine-specific. */
+function isSyncableSetting(key) {
+	return !isWindowOnlySetting(key) && !NOT_SYNCED_SETTINGS.has(key) && !key.startsWith("sandbox");
+}
+//#endregion
+export { IPC_BUILD_ID as C, legacySocketPath as D, ensureDaemonRunning as E, probeSocket as O, compareVersions as S, defaultSocketPath as T, loadAllEvents as _, createSignalListeners as a, loadSessionDocument as b, IpcErrorCode as c, PING_METHOD as d, REDACTED as f, hostRefOf as g, SIGNAL_SEQ_FIELD as h, IpcVersionMismatchError as i, selfDaemonSpawnCommand as k, LOAD_EVENTS_MAX_PAGE_TURNS as l, SESSION_TURNS_PAGE as m, hashValue as n, openIpcClient as o, SESSION_TURNS_MAX_PAGE as p, isRecord as r, IPC_PROTOCOL_VERSION as s, isSyncableSetting as t, LOAD_EVENTS_PAGE_TURNS as u, loadEventsPage as v, daemonSocketName as w, ZIDANE_VERSION as x, loadEventsTail as y };
+
+//# sourceMappingURL=settings-keys-Ckf29NeM.js.map