@sm-lab/recipes 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,1353 @@
+#!/usr/bin/env node
+import { a as deposit, d as addKeys, g as connect, i as getPubkey, n as topUpActiveKeys, r as getKeyBalance, t as increaseAllocatedBalance, v as resolveGate } from "./topup-B2NzJV7_.mjs";
+import { C as snapshot, E as operatorInfo, S as revert, a as setGateAddrs, b as proposeManager, c as cancelPenalty, d as settlePenalty, f as slash, h as unvet, i as submitRewards, l as compensatePenalty, m as exit, o as addBond, p as withdraw, r as makeRewards, s as createBondDebt, t as clActivate, u as reportPenalty, v as confirmManager, w as warpBy, x as proposeReward, y as confirmReward } from "./cl-activate-CPqr6v_D.mjs";
+import { createCuratedOperator, createOperatorGroup, resetOperatorGroup, seedCm, setBondCurveWeight } from "./cm.mjs";
+import { formatEther, isAddress, isHex, parseEther } from "viem";
+import "dotenv/config";
+import { Argument, Command } from "commander";
+import { Readable } from "node:stream";
+import { readFileSync } from "node:fs";
+//#endregion
+//#region ../../node_modules/.pnpm/@hono+node-server@2.0.6_hono@4.12.27/node_modules/@hono/node-server/dist/index.mjs
+const GlobalRequest = global.Request;
+var Request$1 = class extends GlobalRequest {
+	constructor(input, options) {
+		if (typeof input === "object" && getRequestCache in input) {
+			const hasReplacementBody = options !== void 0 && "body" in options && options.body != null;
+			if (input[bodyConsumedDirectlyKey] && !hasReplacementBody) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
+			input = input[getRequestCache]();
+		}
+		if (typeof (options?.body)?.getReader !== "undefined") options.duplex ??= "half";
+		super(input, options);
+	}
+};
+const newHeadersFromIncoming = (incoming) => {
+	const headerRecord = [];
+	const rawHeaders = incoming.rawHeaders;
+	for (let i = 0, len = rawHeaders.length; i < len; i += 2) {
+		const key = rawHeaders[i];
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, rawHeaders[i + 1]]);
+	}
+	return new Headers(headerRecord);
+};
+const wrapBodyStream = Symbol("wrapBodyStream");
+const newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+	const init = {
+		method,
+		headers,
+		signal: abortController.signal
+	};
+	if (method === "TRACE") {
+		init.method = "GET";
+		const req = new Request$1(url, init);
+		Object.defineProperty(req, "method", { get() {
+			return "TRACE";
+		} });
+		return req;
+	}
+	if (!(method === "GET" || method === "HEAD")) if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) init.body = new ReadableStream({ start(controller) {
+		controller.enqueue(incoming.rawBody);
+		controller.close();
+	} });
+	else if (incoming[wrapBodyStream]) {
+		let reader;
+		init.body = new ReadableStream({ async pull(controller) {
+			try {
+				reader ||= Readable.toWeb(incoming).getReader();
+				const { done, value } = await reader.read();
+				if (done) controller.close();
+				else controller.enqueue(value);
+			} catch (error) {
+				controller.error(error);
+			}
+		} });
+	} else init.body = Readable.toWeb(incoming);
+	return new Request$1(url, init);
+};
+const getRequestCache = Symbol("getRequestCache");
+const requestCache = Symbol("requestCache");
+const incomingKey = Symbol("incomingKey");
+const urlKey = Symbol("urlKey");
+const methodKey = Symbol("methodKey");
+const headersKey = Symbol("headersKey");
+const abortControllerKey = Symbol("abortControllerKey");
+const getAbortController = Symbol("getAbortController");
+const abortRequest = Symbol("abortRequest");
+const bodyBufferKey = Symbol("bodyBuffer");
+const bodyReadPromiseKey = Symbol("bodyReadPromise");
+const bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
+const bodyLockReaderKey = Symbol("bodyLockReader");
+const abortReasonKey = Symbol("abortReason");
+const newBodyUnusableError = () => {
+	return /* @__PURE__ */ new TypeError("Body is unusable");
+};
+const rejectBodyUnusable = () => {
+	return Promise.reject(newBodyUnusableError());
+};
+const textDecoder = new TextDecoder();
+const consumeBodyDirectOnce = (request) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	request[bodyConsumedDirectlyKey] = true;
+};
+const toArrayBuffer = (buf) => {
+	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+};
+const contentType = (request) => {
+	return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
+};
+const methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const validateDirectReadMethod = (method) => {
+	if (!methodTokenRegExp.test(method)) return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
+	const normalized = method.toUpperCase();
+	if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE") return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
+};
+const readBodyWithFastPath = (request, method, fromBuffer) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	const methodName = request.method;
+	if (methodName === "GET" || methodName === "HEAD") return request[getRequestCache]()[method]();
+	const methodValidationError = validateDirectReadMethod(methodName);
+	if (methodValidationError) return Promise.reject(methodValidationError);
+	if (request[requestCache]) {
+		if (methodName !== "TRACE") return request[requestCache][method]();
+	}
+	const alreadyUsedError = consumeBodyDirectOnce(request);
+	if (alreadyUsedError) return alreadyUsedError;
+	const raw = readRawBodyIfAvailable(request);
+	if (raw) {
+		const result = Promise.resolve(fromBuffer(raw, request));
+		request[bodyBufferKey] = void 0;
+		return result;
+	}
+	return readBodyDirect(request).then((buf) => {
+		const result = fromBuffer(buf, request);
+		request[bodyBufferKey] = void 0;
+		return result;
+	});
+};
+const readRawBodyIfAvailable = (request) => {
+	const incoming = request[incomingKey];
+	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
+};
+const readBodyDirect = (request) => {
+	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
+	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
+	const incoming = request[incomingKey];
+	if (Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	const promise = new Promise((resolve, reject) => {
+		const chunks = [];
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const onData = (chunk) => {
+			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		};
+		const onEnd = () => {
+			finish(() => {
+				const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+				request[bodyBufferKey] = buffer;
+				resolve(buffer);
+			});
+		};
+		const onError = (error) => {
+			finish(() => {
+				reject(error);
+			});
+		};
+		const onClose = () => {
+			if (incoming.readableEnded) {
+				onEnd();
+				return;
+			}
+			finish(() => {
+				if (incoming.errored) {
+					reject(incoming.errored);
+					return;
+				}
+				const reason = request[abortReasonKey];
+				if (reason !== void 0) {
+					reject(reason instanceof Error ? reason : new Error(String(reason)));
+					return;
+				}
+				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+			});
+		};
+		const cleanup = () => {
+			incoming.off("data", onData);
+			incoming.off("end", onEnd);
+			incoming.off("error", onError);
+			incoming.off("close", onClose);
+			request[bodyReadPromiseKey] = void 0;
+		};
+		incoming.on("data", onData);
+		incoming.on("end", onEnd);
+		incoming.on("error", onError);
+		incoming.on("close", onClose);
+		queueMicrotask(() => {
+			if (settled) return;
+			if (incoming.readableEnded) onEnd();
+			else if (incoming.errored) onError(incoming.errored);
+			else if (incoming.destroyed) onClose();
+		});
+	});
+	request[bodyReadPromiseKey] = promise;
+	return promise;
+};
+const requestPrototype = {
+	get method() {
+		return this[methodKey];
+	},
+	get url() {
+		return this[urlKey];
+	},
+	get headers() {
+		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+	},
+	[abortRequest](reason) {
+		if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason;
+		const abortController = this[abortControllerKey];
+		if (abortController && !abortController.signal.aborted) abortController.abort(reason);
+	},
+	[getAbortController]() {
+		this[abortControllerKey] ||= new AbortController();
+		if (this[abortReasonKey] !== void 0 && !this[abortControllerKey].signal.aborted) this[abortControllerKey].abort(this[abortReasonKey]);
+		return this[abortControllerKey];
+	},
+	[getRequestCache]() {
+		const abortController = this[getAbortController]();
+		if (this[requestCache]) return this[requestCache];
+		const method = this.method;
+		if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
+			this[bodyBufferKey] = void 0;
+			const init = {
+				method: method === "TRACE" ? "GET" : method,
+				headers: this.headers,
+				signal: abortController.signal
+			};
+			if (method !== "TRACE") {
+				init.body = new ReadableStream({ start(c) {
+					c.close();
+				} });
+				init.duplex = "half";
+			}
+			const req = new Request$1(this[urlKey], init);
+			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
+				return "TRACE";
+			} });
+			return this[requestCache] = req;
+		}
+		return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
+	},
+	get body() {
+		if (!this[bodyConsumedDirectlyKey]) return this[getRequestCache]().body;
+		const request = this[getRequestCache]();
+		if (!this[bodyLockReaderKey] && request.body) this[bodyLockReaderKey] = request.body.getReader();
+		return request.body;
+	},
+	get bodyUsed() {
+		if (this[bodyConsumedDirectlyKey]) return true;
+		if (this[requestCache]) return this[requestCache].bodyUsed;
+		return false;
+	}
+};
+Object.defineProperty(requestPrototype, "signal", { get() {
+	return this[getAbortController]().signal;
+} });
+[
+	"cache",
+	"credentials",
+	"destination",
+	"integrity",
+	"mode",
+	"redirect",
+	"referrer",
+	"referrerPolicy",
+	"keepalive"
+].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { get() {
+		return this[getRequestCache]()[k];
+	} });
+});
+["clone", "formData"].forEach((k) => {
+	Object.defineProperty(requestPrototype, k, { value: function() {
+		if (this[bodyConsumedDirectlyKey]) {
+			if (k === "clone") throw newBodyUnusableError();
+			return rejectBodyUnusable();
+		}
+		return this[getRequestCache]()[k]();
+	} });
+});
+Object.defineProperty(requestPrototype, "text", { value: function() {
+	return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
+} });
+Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
+	return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
+} });
+Object.defineProperty(requestPrototype, "blob", { value: function() {
+	return readBodyWithFastPath(this, "blob", (buf, request) => {
+		const type = contentType(request);
+		return new Response(buf, type ? { headers: { "content-type": type } } : void 0).blob();
+	});
+} });
+Object.defineProperty(requestPrototype, "json", { value: function() {
+	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	return this.text().then(JSON.parse);
+} });
+Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+	return `Request (lightweight) ${inspectFn({
+		method: this.method,
+		url: this.url,
+		headers: this.headers,
+		nativeRequest: this[requestCache]
+	}, {
+		...options,
+		depth: depth == null ? null : depth - 1
+	})}`;
+} });
+Object.setPrototypeOf(requestPrototype, Request$1.prototype);
+const defaultContentType = "text/plain; charset=UTF-8";
+const responseCache = Symbol("responseCache");
+const getResponseCache = Symbol("getResponseCache");
+const cacheKey = Symbol("cache");
+const GlobalResponse = global.Response;
+var Response$1 = class Response$1 {
+	#body;
+	#init;
+	[getResponseCache]() {
+		const cache = this[cacheKey];
+		const liveHeaders = cache && cache[2] instanceof Headers ? cache[2] : void 0;
+		delete this[cacheKey];
+		return this[responseCache] ||= new GlobalResponse(this.#body, liveHeaders ? {
+			status: this.#init?.status,
+			statusText: this.#init?.statusText,
+			headers: liveHeaders
+		} : this.#init);
+	}
+	constructor(body, init) {
+		let headers;
+		this.#body = body;
+		if (init instanceof Response$1) {
+			const cachedGlobalResponse = init[responseCache];
+			if (cachedGlobalResponse) {
+				this.#init = cachedGlobalResponse;
+				this[getResponseCache]();
+				return;
+			} else {
+				this.#init = init.#init;
+				headers = new Headers(init.headers);
+			}
+		} else this.#init = init;
+		if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+			init?.status || 200,
+			body ?? null,
+			headers || init?.headers
+		];
+	}
+	get headers() {
+		const cache = this[cacheKey];
+		if (cache) {
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || (cache[1] === null ? void 0 : { "content-type": defaultContentType }));
+			return cache[2];
+		}
+		return this[getResponseCache]().headers;
+	}
+	get status() {
+		return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+	}
+	get ok() {
+		const status = this.status;
+		return status >= 200 && status < 300;
+	}
+};
+[
+	"body",
+	"bodyUsed",
+	"redirected",
+	"statusText",
+	"trailers",
+	"type",
+	"url"
+].forEach((k) => {
+	Object.defineProperty(Response$1.prototype, k, { get() {
+		return this[getResponseCache]()[k];
+	} });
+});
+[
+	"arrayBuffer",
+	"blob",
+	"clone",
+	"formData",
+	"json",
+	"text"
+].forEach((k) => {
+	Object.defineProperty(Response$1.prototype, k, { value: function() {
+		return this[getResponseCache]()[k]();
+	} });
+});
+Object.defineProperty(Response$1.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+	return `Response (lightweight) ${inspectFn({
+		status: this.status,
+		headers: this.headers,
+		ok: this.ok,
+		nativeResponse: this[responseCache]
+	}, {
+		...options,
+		depth: depth == null ? null : depth - 1
+	})}`;
+} });
+Object.setPrototypeOf(Response$1, GlobalResponse);
+Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
+const validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/;
+const parseRedirectUrl = (url) => {
+	if (url instanceof URL) return url.href;
+	if (validRedirectUrl.test(url)) return url;
+	return new URL(url).href;
+};
+const validRedirectStatuses = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+Object.defineProperty(Response$1, "redirect", {
+	value: function redirect(url, status = 302) {
+		if (!validRedirectStatuses.has(status)) throw new RangeError("Invalid status code");
+		return new Response$1(null, {
+			status,
+			headers: { location: parseRedirectUrl(url) }
+		});
+	},
+	writable: true,
+	configurable: true
+});
+Object.defineProperty(Response$1, "json", {
+	value: function json(data, init) {
+		const body = JSON.stringify(data);
+		if (body === void 0) throw new TypeError("The data is not JSON serializable");
+		const initHeaders = init?.headers;
+		let headers;
+		if (initHeaders) {
+			headers = new Headers(initHeaders);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		} else headers = { "content-type": "application/json" };
+		return new Response$1(body, {
+			status: init?.status ?? 200,
+			statusText: init?.statusText,
+			headers
+		});
+	},
+	writable: true,
+	configurable: true
+});
+globalThis.CloseEvent;
+//#endregion
+//#region ../../packages/core/src/admin.ts
+/**
+* Read the consuming package's version from its package.json at runtime.
+*
+* Pass `import.meta.url` from the CONSUMER module. core is bundled into each consumer, so
+* after the build this code runs from the consumer's `dist/` and package.json sits one
+* level up (`../package.json`). Never throws — returns 'unknown' on any failure.
+*/
+function readPackageVersion(metaUrl) {
+	try {
+		return JSON.parse(readFileSync(new URL("../package.json", metaUrl), "utf8")).version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+//#endregion
+//#region ../../packages/core/src/cli.ts
+/** Climb to the root program so commands at any nesting depth can read root-level options (e.g. --url). */
+function findRoot(cmd) {
+	let c = cmd;
+	while (c.parent) c = c.parent;
+	return c;
+}
+//#endregion
+//#region ../../packages/core/src/completion.ts
+const SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+function firstLine(text) {
+	return (text.split("\n")[0] ?? "").trim();
+}
+function toNode(cmd, path) {
+	return {
+		name: cmd.name(),
+		aliases: [...cmd.aliases()],
+		description: firstLine(cmd.description()),
+		path,
+		options: cmd.options.filter((o) => !o.hidden).map((o) => ({
+			short: o.short,
+			long: o.long,
+			description: firstLine(o.description),
+			takesValue: o.required || o.optional,
+			choices: o.argChoices ? [...o.argChoices] : void 0
+		})),
+		args: cmd.registeredArguments.map((a) => ({
+			name: a.name(),
+			description: firstLine(a.description),
+			variadic: a.variadic,
+			choices: a.argChoices ? [...a.argChoices] : void 0
+		})),
+		children: cmd.commands.map((c) => toNode(c, [...path, c.name()]))
+	};
+}
+/** Flatten in registration order — the emitters iterate this, so output is deterministic. */
+function walk(node) {
+	return [node, ...node.children.flatMap(walk)];
+}
+function namesOf(node) {
+	return [node.name, ...node.aliases];
+}
+function fishQuote(s) {
+	return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function emitFish(bin, root) {
+	const lines = [
+		`# fish completion for ${bin}`,
+		`# Load with: ${bin} completion fish | source`,
+		`# Or install: ${bin} completion fish > ~/.config/fish/completions/${bin}.fish`
+	];
+	for (const node of walk(root)) {
+		const seen = node.path.map((p) => `__fish_seen_subcommand_from ${p}`);
+		const childNames = node.children.flatMap(namesOf);
+		const hereParts = [...seen];
+		if (childNames.length > 0) hereParts.push(`not __fish_seen_subcommand_from ${childNames.join(" ")}`);
+		const here = hereParts.length > 0 ? ` -n ${fishQuote(hereParts.join("; and "))}` : "";
+		for (const child of node.children) for (const name of namesOf(child)) lines.push(`complete -c ${bin}${here} -f -a ${name} -d ${fishQuote(child.description)}`);
+		for (const opt of node.options) {
+			let line = `complete -c ${bin}${here}`;
+			if (opt.short) line += ` -s ${opt.short.replace(/^-+/, "")}`;
+			if (opt.long) line += ` -l ${opt.long.replace(/^-+/, "")}`;
+			if (opt.takesValue) line += opt.choices ? ` -x -a ${fishQuote(opt.choices.join(" "))}` : " -r";
+			line += ` -d ${fishQuote(opt.description)}`;
+			lines.push(line);
+		}
+		const atArgs = seen.length > 0 ? ` -n ${fishQuote(seen.join("; and "))}` : "";
+		for (const arg of node.args) if (arg.choices) {
+			const desc = arg.description || arg.name;
+			lines.push(`complete -c ${bin}${atArgs} -f -a ${fishQuote(arg.choices.join(" "))} -d ${fishQuote(desc)}`);
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+function sanitizeIdent(bin) {
+	return bin.replace(/[^A-Za-z0-9_]/g, "_");
+}
+/**
+* Case arms that descend the known subcommand tree token by token, normalising
+* aliases to the canonical path so a single lookup table serves both spellings.
+*/
+function descentCases(root, indent) {
+	return walk(root).filter((node) => node.path.length > 0).map((node) => {
+		const parent = node.path.slice(0, -1).join(" ");
+		return `${indent}${namesOf(node).map((name) => `"${parent ? `${parent} ${name}` : name}"`).join("|")}) path="${node.path.join(" ")}" ;;`;
+	});
+}
+function emitBash(bin, root) {
+	const fn = `_${sanitizeIdent(bin)}_completions`;
+	const optCases = walk(root).map((node) => {
+		const subs = node.children.flatMap(namesOf).join(" ");
+		const flags = node.options.flatMap((o) => [o.short, o.long]).filter((f) => f !== void 0).join(" ");
+		const args = node.args.flatMap((a) => a.choices ?? []).join(" ");
+		return `    "${node.path.join(" ")}") subs="${subs}"; flags="${flags}"; args="${args}" ;;`;
+	});
+	return [
+		`# bash completion for ${bin}`,
+		`# Load with: source <(${bin} completion bash)`,
+		`${fn}() {`,
+		"  local cur path try w i subs flags args",
+		"  cur=\"${COMP_WORDS[COMP_CWORD]}\"",
+		"  path=\"\"",
+		"  for ((i = 1; i < COMP_CWORD; i++)); do",
+		"    w=\"${COMP_WORDS[i]}\"",
+		"    [[ \"$w\" == -* ]] && continue",
+		"    try=\"${path:+$path }$w\"",
+		"    case \"$try\" in",
+		...descentCases(root, "      "),
+		"      *) ;;",
+		"    esac",
+		"  done",
+		"  subs=\"\"; flags=\"\"; args=\"\"",
+		"  case \"$path\" in",
+		...optCases,
+		"  esac",
+		"  if [[ \"$cur\" == -* ]]; then",
+		"    COMPREPLY=($(compgen -W \"$flags\" -- \"$cur\"))",
+		"  elif [[ -n \"$subs\" ]]; then",
+		"    COMPREPLY=($(compgen -W \"$subs\" -- \"$cur\"))",
+		"  elif [[ -n \"$args\" ]]; then",
+		"    COMPREPLY=($(compgen -W \"$args\" -- \"$cur\"))",
+		"  else",
+		"    COMPREPLY=($(compgen -f -- \"$cur\"))",
+		"  fi",
+		"}",
+		`complete -F ${fn} ${bin}`,
+		""
+	].join("\n");
+}
+function zshItem(name, description) {
+	return `'${`${name}:${description}`.replace(/'/g, `'\\''`)}'`;
+}
+function emitZsh(bin, root) {
+	const fn = `_${sanitizeIdent(bin)}`;
+	const optCases = walk(root).map((node) => {
+		const subs = node.children.flatMap((child) => namesOf(child).map((name) => zshItem(name, child.description))).join(" ");
+		const flags = node.options.flatMap((o) => [o.short, o.long].filter((f) => f !== void 0).map((f) => zshItem(f, o.description))).join(" ");
+		const args = node.args.flatMap((a) => (a.choices ?? []).map((c) => zshItem(c, a.description || a.name))).join(" ");
+		const body = [
+			subs ? `subs=(${subs})` : void 0,
+			flags ? `flags=(${flags})` : void 0,
+			args ? `argwords=(${args})` : void 0
+		].filter((p) => p !== void 0).join("; ");
+		return `    "${node.path.join(" ")}") ${body ? `${body} ` : ""};;`;
+	});
+	return [
+		`#compdef ${bin}`,
+		`# zsh completion for ${bin}`,
+		`# Install: ${bin} completion zsh > "\${fpath[1]}/_${bin}" (then restart zsh)`,
+		`${fn}() {`,
+		"  local -a subs flags argwords",
+		"  local path=\"\" try w",
+		"  for w in \"${(@)words[2,CURRENT-1]}\"; do",
+		"    [[ \"$w\" == -* ]] && continue",
+		"    try=\"${path:+$path }$w\"",
+		"    case \"$try\" in",
+		...descentCases(root, "      "),
+		"      *) ;;",
+		"    esac",
+		"  done",
+		"  case \"$path\" in",
+		...optCases,
+		"  esac",
+		"  if [[ \"$PREFIX\" == -* ]]; then",
+		"    (( ${#flags[@]} )) && _describe -t options 'option' flags",
+		"  elif (( ${#subs[@]} )); then",
+		"    _describe -t commands 'command' subs",
+		"  elif (( ${#argwords[@]} )); then",
+		"    _describe -t values 'value' argwords",
+		"  else",
+		"    _files",
+		"  fi",
+		"}",
+		`if [[ "\${funcstack[1]}" == "${fn}" ]]; then`,
+		`  ${fn} "$@"`,
+		"else",
+		`  compdef ${fn} ${bin}`,
+		"fi",
+		""
+	].join("\n");
+}
+/**
+* Build a fully static, self-contained shell-completion script for `root`'s command
+* tree (subcommands at any depth, aliases, flags, option/argument choices). Pure:
+* output depends only on the tree, iterated in registration order.
+*/
+function buildCompletionScript(root, shell) {
+	const bin = root.name();
+	const tree = toNode(root, []);
+	switch (shell) {
+		case "fish": return emitFish(bin, tree);
+		case "bash": return emitBash(bin, tree);
+		case "zsh": return emitZsh(bin, tree);
+	}
+}
+/**
+* Build a `completion <shell>` subcommand that prints the static completion script
+* for the ROOT program (resolved by walking `.parent`) to stdout.
+*/
+function createCompletionCommand() {
+	return new Command("completion").description("Print a static shell-completion script for bash, zsh or fish. Load it in your shell, e.g. fish: `sm-cl completion fish | source`").addArgument(new Argument("<shell>", "target shell").choices(SHELLS)).action((shell, _opts, cmd) => {
+		process.stdout.write(buildCompletionScript(findRoot(cmd), shell));
+	});
+}
+//#endregion
+//#region src/cli/define.ts
+function toBigInt(s) {
+	return BigInt(s);
+}
+function toNumber(s) {
+	const n = Number(s);
+	if (Number.isNaN(n)) throw new Error(`not a number: ${s}`);
+	return n;
+}
+/** ETH (decimal string) → wei bigint. String-based; 1 wei → 1n. */
+function toEth(s) {
+	return parseEther(s);
+}
+function toHexValue(s) {
+	if (!isHex(s)) throw new Error(`not a 0x-hex value: ${s}`);
+	return s;
+}
+function toAddressValue(s) {
+	if (!isAddress(s)) throw new Error(`not an address: ${s}`);
+	return s;
+}
+function identity(s) {
+	return s;
+}
+/** Repeatable '--pair <noId:bps>' → [bigint, bigint][]. */
+function toPairs(raw) {
+	return raw.map((p) => {
+		const [a, b] = p.split(":");
+		if (a === void 0 || b === void 0) throw new Error(`bad pair "${p}", want noId:bps`);
+		return [BigInt(a), BigInt(b)];
+	});
+}
+/** Repeatable '--address <addr>' → Hex[]. */
+function toAddresses(raw) {
+	return raw.map(toAddressValue);
+}
+/** kebab name of a flag's long form, e.g. '--operator-id <id>' → 'operator-id'. */
+function flagName(flag) {
+	return (flag.split(/[ ,]+/).find((t) => t.startsWith("--")) ?? flag).replace(/^--/, "").replace(/<.*$/, "").trim();
+}
+/** commander's camelCased property name for a flag spec (mirrors commander's own rule). */
+function flagProp(flag) {
+	return flagName(flag).replace(/-([a-z])/g, (_m, c) => c.toUpperCase());
+}
+const bigintReplacer = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+/** Run an async action; print thrown errors cleanly and exit non-zero. */
+function run(fn) {
+	fn().catch((err) => {
+		console.error("Error:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	});
+}
+const collect = (v, acc) => [...acc, v];
+const COERCER_HELP = /* @__PURE__ */ new Map([
+	[toEth, "amount in ETH (decimal, 1-wei exact)"],
+	[toBigInt, "unsigned integer"],
+	[toNumber, "number"],
+	[toHexValue, "0x-prefixed hex value"],
+	[toAddressValue, "0x… address"],
+	[toAddresses, "0x… address"],
+	[toPairs, "noId:bps pair"]
+]);
+const optionHelp = (o) => o.description ?? COERCER_HELP.get(o.coerce) ?? "";
+/** Whether an option is also accepted positionally — explicit `positional`, else required && !repeatable. */
+const isPositional = (o) => o.positional ?? (!!o.required && !o.repeatable);
+function defineCommand(desc, connectImpl = connect) {
+	const cmd = new Command(desc.name).description(desc.summary);
+	for (const o of desc.options) if (o.repeatable) cmd.option(o.flag, optionHelp(o), collect, []);
+	else cmd.option(o.flag, optionHelp(o));
+	const positionals = desc.options.filter(isPositional);
+	const variadicAt = positionals.findIndex((o) => o.repeatable);
+	if (variadicAt >= 0 && variadicAt !== positionals.length - 1) throw new Error(`${desc.name}: a repeatable positional must be declared last (it is variadic)`);
+	for (const o of positionals) cmd.argument(`[${flagName(o.flag)}${o.repeatable ? "..." : ""}]`, optionHelp(o));
+	if (positionals.length > 0) {
+		const order = positionals.map((o) => flagName(o.flag) + (o.repeatable ? "..." : "")).join(", ");
+		cmd.addHelpText("after", `\nRequired options may be passed positionally in this order: ${order}`);
+	}
+	cmd.action((...actionArgs) => {
+		const command = actionArgs.at(-1);
+		const positionalValues = command.processedArgs;
+		run(async () => {
+			const g = command.optsWithGlobals();
+			const opts = {};
+			for (const o of desc.options) {
+				const posIndex = positionals.indexOf(o);
+				const posVal = posIndex >= 0 ? positionalValues[posIndex] : void 0;
+				const raw = (o.repeatable ? Array.isArray(posVal) && posVal.length > 0 : posVal != null) ? posVal : g[flagProp(o.flag)];
+				if (raw === void 0 || o.repeatable && raw.length === 0) {
+					if (o.required) throw new Error(`missing required option ${o.flag.split(" ")[0]}`);
+					continue;
+				}
+				opts[o.key] = o.coerce(raw);
+			}
+			const moduleName = desc.module ?? g.module;
+			if (!moduleName) throw new Error("set --module <csm|cm>");
+			const rpcUrl = g.rpcUrl ?? process.env.RPC_URL ?? "http://127.0.0.1:8545";
+			const clMockUrl = g.clMockUrl ?? process.env.CL_MOCK_URL;
+			if (desc.needsClMock && !clMockUrl) throw new Error(`${desc.name} needs --cl-mock-url or CL_MOCK_URL`);
+			const ctx = await connectImpl({
+				module: moduleName,
+				rpcUrl,
+				clMockUrl
+			});
+			const result = await desc.run(ctx, opts);
+			if (g.json) console.log(JSON.stringify(result === void 0 ? { ok: true } : result, bigintReplacer, 2));
+			else for (const line of desc.report(result, opts)) console.log(line);
+		});
+	});
+	return cmd;
+}
+//#endregion
+//#region src/cli/commands/shared.ts
+const operatorId$1 = {
+	flag: "--operator-id <id>",
+	key: "noId",
+	coerce: toBigInt,
+	required: true,
+	description: "node operator id (uint)"
+};
+const keyIndex = {
+	flag: "--key-index <i>",
+	key: "keyIndex",
+	coerce: toBigInt,
+	required: true,
+	description: "zero-based key index within the operator"
+};
+const seedHex = {
+	flag: "--seed <hex>",
+	key: "seed",
+	coerce: toHexValue,
+	description: "deterministic seed (0x-hex); omit for fresh randomness"
+};
+const cidEscape = (which) => ({
+	coerce: identity,
+	description: `skip IPFS pinning by supplying the ${which} CID — no running sm-ipfs needed`
+});
+const sharedCommands = [
+	{
+		name: "add-keys",
+		summary: "add N fresh validator keys to an operator (pays bond, as manager)",
+		options: [
+			operatorId$1,
+			{
+				flag: "--count <n>",
+				key: "count",
+				coerce: toNumber,
+				required: true
+			},
+			seedHex
+		],
+		run: (ctx, o) => addKeys(ctx, o),
+		report: (r, o) => [`operator ${o.noId}: +${o.count} keys`, `pubkeys: ${r.publicKeys.join(", ")}`]
+	},
+	{
+		name: "operator-info",
+		summary: "read a node operator's on-chain record (addresses + key counts); one field per line, --json for the raw object",
+		options: [operatorId$1],
+		run: (ctx, o) => operatorInfo(ctx, o),
+		report: (r, o) => [`operator ${o.noId}:`, ...Object.entries(r).map(([k, v]) => `  ${k}: ${String(v)}`)]
+	},
+	{
+		name: "deposit",
+		summary: "deposit N depositable keys (as the StakingRouter)",
+		options: [{
+			flag: "--count <n>",
+			key: "count",
+			coerce: toBigInt,
+			required: true
+		}],
+		run: (ctx, o) => deposit(ctx, o),
+		report: (r) => [`deposited: ${r.deposited}`]
+	},
+	{
+		name: "unvet",
+		summary: "set an operator vetted-keys count down (as the StakingRouter)",
+		options: [operatorId$1, {
+			flag: "--vetted-keys <n>",
+			key: "vettedKeys",
+			coerce: toBigInt,
+			required: true
+		}],
+		run: (ctx, o) => unvet(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: vetted=${o.vettedKeys}`]
+	},
+	{
+		name: "exit",
+		summary: "report exited keys for an operator (as the StakingRouter)",
+		options: [operatorId$1, {
+			flag: "--exited-keys <n>",
+			key: "exitedKeys",
+			coerce: toBigInt,
+			required: true
+		}],
+		run: (ctx, o) => exit(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: exited=${o.exitedKeys}`]
+	},
+	{
+		name: "increase-allocated-balance",
+		summary: "top up one deposited key's allocated balance (ETH)",
+		options: [
+			operatorId$1,
+			keyIndex,
+			{
+				flag: "--amount <eth>",
+				key: "amountWei",
+				coerce: toEth,
+				required: true
+			}
+		],
+		run: (ctx, o) => increaseAllocatedBalance(ctx, o),
+		report: (r) => [`+${formatEther(r.amountWei)} ETH allocated`]
+	},
+	{
+		name: "top-up-active-keys",
+		summary: "allocate deposit balance to every active key of an operator, in key-index order (TopUpQueueOps FIFO), as the StakingRouter; capped at 2016 ETH per key",
+		options: [operatorId$1],
+		run: (ctx, o) => topUpActiveKeys(ctx, o),
+		report: (r) => [`topped up ${r.toppedUp} key(s)`]
+	},
+	{
+		name: "slash",
+		summary: "slash a validator key (Verifier-gated)",
+		options: [operatorId$1, keyIndex],
+		run: (ctx, o) => slash(ctx, o),
+		report: (_r, o) => [`slashed operator ${o.noId} key ${o.keyIndex}`]
+	},
+	{
+		name: "withdraw",
+		summary: "report a withdrawn validator (Verifier-gated); balances in ETH",
+		options: [
+			operatorId$1,
+			keyIndex,
+			{
+				flag: "--exit-balance <eth>",
+				key: "exitBalance",
+				coerce: toEth,
+				required: true
+			},
+			{
+				flag: "--slashing-penalty <eth>",
+				key: "slashingPenalty",
+				coerce: toEth
+			}
+		],
+		run: (ctx, o) => withdraw(ctx, o),
+		report: (_r, o) => [`withdrew operator ${o.noId} key ${o.keyIndex}`]
+	},
+	{
+		name: "report-penalty",
+		summary: "report a general delayed penalty (ETH amount)",
+		options: [
+			operatorId$1,
+			{
+				flag: "--amount <eth>",
+				key: "amount",
+				coerce: toEth,
+				required: true
+			},
+			{
+				flag: "--penalty-type <hex>",
+				key: "penaltyType",
+				coerce: toHexValue
+			},
+			{
+				flag: "--details <text>",
+				key: "details",
+				coerce: identity
+			}
+		],
+		run: (ctx, o) => reportPenalty(ctx, o),
+		report: (_r, o) => [`reported penalty ${formatEther(o.amount)} ETH on operator ${o.noId}`]
+	},
+	{
+		name: "cancel-penalty",
+		summary: "cancel a reported general delayed penalty (ETH amount)",
+		options: [operatorId$1, {
+			flag: "--amount <eth>",
+			key: "amount",
+			coerce: toEth,
+			required: true
+		}],
+		run: (ctx, o) => cancelPenalty(ctx, o),
+		report: (_r, o) => [`cancelled penalty on operator ${o.noId}`]
+	},
+	{
+		name: "settle-penalty",
+		summary: "settle an operator's general delayed penalty (optional ETH cap)",
+		options: [operatorId$1, {
+			flag: "--max-amount <eth>",
+			key: "maxAmount",
+			coerce: toEth
+		}],
+		run: (ctx, o) => settlePenalty(ctx, o),
+		report: (_r, o) => [`settled penalty on operator ${o.noId}`]
+	},
+	{
+		name: "compensate-penalty",
+		summary: "compensate (pay off) an operator's penalty (as manager)",
+		options: [operatorId$1],
+		run: (ctx, o) => compensatePenalty(ctx, o),
+		report: (_r, o) => [`compensated penalty on operator ${o.noId}`]
+	},
+	{
+		name: "add-bond",
+		summary: "add bond to an operator (ETH)",
+		options: [operatorId$1, {
+			flag: "--amount <eth>",
+			key: "amount",
+			coerce: toEth,
+			required: true
+		}],
+		run: (ctx, o) => addBond(ctx, o),
+		report: (_r, o) => [`added ${formatEther(o.amount)} ETH bond to operator ${o.noId}`]
+	},
+	{
+		name: "create-bond-debt",
+		summary: "create a bond debt by penalizing an operator (ETH)",
+		options: [operatorId$1, {
+			flag: "--amount <eth>",
+			key: "amount",
+			coerce: toEth,
+			required: true
+		}],
+		run: (ctx, o) => createBondDebt(ctx, o),
+		report: (r, o) => [`operator ${o.noId}: debt created (penaltyCovered=${r.penaltyCovered})`]
+	},
+	{
+		name: "propose-manager",
+		summary: "propose a new manager address (as current manager)",
+		options: [operatorId$1, {
+			flag: "--proposed <address>",
+			key: "proposed",
+			coerce: toAddressValue,
+			required: true
+		}],
+		run: (ctx, o) => proposeManager(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: proposed manager ${o.proposed}`]
+	},
+	{
+		name: "confirm-manager",
+		summary: "confirm the proposed manager address (as proposed manager)",
+		options: [operatorId$1],
+		run: (ctx, o) => confirmManager(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: manager confirmed`]
+	},
+	{
+		name: "propose-reward",
+		summary: "propose a new reward address (as current manager)",
+		options: [operatorId$1, {
+			flag: "--proposed <address>",
+			key: "proposed",
+			coerce: toAddressValue,
+			required: true
+		}],
+		run: (ctx, o) => proposeReward(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: proposed reward ${o.proposed}`]
+	},
+	{
+		name: "confirm-reward",
+		summary: "confirm the proposed reward address (as proposed reward addr)",
+		options: [operatorId$1],
+		run: (ctx, o) => confirmReward(ctx, o),
+		report: (_r, o) => [`operator ${o.noId}: reward confirmed`]
+	},
+	{
+		name: "make-rewards",
+		summary: "build the cumulative rewards tree + pin to IPFS (no submit)",
+		options: [
+			seedHex,
+			{
+				flag: "--tree-cid <cid>",
+				key: "treeCid",
+				...cidEscape("tree")
+			},
+			{
+				flag: "--log-cid <cid>",
+				key: "logCid",
+				...cidEscape("report-log")
+			}
+		],
+		run: (ctx, o) => makeRewards(ctx, o),
+		report: (r) => [
+			`tree root: ${r.treeRoot}`,
+			`tree CID:  ${r.treeCid || "(none)"}`,
+			`log CID:   ${r.logCid || "(none)"}`,
+			`distributed: ${formatEther(r.distributed)} ETH`
+		]
+	},
+	{
+		name: "submit-rewards",
+		summary: "build AND submit a rewards report (warps to the next frame)",
+		options: [
+			seedHex,
+			{
+				flag: "--tree-cid <cid>",
+				key: "treeCid",
+				...cidEscape("tree")
+			},
+			{
+				flag: "--log-cid <cid>",
+				key: "logCid",
+				...cidEscape("report-log")
+			}
+		],
+		run: async (ctx, o) => submitRewards(ctx, await makeRewards(ctx, o)),
+		report: (r) => r.submitted ? [`submitted at refSlot ${r.refSlot}`, `reportHash: ${r.reportHash}`] : ["skipped: empty report (zero root)"]
+	},
+	{
+		name: "cl-activate",
+		summary: "mark a key active_ongoing on a running cl-mock (requires --cl-mock-url or CL_MOCK_URL)",
+		needsClMock: true,
+		options: [operatorId$1, keyIndex],
+		run: (ctx, o) => clActivate(ctx, o),
+		report: (r) => [`${r.pubkey}: ${r.status} @ ${r.effectiveBalanceGwei} gwei`]
+	},
+	{
+		name: "get-pubkey",
+		summary: "read a key's pubkey",
+		options: [operatorId$1, keyIndex],
+		run: (ctx, o) => getPubkey(ctx, o),
+		report: (r) => [r]
+	},
+	{
+		name: "get-key-balance",
+		summary: "read a key's allocated balance",
+		options: [operatorId$1, keyIndex],
+		run: (ctx, o) => getKeyBalance(ctx, o),
+		report: (r) => [`${formatEther(r)} ETH (${r} wei)`]
+	},
+	{
+		name: "warp",
+		summary: "advance the fork clock by N seconds",
+		options: [{
+			flag: "--by <seconds>",
+			key: "by",
+			coerce: toBigInt,
+			required: true
+		}],
+		run: (ctx, o) => warpBy(ctx, o.by),
+		report: (_r, o) => [`warped by ${o.by} seconds`]
+	},
+	{
+		name: "snapshot",
+		summary: "take an EVM snapshot, print its id",
+		options: [],
+		run: (ctx) => snapshot(ctx),
+		report: (r) => [`snapshot id: ${r}`]
+	},
+	{
+		name: "revert",
+		summary: "revert the fork to a snapshot id",
+		options: [{
+			flag: "--id <hex>",
+			key: "id",
+			coerce: toHexValue,
+			required: true
+		}],
+		run: (ctx, o) => revert(ctx, o.id),
+		report: (_r, o) => [`reverted to ${o.id}`]
+	}
+];
+//#endregion
+//#region src/cli/commands/cm.ts
+const operatorId = {
+	flag: "--operator-id <id>",
+	key: "noId",
+	coerce: toBigInt,
+	required: true,
+	description: "node operator id (uint)"
+};
+const cmSelectorHelp = "gate selector: po|pto|pgo|do|eeo|iodc|iodcp, gate index 0-6, or 0x… address";
+const cmCommands = [
+	{
+		name: "seed",
+		summary: "seed a realistic cm fork (3 operators, a group, keyed/deposited/topped-up)",
+		module: "cm",
+		options: [{
+			flag: "--selector <name>",
+			key: "selector",
+			coerce: identity,
+			description: `${cmSelectorHelp} (default: po)`
+		}, {
+			flag: "--seed <hex>",
+			key: "seed",
+			coerce: toHexValue,
+			description: "deterministic seed (0x-hex); omit for fresh randomness"
+		}],
+		run: (ctx, o) => seedCm(ctx, o),
+		report: (r) => [`seeded operators: ${r.noIds.join(", ")}`, `addresses: ${r.operators.join(", ")}`]
+	},
+	{
+		name: "create-curated-operator",
+		summary: "create a curated node operator through a cm gate as --operator (the new operator's address); prints the new operator id",
+		module: "cm",
+		options: [{
+			flag: "--selector <name>",
+			key: "selector",
+			coerce: identity,
+			required: true,
+			description: cmSelectorHelp
+		}, {
+			flag: "--operator <address>",
+			key: "operator",
+			coerce: toAddressValue,
+			required: true
+		}],
+		run: (ctx, o) => createCuratedOperator(ctx, o),
+		report: (r) => [`created operator ${r.noId}`]
+	},
+	{
+		name: "create-operator-group",
+		summary: "create a MetaRegistry operator group (--pair noId:bps, must sum to 10000)",
+		module: "cm",
+		options: [{
+			flag: "--pair <noId:bps>",
+			key: "pairs",
+			coerce: toPairs,
+			repeatable: true,
+			required: true
+		}],
+		run: (ctx, o) => createOperatorGroup(ctx, o),
+		report: (r) => [
+			`group created: ${r.subNodeOperators.length} member(s)`,
+			`members: ${r.subNodeOperators.map((s) => `${s.nodeOperatorId}@${s.share}bps`).join(", ")}`,
+			...r.resetGroupIds.length ? [`reset prior groups: ${r.resetGroupIds.join(", ")}`] : []
+		]
+	},
+	{
+		name: "reset-operator-group",
+		summary: "reset an operator's group membership",
+		module: "cm",
+		options: [operatorId],
+		run: (ctx, o) => resetOperatorGroup(ctx, o),
+		report: (_r, o) => [`reset group for operator ${o.noId}`]
+	},
+	{
+		name: "set-bond-curve-weight",
+		summary: "set the MetaRegistry bond-curve weight for a curve id (impersonates the role holder read from the contract)",
+		module: "cm",
+		options: [{
+			flag: "--curve-id <n>",
+			key: "curveId",
+			coerce: toBigInt,
+			required: true
+		}, {
+			flag: "--weight <n>",
+			key: "weight",
+			coerce: toBigInt,
+			required: true
+		}],
+		run: (ctx, o) => setBondCurveWeight(ctx, o),
+		report: (r) => [`curve ${r.curveId} weight=${r.weight}`]
+	},
+	{
+		name: "set-gate",
+		summary: "build + install a gate address tree (pins to IPFS unless --cid)",
+		module: "cm",
+		options: [
+			{
+				flag: "--selector <name>",
+				key: "selector",
+				coerce: identity,
+				positional: true,
+				description: `${cmSelectorHelp} (default: po)`
+			},
+			{
+				flag: "--address <addr>",
+				key: "addresses",
+				coerce: toAddresses,
+				repeatable: true,
+				required: true,
+				positional: true
+			},
+			{
+				flag: "--cid <cid>",
+				key: "cid",
+				coerce: identity,
+				description: "skip IPFS pinning by supplying the CID — no running sm-ipfs needed"
+			}
+		],
+		run: (ctx, o) => setGateAddrs(ctx, o),
+		report: (r) => [`tree root: ${r.treeRoot}`, `tree CID:  ${r.treeCid}`]
+	},
+	{
+		name: "resolve-gate",
+		summary: "resolve a cm gate contract address by selector (read-only); prints the address",
+		module: "cm",
+		options: [{
+			flag: "--selector <name>",
+			key: "selector",
+			coerce: identity,
+			required: true,
+			description: cmSelectorHelp
+		}],
+		run: (ctx, o) => resolveGate(ctx, o.selector),
+		report: (r, o) => [`${o.selector} → ${r}`]
+	}
+];
+//#endregion
+//#region src/cli/commands/csm.ts
+const csmSelectorHelp = "gate selector: ics (VettedGate) | idvtc (v3-only) | 0x… gate address";
+const csmCommands = [{
+	name: "set-gate",
+	summary: "build + install a gate address tree (pins to IPFS unless --cid)",
+	module: "csm",
+	options: [
+		{
+			flag: "--selector <name>",
+			key: "selector",
+			coerce: identity,
+			positional: true,
+			description: `${csmSelectorHelp} (default: ics)`
+		},
+		{
+			flag: "--address <addr>",
+			key: "addresses",
+			coerce: toAddresses,
+			repeatable: true,
+			required: true,
+			positional: true
+		},
+		{
+			flag: "--cid <cid>",
+			key: "cid",
+			coerce: identity,
+			description: "skip IPFS pinning by supplying the CID — no running sm-ipfs needed"
+		}
+	],
+	run: (ctx, o) => setGateAddrs(ctx, o),
+	report: (r) => [`tree root: ${r.treeRoot}`, `tree CID:  ${r.treeCid}`]
+}, {
+	name: "resolve-gate",
+	summary: "resolve a csm gate contract address by selector (read-only); prints the address",
+	module: "csm",
+	options: [{
+		flag: "--selector <name>",
+		key: "selector",
+		coerce: identity,
+		required: true,
+		description: csmSelectorHelp
+	}],
+	run: (ctx, o) => resolveGate(ctx, o.selector),
+	report: (r, o) => [`${o.selector} → ${r}`]
+}];
+//#endregion
+//#region src/cli/program.ts
+/** Pre-bind shared descriptors to a module so they run group-form without --module. */
+const withModule = (descs, module) => descs.map((d) => ({
+	...d,
+	module
+}));
+const showGlobals = (c) => {
+	c.configureHelp({ showGlobalOptions: true });
+	for (const child of c.commands) showGlobals(child);
+};
+function buildProgram(connectImpl = connect) {
+	const program = new Command().name("sm-recipes").description("Prepare Lido SM on-chain state on an anvil fork (run-and-exit recipes)").version(readPackageVersion(import.meta.url)).option("--rpc-url <url>", "anvil fork RPC URL (default: $RPC_URL or http://127.0.0.1:8545)").option("--module <csm|cm>", "target module for shared commands").option("--cl-mock-url <url>", "cl-mock URL for cl-activate (default: $CL_MOCK_URL)").option("--json", "emit the raw result as JSON").addHelpText("after", `
+Examples:
+  sm-recipes operator-info 0 --module csm --json
+  sm-recipes csm operator-info 0 --json
+  sm-recipes add-keys 0 --module cm --json
+  sm-recipes cm seed --json
+  sm-recipes completion fish | source`).helpCommand(true);
+	for (const desc of sharedCommands) program.addCommand(defineCommand(desc, connectImpl));
+	program.addCommand(createCompletionCommand());
+	const cm = new Command("cm").description("cm recipes + shared recipes (module forced to cm)");
+	for (const desc of [...cmCommands, ...withModule(sharedCommands, "cm")]) cm.addCommand(defineCommand(desc, connectImpl));
+	program.addCommand(cm);
+	const csm = new Command("csm").description("csm recipes + shared recipes (module forced to csm)");
+	for (const desc of [...csmCommands, ...withModule(sharedCommands, "csm")]) csm.addCommand(defineCommand(desc, connectImpl));
+	program.addCommand(csm);
+	showGlobals(program);
+	return program;
+}
+//#endregion
+//#region src/cli/index.ts
+buildProgram().parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map