mainflow 0.34.0 → 0.35.0

package/dist/host.d.ts

@@ -4,9 +4,17 @@ export declare const hostName: (hub: string) => string;
 export declare function siteBlock(hub: string, port: number): string;
 /** Caddy's sites directory: MAINFLOW_CADDY_SITES, or the Homebrew layout {prefix}/etc/caddy/sites; null without either. */
 export declare function caddySites(): string | null;
+/**
+ * Remove the mainflow-* links in `sites` whose target is gone. One such link makes every Caddy reload fail,
+ * because the Caddyfile imports the whole directory; hubs deleted without being asked to stop (test hubs)
+ * leave them behind. Other names and links with a target are not touched. Returns the names removed.
+ */
+export declare function removeDanglingLinks(sites: string): string[];
 export interface HostOptions {
   reload?: (sites: string) => string | null;
   running?: () => Promise<boolean>;
+  /** Upstream addresses Caddy currently has for a host name; undefined when that cannot be read. */
+  upstreams?: (host: string) => Promise<string[] | undefined>;
 }
 /** The host name URL when Caddy serves it, or why it does not so the caller can fall back to localhost. */
 export type HostResult = {
@@ -14,6 +22,7 @@ export type HostResult = {
 } | {
   url: null;
   reason: string;
+  reloadFailed?: true;
 };
 /**
  * Point {hub}.mainflow.localhost at `port`. The site block is rewritten and Caddy reloaded only when the

package/dist/host.js

@@ -1,2 +1,2 @@
-import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-79T-_NMu.js";
-export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeHostLink, siteBlock, syncHost };
+import { a as openInApp, c as siteBlock, i as hostName, l as syncHost, n as DEFAULT_UI_PORT, o as removeDanglingLinks, r as caddySites, s as removeHostLink, t as APP_BUNDLE_ID } from "./host-bnHYIwuY.js";
+export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeDanglingLinks, removeHostLink, siteBlock, syncHost };

package/dist/{index-ihgXABQc.d.ts → index-DgYB5u1f.d.ts}

@@ -10,6 +10,8 @@ declare const ID_PATTERNS: {
   readonly action: RegExp;
   readonly issue: RegExp;
   readonly finding: RegExp;
+  /** A hub-level group of mainlines and issues; groups/w{NNN}-{slug}.md */
+  readonly group: RegExp;
   readonly grant: RegExp;
 };
 declare const CHECKLIST_REF: RegExp;
@@ -75,6 +77,11 @@ declare const mainlineSchema: z.ZodObject<{
     P2: "P2";
     P3: "P3";
   }>>;
+  group: z.ZodOptional<z.ZodString>;
+  role: z.ZodOptional<z.ZodEnum<{
+    impl: "impl";
+    plan: "plan";
+  }>>;
   due: z.ZodOptional<z.ZodString>;
   archivedAt: z.ZodOptional<z.ZodString>;
   criteria: z.ZodArray<z.ZodObject<{
@@ -370,6 +377,7 @@ declare const issueSchema: z.ZodObject<{
     P2: "P2";
     P3: "P3";
   }>>;
+  group: z.ZodOptional<z.ZodString>;
   order: z.ZodOptional<z.ZodNumber>;
   due: z.ZodOptional<z.ZodString>;
   plannedIn: z.ZodOptional<z.ZodString>;
@@ -410,6 +418,49 @@ declare const findingSchema: z.ZodObject<{
   archivedAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type Finding = z.infer<typeof findingSchema>;
+/**
+ * Front matter of groups/w{NNN}-{slug}.md: mainlines and issues that belong together, such as a plan mainline with the
+ * impl mainlines it split off, or the issues to take up together when a measurement is fixed. Membership is written
+ * on each member (`group`), so a group file never lists its members and the two cannot disagree. A group is apart
+ * from dependencies: depends-on between groups orders them, and priority and trigger say how urgent and when.
+ */
+declare const groupSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    done: "done";
+    open: "open";
+  }>;
+  priority: z.ZodOptional<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>;
+  trigger: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Group = z.infer<typeof groupSchema>;
 /** One line of ops/{YYYY-MM}.log: an external operation, append-only. */
 declare const opsEntrySchema: z.ZodObject<{
   at: z.ZodString;
@@ -420,4 +471,4 @@ declare const opsEntrySchema: z.ZodObject<{
 }, z.core.$strip>;
 type OpsEntry = z.infer<typeof opsEntrySchema>;
 //#endregion
-export { Until as _, Decision as a, ID_PATTERNS as c, OpsEntry as d, SERVES_REF as f, Task as g, SurveyLine as h, ChecklistItem as i, Issue as l, Session as m, ActionBlock as n, FORMAT_VERSION as o, SLUG as p, CHECKLIST_REF as r, Finding as s, Action as t, Mainline as u };
+export { Task as _, Decision as a, Group as c, Mainline as d, OpsEntry as f, SurveyLine as g, Session as h, ChecklistItem as i, ID_PATTERNS as l, SLUG as m, ActionBlock as n, FORMAT_VERSION as o, SERVES_REF as p, CHECKLIST_REF as r, Finding as s, Action as t, Issue as u, Until as v };

package/dist/launch-D80CYPcm.js

@@ -0,0 +1,327 @@
+import { _t as DATA_DIR, i as hostName, l as syncHost, n as DEFAULT_UI_PORT, s as removeHostLink, vt as WriteError } from "./host-bnHYIwuY.js";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:net";
+//#region src/version.ts
+/** This CLI's own version, from the package manifest one level above both src/ and dist/. */
+const CLI_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+//#endregion
+//#region src/launch.ts
+/** How many ports above DEFAULT_UI_PORT are tried before giving up. */
+const PORT_SPAN = 100;
+/** Where the last server started is remembered: machine-specific, so under the unversioned local/ folder. */
+const uiRecordFile = (root) => join(root, DATA_DIR, "local", "ui.json");
+function readUiRecord(root) {
+	try {
+		const record = JSON.parse(readFileSync(uiRecordFile(root), "utf8"));
+		if (!Number.isInteger(record.port)) return void 0;
+		return {
+			port: record.port,
+			...Number.isInteger(record.pid) && { pid: record.pid },
+			...typeof record.version === "string" && { version: record.version },
+			...typeof record.hostError === "string" && { hostError: record.hostError }
+		};
+	} catch {
+		return;
+	}
+}
+function writeUiRecord(root, record) {
+	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
+	writeFileSync(uiRecordFile(root), `${JSON.stringify(record)}\n`);
+}
+/**
+* Ports to try, in order. An explicit --port is the only candidate: the user asked for that port. Otherwise
+* the hub's configured port, then the last one used, then the default range.
+*/
+function portCandidates(options) {
+	if (options.explicit !== void 0) return [options.explicit];
+	const range = Array.from({ length: 100 }, (_, i) => DEFAULT_UI_PORT + i);
+	return [...new Set([
+		options.configured,
+		options.last,
+		...range
+	].filter((p) => p !== void 0))];
+}
+const sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+/** How long a server gets to answer /api/ping; the endpoint loads nothing, so a server that is slower is not a live one. */
+const PROBE_MS = 1e3;
+/**
+* Ask `path` of the server on `port`: its JSON body (also from a 503 of kind hub-config), 404 for a server without
+* that endpoint, null for anything else.
+* A server that predates the endpoint answers with its page (200 text/html) rather than 404, so a 200 that is not a
+* JSON object naming a hub counts as no endpoint too.
+*/
+async function getJson(port, path) {
+	try {
+		const res = await fetch(`http://localhost:${port}${path}`, { signal: AbortSignal.timeout(PROBE_MS) });
+		if (res.status === 404) return 404;
+		if (!res.ok && res.status !== 503) return null;
+		const body = await res.json().catch(() => null);
+		if (res.status === 503 && body?.kind !== "hub-config") return null;
+		return body !== null && typeof body === "object" && typeof body.hub === "string" ? body : 404;
+	} catch {
+		return null;
+	}
+}
+const networkProbe = {
+	async serverAt(port) {
+		let body = await getJson(port, "/api/ping");
+		if (body === 404) body = await getJson(port, "/api/hub");
+		if (body === null || body === 404 || typeof body.hub !== "string") return null;
+		return {
+			hub: body.hub,
+			...typeof body.version === "string" && { version: body.version },
+			...typeof body.root === "string" && { root: body.root },
+			...Number.isInteger(body.pid) && { pid: body.pid },
+			...body.status === "config-error" && { status: "config-error" }
+		};
+	},
+	isFree: (port) => new Promise((done) => {
+		const probe = createServer().once("error", () => done(false));
+		probe.listen(port, () => probe.close(() => done(true)));
+	}),
+	listenerOf(port) {
+		const out = spawnSync("lsof", [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-t"
+		], { encoding: "utf8" });
+		const pid = Number(out.stdout?.split("\n")[0]);
+		return out.status === 0 && Number.isInteger(pid) && pid > 0 ? pid : null;
+	},
+	async stop(pid, port) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {
+			return false;
+		}
+		for (let i = 0; i < 25; i++) {
+			await sleep(200);
+			if (await networkProbe.isFree(port)) return true;
+		}
+		return false;
+	}
+};
+/** The absolute path of `root` with symbolic links followed, so two paths to one directory compare equal. */
+function realRoot(root) {
+	try {
+		return realpathSync(root);
+	} catch {
+		return resolve(root);
+	}
+}
+/** Whether `info` is a server of the hub `hub` at `root`. A server that reports no root cannot be told apart by it, so the name decides. */
+const serves = (info, hub, root) => info !== null && info.hub === hub && (info.root === void 0 || root === void 0 || info.root === root);
+/**
+* A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
+* changed ui.port never starts a second copy; all candidates are asked at once, bounding the wait by one
+* probe timeout. Among several servers of the hub, the one of `version` is kept, else the first in the order, and
+* the rest are returned as `extras`. A hub of the same name at another root, such as a worktree's, is not this
+* hub's server. Otherwise the first free candidate; ports held by another hub or program are skipped.
+*/
+async function choosePort(hub, candidates, probe = networkProbe, options = {}) {
+	const servers = await Promise.all(candidates.map((port) => probe.serverAt(port)));
+	const ours = candidates.flatMap((port, i) => serves(servers[i], hub, options.root) ? [{
+		port,
+		...servers[i]
+	}] : []);
+	const kept = ours.find((s) => s.version === options.version) ?? ours[0];
+	if (kept) return {
+		port: kept.port,
+		running: kept.version ?? "",
+		...kept.pid !== void 0 && { pid: kept.pid },
+		extras: ours.filter((s) => s !== kept)
+	};
+	for (const [i, port] of candidates.entries()) if (servers[i] === null && await probe.isFree(port)) return {
+		port,
+		running: void 0,
+		extras: []
+	};
+	const tried = candidates.length === 1 ? `port ${candidates[0]} is` : `ports ${candidates[0]} to ${candidates.at(-1)} are`;
+	throw new WriteError(`${tried} taken by other programs; free one, or pass --port <port>`);
+}
+/** The lock that makes starting an interface one hook at a time: machine-specific, so under the unversioned local/ folder. */
+const uiLockFile = (root) => join(root, DATA_DIR, "local", "ui.lock");
+const processAlive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+};
+/**
+* Run `action` while holding local/ui.lock, so several hooks starting at the same moment, such as the sessions of a
+* workspace opened together, take turns: the later ones then find the first one's server and reuse it. A lock whose
+* process is gone, or that is older than `staleMs`, is taken over; after `waitMs` the action runs without the lock
+* rather than leave a session without its interface.
+*/
+async function withUiLock(root, action, options = {}) {
+	const { waitMs = 2e4, staleMs = 6e4 } = options;
+	const file = uiLockFile(root);
+	mkdirSync(join(root, DATA_DIR, "local"), { recursive: true });
+	const deadline = Date.now() + waitMs;
+	let held = false;
+	for (;;) {
+		try {
+			writeFileSync(file, `${process.pid}\n`, { flag: "wx" });
+			held = true;
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") break;
+		}
+		const holder = Number.parseInt(readLock(file), 10);
+		const age = Date.now() - (statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now());
+		if (Number.isInteger(holder) && holder > 0 && !processAlive(holder) || age > staleMs) {
+			rmSync(file, { force: true });
+			continue;
+		}
+		if (Date.now() >= deadline) break;
+		await sleep(50);
+	}
+	try {
+		return await action();
+	} finally {
+		if (held && Number.parseInt(readLock(file), 10) === process.pid) rmSync(file, { force: true });
+	}
+}
+function readLock(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return "";
+	}
+}
+/**
+* Run `mainflow ui --no-open` detached, for a hook that must not wait: it reuses a server already serving this
+* hub, replaces one of another version, or starts one. The CLI running now is the one started, so the hub's
+* pinned version serves its interface.
+*/
+function startUiInBackground(root) {
+	const cli = process.argv[1];
+	if (!cli || process.env.MAINFLOW_NO_BACKGROUND_UI === "1") return;
+	spawn(process.execPath, [
+		cli,
+		"ui",
+		"--no-open"
+	], {
+		cwd: root,
+		detached: true,
+		stdio: "ignore"
+	}).on("error", () => {}).unref();
+}
+/**
+* Call `onGone` once the hub's config.yaml disappears, checking every `everyMs`. A server started for a hub in a
+* directory that is later deleted, such as a test's, then stops instead of holding its port forever. The timer
+* does not keep the process alive by itself.
+*/
+function watchHubGone(root, onGone, everyMs = 3e4) {
+	const timer = setInterval(() => {
+		if (existsSync(join(root, ".mainflow", "config.yaml"))) return;
+		clearInterval(timer);
+		onGone();
+	}, everyMs);
+	timer.unref();
+	return timer;
+}
+/** Open a URL in the default browser without waiting for it. */
+function openUrl(url) {
+	const [command, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? [
+		"cmd",
+		"/c",
+		"start",
+		"",
+		url
+	] : ["xdg-open", url];
+	spawn(command, args, {
+		detached: true,
+		stdio: "ignore"
+	}).on("error", () => console.log(`open ${url} in a browser`)).unref();
+}
+/** Start or reuse this hub's interface: the URL it is reached at, and the server when this call started one. */
+async function launchUi(root, hub, configured, options) {
+	const log = options.log ?? console.log;
+	let explicit;
+	if (options.port !== void 0) {
+		explicit = Number(options.port);
+		if (!Number.isInteger(explicit) || explicit < 1024 || explicit > 65535) throw new WriteError("--port must be an integer from 1024 to 65535, e.g. --port 4320");
+	}
+	const probe = options.probe ?? networkProbe;
+	const hubRoot = realRoot(root);
+	const { choice, reuse, server } = await withUiLock(root, async () => {
+		const record = readUiRecord(root);
+		const choice = await choosePort(hub, portCandidates({
+			explicit,
+			configured,
+			last: record?.port
+		}), probe, {
+			root: hubRoot,
+			version: CLI_VERSION
+		});
+		for (const extra of choice.extras) {
+			if (extra.root === void 0) continue;
+			const pid = extra.pid ?? probe.listenerOf(extra.port);
+			if (pid !== null && pid !== process.pid && await probe.stop(pid, extra.port)) log(`! stopped a second interface of ${hub} on localhost:${extra.port}`);
+		}
+		let reuse = choice.running !== void 0;
+		if (reuse && choice.running !== CLI_VERSION) {
+			const from = choice.running || "unknown";
+			const pid = choice.pid ?? (record?.port === choice.port && record.pid !== void 0 ? record.pid : probe.listenerOf(choice.port));
+			if (pid !== null && await probe.stop(pid, choice.port)) {
+				log(`! restarted: mainflow ${from} → ${CLI_VERSION}`);
+				reuse = false;
+			} else log(`! localhost:${choice.port} still runs mainflow ${from}, not ${CLI_VERSION}; stop it with \`kill $(lsof -ti tcp:${choice.port})\` and run mainflow ui again`);
+		}
+		let server;
+		if (!reuse) {
+			const { serveUi } = await import("./ui-C4h4iLDu.js");
+			server = await serveUi(root, choice.port);
+			writeUiRecord(root, {
+				port: choice.port,
+				pid: process.pid,
+				version: CLI_VERSION
+			});
+			const started = server;
+			watchHubGone(root, () => {
+				const failure = removeHostLink(root, hub);
+				if (failure) log(`! caddy reload failed after removing ${hostName(hub)}: ${failure}`);
+				started.close();
+				process.exit(0);
+			});
+		}
+		return {
+			choice,
+			reuse,
+			server
+		};
+	});
+	const host = await syncHost(root, hub, choice.port, options.host);
+	if (host.url === null) log(`! host name not available: ${host.reason}`);
+	const hostError = host.url === null && host.reloadFailed ? host.reason : void 0;
+	const recorded = readUiRecord(root);
+	if (recorded && recorded.hostError !== hostError) {
+		const { hostError: _previous, ...rest } = recorded;
+		writeUiRecord(root, hostError ? {
+			...rest,
+			hostError
+		} : rest);
+	}
+	const url = host.url ?? `http://localhost:${choice.port}`;
+	log(`${reuse ? "already running" : "mainflow ui"}: ${url} (localhost:${choice.port})`);
+	if (options.open) openUrl(url);
+	return {
+		url,
+		server,
+		...hostError && { hostError }
+	};
+}
+/**
+* The exit code `mainflow ui` sets once launching is done. A stale host name makes it 1 only when this process
+* has no server of its own and so ends here; a process that serves keeps 0, or a normal stop much later would
+* report 1.
+*/
+const exitCodeFor = (result) => result.hostError && !result.server ? 1 : 0;
+//#endregion
+export { networkProbe as a, realRoot as c, withUiLock as d, CLI_VERSION as f, launchUi as i, startUiInBackground as l, choosePort as n, portCandidates as o, exitCodeFor as r, readUiRecord as s, PORT_SPAN as t, watchHubGone as u };

package/dist/launch.d.ts

@@ -8,6 +8,8 @@ export interface UiRecord {
   port: number;
   pid?: number;
   version?: string;
+  /** Why the last run could not point the host name at this server: the Caddy reload failure, absent when it worked. */
+  hostError?: string;
 }
 export declare function readUiRecord(root: string): UiRecord | undefined;
 /**
@@ -19,10 +21,18 @@ export declare function portCandidates(options: {
   configured?: number;
   last?: number;
 }): number[];
-/** What a mainflow interface on a port reports; servers older than 0.8.1 report no version. */
+/**
+ * What a mainflow interface on a port reports. Servers older than 0.8.1 report no version, and servers that answer
+ * only /api/hub report neither their root nor their process.
+ */
 export interface ServerInfo {
   hub: string;
   version?: string;
+  /** The hub's root with symbolic links resolved */
+  root?: string;
+  pid?: number;
+  /** 'config-error' when the server is this hub's but its config.yaml cannot be used right now */
+  status?: 'config-error';
 }
 export interface PortProbe {
   /** The mainflow interface on this port, or null when nothing mainflow answers. */
@@ -34,17 +44,43 @@ export interface PortProbe {
   stop: (pid: number, port: number) => Promise<boolean>;
 }
 export declare const networkProbe: PortProbe;
-/** A port to serve on; `running` is the version already serving this hub there, '' when it reports none. */
+/** The absolute path of `root` with symbolic links followed, so two paths to one directory compare equal. */
+export declare function realRoot(root: string): string;
+/** A server of this hub on `port`, with what it reported. */
+export interface HubServer extends ServerInfo {
+  port: number;
+}
+/**
+ * A port to serve on. `running` is the version already serving this hub there, '' when it reports none. `extras` are
+ * the other servers of this hub found on the candidates, to be stopped so one remains.
+ */
 export type PortChoice = {
   port: number;
   running?: string;
+  pid?: number;
+  extras: HubServer[];
 };
 /**
  * A candidate already serving this hub wins wherever it sits in the order, so a lost last-port record or a
  * changed ui.port never starts a second copy; all candidates are asked at once, bounding the wait by one
- * probe timeout. Otherwise the first free candidate; ports held by another hub or program are skipped.
+ * probe timeout. Among several servers of the hub, the one of `version` is kept, else the first in the order, and
+ * the rest are returned as `extras`. A hub of the same name at another root, such as a worktree's, is not this
+ * hub's server. Otherwise the first free candidate; ports held by another hub or program are skipped.
+ */
+export declare function choosePort(hub: string, candidates: number[], probe?: PortProbe, options?: {
+  root?: string;
+  version?: string;
+}): Promise<PortChoice>;
+/**
+ * Run `action` while holding local/ui.lock, so several hooks starting at the same moment, such as the sessions of a
+ * workspace opened together, take turns: the later ones then find the first one's server and reuse it. A lock whose
+ * process is gone, or that is older than `staleMs`, is taken over; after `waitMs` the action runs without the lock
+ * rather than leave a session without its interface.
  */
-export declare function choosePort(hub: string, candidates: number[], probe?: PortProbe): Promise<PortChoice>;
+export declare function withUiLock<T>(root: string, action: () => Promise<T>, options?: {
+  waitMs?: number;
+  staleMs?: number;
+}): Promise<T>;
 /**
  * Run `mainflow ui --no-open` detached, for a hook that must not wait: it reuses a server already serving this
  * hub, replaces one of another version, or starts one. The CLI running now is the one started, so the hub's
@@ -68,5 +104,15 @@ export interface LaunchOptions {
 export declare function launchUi(root: string, hub: string, configured: number | undefined, options: LaunchOptions): Promise<{
   url: string;
   server?: ServerType;
+  hostError?: string;
 }>;
+/**
+ * The exit code `mainflow ui` sets once launching is done. A stale host name makes it 1 only when this process
+ * has no server of its own and so ends here; a process that serves keeps 0, or a normal stop much later would
+ * report 1.
+ */
+export declare const exitCodeFor: (result: {
+  hostError?: string;
+  server?: unknown;
+}) => number;
 //#endregion

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as portCandidates, c as watchHubGone, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-DQVyIbpf.js";
-export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readUiRecord, startUiInBackground, watchHubGone };
+import { a as networkProbe, c as realRoot, d as withUiLock, i as launchUi, l as startUiInBackground, n as choosePort, o as portCandidates, r as exitCodeFor, s as readUiRecord, t as PORT_SPAN, u as watchHubGone } from "./launch-D80CYPcm.js";
+export { PORT_SPAN, choosePort, exitCodeFor, launchUi, networkProbe, portCandidates, readUiRecord, realRoot, startUiInBackground, watchHubGone, withUiLock };

package/dist/{operation--fJnUqvA.js → operation-DVcJgKM9.js}

@@ -1,4 +1,4 @@
-import { $ as MAX_FILE_BYTES, F as renumberFiles, I as renumberPath, L as renumberText, N as applyOffline, P as renumberRequest, Q as MAX_BLOB_BYTES, R as scopeOfPath, X as ACCESS_HEADERS, Y as nodeStorage, Z as BLOB_HASH, _t as splitFrontMatter, at as requestTime, et as ROUTES, gt as contentHash, ht as WriteError, it as readsAsText, mt as DATA_DIR, nt as comparePaths, ot as textBytes, pt as ConflictError, q as nowMinute, rt as exceedsFileLimit, tt as SOCKET_MAX_AGE_CLOSE, z as applyOperation } from "./host-79T-_NMu.js";
+import { $ as ACCESS_HEADERS, B as applyOperation, F as renumberRequest, I as renumberFiles, L as renumberPath, P as applyOffline, Q as nodeStorage, R as renumberText, X as nowMinute, _t as DATA_DIR, at as comparePaths, bt as splitFrontMatter, ct as requestTime, et as BLOB_HASH, gt as ConflictError, it as SOCKET_MAX_AGE_CLOSE, lt as textBytes, nt as MAX_FILE_BYTES, ot as exceedsFileLimit, rt as ROUTES, st as readsAsText, tt as MAX_BLOB_BYTES, vt as WriteError, yt as contentHash, z as scopeOfPath } from "./host-bnHYIwuY.js";
 import { createHash, randomBytes } from "node:crypto";
 import { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -5902,4 +5902,4 @@ function hubWriter(root, env = process.env, options = {}) {
 	};
 }
 //#endregion
-export { syncPaths as A, ENV as C, SETTINGS_FILE as D, syncSettings as E, SYNC_DIR as O, ServerError as S, hubName as T, readDaemon as _, remoteMode as a, oversizedFiles as b, planAnnounce as c, toolCallOf as d, startDaemon as f, probeDaemon as g, callDaemon as h, queuedCount as i, isSynced as k, planFetch as l, DaemonUnavailable as m, hubWriter as n, fetchDenial as o, DaemonRunning as p, writtenLines as r, hookAnswer as s, CONFIRM_MS as t, planFlush as u, silentHint as v, earlierToken as w, ServerApi as x, readRemote as y };
+export { isSynced as A, ServerError as C, syncSettings as D, hubName as E, SETTINGS_FILE as O, ServerApi as S, earlierToken as T, readDaemon as _, remoteMode as a, readRemote as b, planAnnounce as c, toolCallOf as d, startDaemon as f, probeDaemon as g, callDaemon as h, queuedCount as i, syncPaths as j, SYNC_DIR as k, planFetch as l, DaemonUnavailable as m, hubWriter as n, fetchDenial as o, DaemonRunning as p, writtenLines as r, hookAnswer as s, CONFIRM_MS as t, planFlush as u, silentHint as v, ENV as w, oversizedFiles as x, watchTree as y };