@krapht/ork 1.0.0-alpha.14 → 1.0.0-alpha.15

package/dist/{format-CvTE5CZQ.mjs → format-C8MsFj8_.mjs}

@@ -1,4 +1,4 @@
-import { Kt as runStatus, Ut as liveStatus, Wt as lockWaitsOf, Zt as isItem, nn as lockWaitLine, qt as slotWaitsOf } from "./src-tsuZRu0H.mjs";
+import { Cn as liveStatus, Dn as slotWaitsOf, En as runStatus, Lt as lockWaitLine, jn as isItem, wn as lockWaitsOf } from "./src-Dr_fTSu-.mjs";
 import { C as termOf, E as widthOf, n as cost, o as shortCount, r as costOf, s as style, w as cut } from "./output-B1kwo0YU.mjs";
 import { i as statusChip, n as chip } from "./chips-BqcT58qr.mjs";
 import { n as nodeVerdict } from "./verdict-CMvPCpWC.mjs";
@@ -180,8 +180,12 @@ const stateText = (node) => {
 	}
 	return node.state;
 };
-/** The ownership tree, one line per node, children under their owner. */
-const formatTree = (roots, now = Date.now()) => {
+/**
+* The ownership tree, one line per node, children under their owner. A node in
+* `waits` (a live run's `lockWaitsOf`) reads `waiting for <lock>`, an item
+* too.
+*/
+const formatTree = (roots, now = Date.now(), waits = []) => {
 	const lines = [];
 	const walk = (node, lead, branch) => {
 		lines.push({
@@ -198,9 +202,19 @@ const formatTree = (roots, now = Date.now()) => {
 	const type = Math.max(...lines.map((l) => l.node.type.length));
 	return lines.map(({ label: text, node }) => {
 		const usage = node.inputTokens + node.outputTokens === 0 ? "" : style("dim", `  ${count(node.inputTokens)} in / ${count(node.outputTokens)} out · ${cost(node.costUsd)}`);
-		const state = node.held === true ? `${style("yellow", "‖")} paused` : `${STATE_MARK[node.state]()} ${stateText(node)}`;
+		const lock = waits.find((wait) => wait.id === node.id)?.lock;
+		const state = node.held === true ? `${style("yellow", "‖")} paused` : lock === void 0 ? `${STATE_MARK[node.state]()} ${stateText(node)}` : `${STATE_MARK.waiting()} waiting for ${lock}`;
 		const spent = isItem(node) && node.startedAt !== void 0 ? style("dim", `  ${duration((node.finishedAt === void 0 ? now : Date.parse(node.finishedAt)) - Date.parse(node.startedAt))}`) : "";
 		return `${text.padEnd(label)}  ${style("dim", node.type.padEnd(type))}  ${state}${spent}${usage}`;
 	});
 };
-export { header as a, listedStatus as i, formatRuns as n, table as o, formatTree as r, ago as t };
+/**
+* What `ork tree` prints: the run's header (its status as `ork ps` reads it)
+* and the tree. A finished run's lock waits are stale, so only a live run's
+* show; `events` are the run's, `roots` its nested tree.
+*/
+const formatTreeView = (run, events, roots, now = Date.now()) => {
+	const waits = runStatus(run, events) === "running" ? lockWaitsOf(events) : [];
+	return [`${style("bold", `run ${run.id}`)} ${dim(`of ${run.workflow} · ${listedStatus(run, events)} · ${cost(run.costUsd)}`)}`, ...formatTree(roots, now, waits)];
+};
+export { header as a, listedStatus as i, formatRuns as n, table as o, formatTreeView as r, ago as t };

package/dist/{help-groups-CpR2UzSn.mjs → help-groups-CQ98mLjF.mjs}

@@ -284,6 +284,10 @@ const HELP_GROUPS = [
 				name: "feedback",
 				short: "What got in the way in your runs"
 			},
+			{
+				name: "follow-ups",
+				short: "What shipped changes left for later"
+			},
 			{
 				name: "worktrees",
 				short: "Track and clean up Ork's worktrees"

package/dist/{in-a-run-cL5N9gpH.mjs → in-a-run-Bp0k0J09.mjs}

@@ -1,4 +1,4 @@
-import { p as runMarkerIn } from "./src-C7z_6fhn.mjs";
+import { p as runMarkerIn } from "./src-DcrhgipG.mjs";
 // src/commands/in-a-run.ts
 /**
 * @file The commands that act as the user refuse a program or an agent in a run

package/dist/{__build_info__-B82-dGJY.mjs → install-DWtXTq4y.mjs}

@@ -1,7 +1,6 @@
-import { $n as maskSecrets, A as isNewer, Cr as guardedBase, Mn as FEEDBACK_KINDS, Nn as FEEDBACK_SEVERITIES, Sr as estimateTokens, Tr as writePlainFile, Un as targetOf, Vn as fingerprint, j as parseVersion, k as compareVersions, mr as placeFor, pr as placeFiles, wr as plainPathInside, xr as LESSON_CAP_TOKENS, yr as inside, zn as publishPost } from "./src-tsuZRu0H.mjs";
+import { Dr as placeFor, Er as placeFiles, Fr as estimateTokens, Gn as FEEDBACK_SEVERITIES, Ir as guardedBase, Lr as plainPathInside, Mr as inside, Pr as LESSON_CAP_TOKENS, Rr as writePlainFile, Wn as FEEDBACK_KINDS, Zn as publishPost, er as fingerprint, fr as maskSecrets, nr as targetOf } from "./src-Dr_fTSu-.mjs";
 import path from "node:path";
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { spawn } from "node:child_process";
 // ../core/src/feedback/actions.ts
 const ALLOWED = { ok: true };
@@ -363,174 +362,6 @@ const previewPost = (store, item, ask) => {
 		})
 	};
 };
-// ../core/src/remote/session.ts
-const chattable = (type) => type === "agent.leader" || type === "agent.worker";
-/** Reads `node`'s session from a run's events, and every node's last output. */
-const nodeSession = (events, node) => {
-	const session = {
-		known: false,
-		chattable: false,
-		running: false
-	};
-	const outputs = {};
-	for (const { event } of events) {
-		if (event.type === "run.started") {
-			const declared = event.nodes.find((n) => n.id === node);
-			if (declared !== void 0) {
-				session.known = true;
-				session.chattable = chattable(declared.type);
-			}
-		}
-		if (event.type === "node.finished") outputs[event.id] = event.output;
-		if (!("id" in event) || event.id !== node) continue;
-		if (event.type === "node.started") {
-			session.known = true;
-			session.chattable = chattable(event.nodeType);
-			session.running = true;
-		}
-		if (event.type === "node.finished") session.running = false;
-		if (event.type === "worktree" && event.action === "created") session.checkout = {
-			path: event.path,
-			...event.branch === void 0 ? {} : { branch: event.branch },
-			own: true,
-			owner: node
-		};
-		if (event.type !== "node.event") continue;
-		const inner = event.event;
-		if (inner.fork === true) continue;
-		if (inner.type === "session.started") {
-			session.sessionId = inner.sessionId;
-			if (inner.cwd !== void 0) session.cwd = inner.cwd;
-			if (inner.driver !== void 0) session.driver = inner.driver;
-			if (inner.model !== "") session.model = inner.model;
-		}
-		if (inner.type === "session.finished" && inner.outcome.sessionId !== "") session.sessionId = inner.outcome.sessionId;
-	}
-	return {
-		session,
-		outputs
-	};
-};
-/** The dist-tags every install follows, toward and after 1.0.0. */
-const CHANNEL_TAGS = [
-	"latest",
-	"alpha",
-	"beta",
-	"rc"
-];
-/** The dist-tag of snapshots from `main`, followed only by a canary. */
-const CANARY_TAG = "canary";
-const updateCachePath = (home = homedir()) => path.join(home, ".ork", "update-check.json");
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const text = (record, key) => {
-	const value = record[key];
-	return typeof value === "string" ? value : void 0;
-};
-const notifiedOf = (value) => {
-	if (!isRecord(value)) return void 0;
-	const version = text(value, "version");
-	const at = text(value, "at");
-	return version === void 0 || at === void 0 ? void 0 : {
-		version,
-		at
-	};
-};
-/** The cache, or `null` when there is none or it cannot be read. */
-const readUpdateCache = (file) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return null;
-	}
-	if (!isRecord(parsed)) return null;
-	const checkedAt = text(parsed, "checkedAt");
-	if (checkedAt === void 0) return null;
-	const latest = text(parsed, "latest");
-	const notified = notifiedOf(parsed["notified"]);
-	return {
-		checkedAt,
-		...latest === void 0 ? {} : { latest },
-		...notified === void 0 ? {} : { notified }
-	};
-};
-/** Writes the cache whole (a temporary file, then a rename). */
-const writeUpdateCache = (file, cache) => {
-	mkdirSync(path.dirname(file), { recursive: true });
-	const temporary = `${file}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(cache, null, 2)}\n`);
-	renameSync(temporary, file);
-};
-const age = (iso, now) => {
-	const time = Date.parse(iso);
-	return Number.isNaN(time) ? Infinity : now.getTime() - time;
-};
-/** Whether it is time to ask the registry again. */
-const checkDue = (cache, now) => cache === null || age(cache.checkedAt, now) >= 864e5;
-/** Whether `version` is a canary snapshot: its pre-release starts `canary`. */
-const isCanary = (version) => parseVersion(version)?.pre[0]?.startsWith(CANARY_TAG) === true;
-/**
-* The newest version, by semver precedence, among the dist-tags `current`
-* follows: the channel tags, and `canary` too when `current` is a canary. A tag
-* whose value doesn't parse is skipped; `null` when none does.
-*/
-const newestTagged = (tags, current) => {
-	return (current !== void 0 && isCanary(current) ? [...CHANNEL_TAGS, "canary"] : CHANNEL_TAGS).flatMap((tag) => {
-		const value = tags[tag];
-		const version = typeof value === "string" ? parseVersion(value) : null;
-		return typeof value === "string" && version !== null ? [{
-			value,
-			version
-		}] : [];
-	}).reduce((best, candidate) => best === null || compareVersions(candidate.version, best.version) > 0 ? candidate : best, null)?.value ?? null;
-};
-/**
-* The newest version on the registry that the running version follows ({@link
-* newestTagged}), or `null` on any failure.
-*/
-const fetchLatest = async (name, options = {}) => {
-	const registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/+$/u, "");
-	const get = options.fetch ?? globalThis.fetch;
-	try {
-		const response = await get(`${registry}/-/package/${name}/dist-tags`, {
-			headers: { accept: "application/json" },
-			signal: AbortSignal.timeout(options.timeoutMs ?? 5e3)
-		});
-		if (!response.ok) return null;
-		const tags = await response.json();
-		return isRecord(tags) ? newestTagged(tags, options.current) : null;
-	} catch {
-		return null;
-	}
-};
-/**
-* Asks the registry and records the answer. A failed check is recorded too, so
-* an offline machine is not asked again until the interval passes; the last
-* known version is kept. `options.current` is the running version.
-*/
-const refreshUpdateCache = async (file, name, now, options = {}) => {
-	const before = readUpdateCache(file);
-	const latest = await fetchLatest(name, options) ?? before?.latest;
-	const cache = {
-		...before,
-		checkedAt: now.toISOString(),
-		...latest === void 0 ? {} : { latest }
-	};
-	writeUpdateCache(file, cache);
-	return cache;
-};
-/** The newer version the cache knows of, if any. */
-const newerVersion = (cache, current) => cache?.latest !== void 0 && isNewer(cache.latest, current) ? cache.latest : null;
-/**
-* The version to tell the user about now: newer than theirs, and not already
-* told today. `null` when there is nothing to say.
-*/
-const pendingNotice = (cache, current, now) => {
-	const newer = newerVersion(cache, current);
-	if (newer === null) return null;
-	const told = cache?.notified;
-	return told?.version === newer && age(told.at, now) < 864e5 ? null : newer;
-};
 /**
 * Runs the command; resolves its exit code. Without `onOutput` it writes on the
 * terminal.
@@ -558,59 +389,4 @@ const runInstall = (argv, onOutput) => new Promise((resolve) => {
 		resolve(code ?? 1);
 	});
 });
-// ../core/src/update/switches.ts
-/**
-* @file The environment's say over the update check (ADR-038): the variables
-*   that turn it off (`ORK_NO_UPDATE_CHECK`, the common `NO_UPDATE_NOTIFIER`,
-*   and `CI`), and the registry to ask instead of npm's. The CLI adds its own
-*   rules about where a notice may go; the server behind `ork ui` uses only
-*   these.
-*/
-/** Turns the automatic check and its notice off. */
-const NO_UPDATE_ENV = "ORK_NO_UPDATE_CHECK";
-/** A registry to ask instead of npm's, e.g. a company mirror. */
-const UPDATE_REGISTRY_ENV = "ORK_UPDATE_REGISTRY";
-/** The variables that turn the check off, in the order they are looked at. */
-const UPDATE_SWITCHES = [
-	NO_UPDATE_ENV,
-	"NO_UPDATE_NOTIFIER",
-	"CI"
-];
-/** Set to anything but empty, `0` or `false`. */
-const isSwitchedOn = (value) => value !== void 0 && value !== "" && value !== "0" && value.toLowerCase() !== "false";
-/** The variable that turns the check off in `env`, or `null` when none does. */
-const updateSwitchOff = (env) => UPDATE_SWITCHES.find((name) => isSwitchedOn(env[name])) ?? null;
-/** The registry `ORK_UPDATE_REGISTRY` names, if it names one. */
-const registryOf = (env) => {
-	const registry = env[UPDATE_REGISTRY_ENV];
-	return registry === void 0 || registry === "" ? void 0 : registry;
-};
-/** The host of a registry that isn't an http(s) URL, past any `user:pass@`. */
-const hostOf = (registry) => registry.replace(/^[a-z][\w+.-]*:\/\//iu, "").replace(/^[^/?#]*@/u, "").split(/[/?#]/u)[0] ?? "";
-/**
-* The registry as it may be shown (on a page, in a message): an http(s) URL
-* without its user name and password, which a mirror's URL may carry; anything
-* else only as its host.
-*/
-const registryShown = (registry) => {
-	try {
-		const url = new URL(registry);
-		if (url.protocol === "http:" || url.protocol === "https:") {
-			if (url.username === "" && url.password === "") return registry;
-			url.username = "";
-			url.password = "";
-			return url.href;
-		}
-	} catch {}
-	return hostOf(registry);
-};
-// src/__build_info__.ts
-/**
-* @file The published package's name and version, bound to
-*   `packages/cli/package.json`. Do not edit by hand: `pnpm changesets:version`
-*   and `pnpm build` rewrite it (`tools/release/build-info.ts`), and a test
-*   fails when it is stale.
-*/
-const ORK_NAME = "@krapht/ork";
-const ORK_VERSION = "1.0.0-alpha.14";
-export { feedbackActions as C, placeOf as S, previewPost as _, registryShown as a, acceptItem as b, checkDue as c, pendingNotice as d, readUpdateCache as f, nodeSession as g, writeUpdateCache as h, registryOf as i, fetchLatest as l, updateCachePath as m, ORK_VERSION as n, updateSwitchOff as o, refreshUpdateCache as p, isSwitchedOn as r, runInstall as s, ORK_NAME as t, newerVersion as u, checkNote as v, openFixRun as w, lessonPlaceOf as x, recordNote as y };
+export { acceptItem as a, feedbackActions as c, recordNote as i, openFixRun as l, previewPost as n, lessonPlaceOf as o, checkNote as r, placeOf as s, runInstall as t };

package/dist/{limits-Dhe--wmX.mjs → limits-B1qzS4cX.mjs}

@@ -1,4 +1,4 @@
-import { C as capsHere, Dt as limitsNow, Et as NOT_STARTED, Ot as limitsReport } from "./src-tsuZRu0H.mjs";
+import { C as capsHere, bt as limitsReport, vt as NOT_STARTED, yt as limitsNow } from "./src-Dr_fTSu-.mjs";
 // src/run/limits.ts
 /**
 * @file The limits across runs that apply here (RFC-007): the user's settings

package/dist/{mcp-CsmboyXv.mjs → mcp-BOrVkyhN.mjs}

@@ -1,8 +1,8 @@
-import { A as isNewer } from "./src-tsuZRu0H.mjs";
-import { n as ORK_VERSION } from "./__build_info__-B82-dGJY.mjs";
-import { p as runMarkerIn } from "./src-C7z_6fhn.mjs";
-import { n as explainNode } from "./context-Y_I4Mofq.mjs";
-import { a as openMcp, c as refused, o as tool, s as answer } from "./src-8Mul0695.mjs";
+import { A as isNewer } from "./src-Dr_fTSu-.mjs";
+import { n as ORK_VERSION } from "./__build_info__-Bsb1kjgF.mjs";
+import { p as runMarkerIn } from "./src-DcrhgipG.mjs";
+import { n as explainNode } from "./context-BNqDw9z1.mjs";
+import { a as openMcp, c as refused, o as tool, s as answer } from "./src-DQKz2eOH.mjs";
 import { z } from "zod";
 import { defineCommand } from "citty";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -43,7 +43,7 @@ const orkMcpServer = (options = {}) => {
 		...options.script === void 0 ? {} : { script: options.script }
 	});
 	const all = [...opened.tools, explainTool(opened, options.home)];
-	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.14") ? tooOld(all, options.expects) : all;
+	const tools = options.expects !== void 0 && isNewer(options.expects, "1.0.0-alpha.15") ? tooOld(all, options.expects) : all;
 	const server = new McpServer({
 		name: "ork",
 		version: ORK_VERSION

package/dist/{once-CrwI-ZdN.mjs → once-C1fL3GVo.mjs}

@@ -1,7 +1,7 @@
-import "./src-tsuZRu0H.mjs";
-import { t as runOnce } from "./run-D8divGCs.mjs";
+import "./src-Dr_fTSu-.mjs";
+import { t as runOnce } from "./run-CiPsW9Kf.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { t as ago } from "./format-CvTE5CZQ.mjs";
+import { t as ago } from "./format-C8MsFj8_.mjs";
 import { spawn } from "node:child_process";
 import { defineCommand, parseArgs } from "citty";
 // src/commands/once.ts

package/dist/orphan-guard-BFKg8VSd.mjs

@@ -0,0 +1,58 @@
+import { Readable, Writable } from "node:stream";
+// ../core/src/machine/orphan-guard.ts
+/**
+* @file The orphan guard: a node's processes end with `ork`, whatever ends
+*   `ork` (SIGKILL, the OOM killer, a crash exit). A child started in its own
+*   process group (`detached: true`) under `sh` also starts a small watcher in
+*   that group, which reads a pipe that only `ork` holds open. `ork` never
+*   writes to it, so when `ork` dies the read sees EOF, and the watcher sends
+*   its own group (`kill 0`, never another's) SIGTERM, then SIGKILL after
+*   {@link KILL_AFTER_MS}. A line on the pipe instead lets the watcher exit
+*   quietly, and so does killing it, which is how a node that ends normally
+*   leaves its leftover background processes alone. POSIX only. Two uses:
+*
+*   - A shell that outlives the program (the tool runner's timing wrapper):
+*     `${orphanGuard(4)} w=$!; "$0" "$@" 4<&-; s=$?; kill -s KILL $w`, then
+*     spawn with a `"pipe"` at `stdio[4]` and call
+*     `holdGuard(child.stdio[4])`.
+*   - A shell that `exec`s the program (a session, so its pid stays the
+*     driver's): `${orphanGuard(3)} exec 3<&-; exec "$0" "$@"` (a bare `exec`
+*     closes the pipe: macOS's `sh` keeps a copy of one an `exec` command
+*     closes, which the driver would inherit), with a `"pipe"` at `stdio[3]`;
+*     nothing is left to kill the watcher, so call the function `holdGuard`
+*     returns once the driver has exited (on `exit`: the pipe holds `close`).
+*/
+/** How long the group gets to end after SIGTERM before SIGKILL. */
+const KILL_AFTER_MS = 2e3;
+/** The file descriptors a redirect can name in every POSIX shell. */
+const SHELL_FDS = [
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9
+];
+/**
+* Shell text that starts the watcher in the background on pipe `fd` (3 to 9);
+* it ends with `&`, so `$!` after it is the watcher's pid. The watcher holds no
+* other descriptor, so it never keeps the child's output pipes open.
+*/
+const orphanGuard = (fd) => {
+	const others = SHELL_FDS.filter((other) => other !== fd).map((other) => `${String(other)}>&-`).join(" ");
+	return `{ read -r _ork <&${String(fd)} || { trap '' TERM; kill -s TERM 0; sleep ${String(KILL_AFTER_MS / 1e3)}; kill -s KILL 0; }; } </dev/null >/dev/null 2>&1 ${others} & `;
+};
+/**
+* Keeps `ork`'s end of the watch pipe (`child.stdio[fd]`) open and drained, so
+* it never holds back the child's `close`; returns the release, which writes
+* the line that lets the watcher exit without touching its group.
+*/
+const holdGuard = (pipe) => {
+	pipe?.on("error", () => {});
+	if (pipe instanceof Readable) pipe.resume();
+	return () => {
+		if (pipe instanceof Writable && pipe.writable) pipe.write("\n");
+	};
+};
+export { holdGuard as n, orphanGuard as r, KILL_AFTER_MS as t };

package/dist/{pause-DssrYcda.mjs → pause-DOMK-R8V.mjs}

@@ -1,7 +1,7 @@
-import { U as openStore, _t as requestPause, gt as requestContinue } from "./src-tsuZRu0H.mjs";
-import { t as findRun } from "./find-BVX-bL4u.mjs";
+import { U as openStore, bn as requestPause, yn as requestContinue } from "./src-Dr_fTSu-.mjs";
+import { t as findRun } from "./find-BYLlszqj.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
-import { i as continueRefusal } from "./in-a-run-cL5N9gpH.mjs";
+import { i as continueRefusal } from "./in-a-run-Bp0k0J09.mjs";
 import { defineCommand } from "citty";
 // src/commands/pause.ts
 /**

package/dist/post-BzA6Qobq.mjs

@@ -0,0 +1,44 @@
+import { Qn as redact } from "./src-Dr_fTSu-.mjs";
+// ../core/src/follow-ups/post.ts
+/** Posts `f`'s draft as a GitHub comment once `confirmed`, and marks it done. */
+const postFollowUpMessage = async (f, options) => {
+	const draft = f.draft;
+	if (f.kind !== "message" || draft?.channel !== "github") return {
+		ok: false,
+		error: "only a message drafted for the github channel is posted; send the others yourself"
+	};
+	if (!options.confirmed) return {
+		ok: false,
+		error: "posting to GitHub needs the maintainer's confirmation"
+	};
+	const body = redact(draft.text, {
+		roots: [f.project],
+		home: options.home
+	});
+	const on = /\/pull\/\d+/u.test(draft.to) ? "pr" : "issue";
+	const result = await options.gh([
+		on,
+		"comment",
+		draft.to,
+		"--body",
+		body
+	], { cwd: f.project });
+	if (!result.ok) return {
+		ok: false,
+		error: `gh failed: ${result.stderr.trim() || result.stdout.trim() || "no output"}`
+	};
+	const url = result.stdout.trim().split("\n").findLast((line) => line.startsWith("https://"));
+	const done = {
+		...f,
+		status: "done",
+		note: `posted${url === void 0 ? "" : ` as ${url}`}`,
+		updatedAt: options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+	options.rows.putFollowUp(done);
+	return {
+		ok: true,
+		followUp: done,
+		...url === void 0 ? {} : { url }
+	};
+};
+export { postFollowUpMessage as t };

package/dist/{relay-DASRgsTQ.mjs → relay-OWuu4fib.mjs}

@@ -1,4 +1,4 @@
-import { U as openStore, ft as addressOf, ht as unlinkNodes, mt as linkNodes } from "./src-tsuZRu0H.mjs";
+import { U as openStore, _n as linkNodes, hn as addressOf, vn as unlinkNodes } from "./src-Dr_fTSu-.mjs";
 import { c as write, l as writeErr, s as style } from "./output-B1kwo0YU.mjs";
 import { defineCommand } from "citty";
 // src/commands/relay.ts