@sm-lab/merkle 1.2.0

package/dist/cli.mjs

@@ -0,0 +1,796 @@
+#!/usr/bin/env node
+import { m as readJsonFile, n as makeRewards, p as readAddressFile, r as makeStrikes, t as makeAddresses } from "./pipelines-Dxpjkr0j.mjs";
+import { readFileSync } from "node:fs";
+import "dotenv/config";
+import { Argument, Command } from "commander";
+import { Readable } from "node:stream";
+//#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/program.ts
+/** Wrap an async action so thrown errors print 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 bigintReplacer = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+function report(label, result) {
+	console.log(`${label} tree root: ${result.treeRoot}`);
+	console.log(`${label} tree CID:  ${result.treeCid ?? "(upload skipped)"}`);
+	if (result.logCid) console.log(`${label} log  CID:  ${result.logCid}`);
+	if (result.configPath) console.log(`Wrote ${result.configPath}`);
+}
+function buildProgram(deps = {
+	makeAddresses,
+	makeStrikes,
+	makeRewards
+}) {
+	const program = new Command().name("sm-merkle").description("Lido SM Merkle tree builder — build a tree, pin it to IPFS, print root + CID").version(readPackageVersion(import.meta.url)).helpCommand(false);
+	program.command("addresses", { isDefault: true }).description("Build the addresses (vetted gate) tree, pin it to IPFS, print root + CID").argument("[addresses...]", "whitelist addresses (inline, or use --input / --source)").option("--input <addr>", "repeatable: add one address to the list", (v, acc) => {
+		acc.push(v);
+		return acc;
+	}, []).option("--source <file>", "load address list from a JSON array or newline-delimited .txt").option("--no-upload", "build/print root only, skip IPFS pinning").option("-o, --out <path>", "also write { treeRoot, treeCid } JSON to this path").option("--json", "print result as JSON to stdout (machine-readable)").action((positionals, opts) => {
+		run(async () => {
+			const hasInline = positionals.length > 0 || opts.input.length > 0;
+			const hasFile = Boolean(opts.source);
+			if (hasInline && hasFile) throw new Error("Cannot combine inline addresses (positionals / --input) with --source <file>. Use one or the other.");
+			let addresses;
+			if (hasFile) addresses = readAddressFile(opts.source);
+			else addresses = [...positionals, ...opts.input];
+			if (addresses.length === 0) throw new Error("No addresses supplied. Provide positional addresses, --input <addr>, or --source <file>.");
+			const result = await deps.makeAddresses(addresses, {
+				noUpload: !opts.upload,
+				configPath: opts.out
+			});
+			if (opts.json) console.log(JSON.stringify(result, bigintReplacer, 2));
+			else report("Addresses", result);
+		});
+	});
+	program.command("strikes").description("Build the strikes tree, pin it to IPFS, print root + CID").argument("<strikes>", "path to strikes.json — JSON array [{ nodeOperatorId, pubkey, strikes: number[] }]").option("--source <file>", "alternative flag for the strikes file path (same as positional)").option("--no-upload", "build/print root only, skip IPFS pinning").option("-o, --out <path>", "also write { treeRoot, treeCid } JSON to this path").option("--json", "print result as JSON to stdout (machine-readable)").action((strikesArg, opts) => {
+		run(async () => {
+			const strikesPath = opts.source ?? strikesArg;
+			const result = await deps.makeStrikes(strikesPath, {
+				noUpload: !opts.upload,
+				configPath: opts.out
+			});
+			if (opts.json) console.log(JSON.stringify(result, bigintReplacer, 2));
+			else report("Strikes", result);
+		});
+	});
+	program.command("rewards").description("Build the rewards tree from [nodeOperatorId, cumulativeShares] pairs, pin it").requiredOption("--source <file>", "JSON array of [nodeOperatorId, cumulativeShares] pairs (number or numeric-string)").option("--no-upload", "build/print root only, skip IPFS pinning").option("-o, --out <path>", "also write { treeRoot, treeCid } JSON to this path").option("--json", "print result as JSON to stdout (machine-readable)").action((opts) => {
+		run(async () => {
+			const raw = readJsonFile(opts.source);
+			if (raw.length === 0) throw new Error("No leaves supplied. Provide a non-empty JSON array of [nodeOperatorId, cumulativeShares] pairs.");
+			const leaves = raw.map(([noId, shares], i) => {
+				const toBig = (v, field) => {
+					if (typeof v === "bigint") return v;
+					if (typeof v === "number" || typeof v === "string") return BigInt(v);
+					throw new Error(`rewards --source: entry [${i}].${field} must be a number or numeric string, got ${typeof v}`);
+				};
+				return [toBig(noId, "0"), toBig(shares, "1")];
+			});
+			const result = await deps.makeRewards(leaves, {
+				noUpload: !opts.upload,
+				configPath: opts.out
+			});
+			if (opts.json) console.log(JSON.stringify(result, bigintReplacer, 2));
+			else report("Rewards", result);
+		});
+	});
+	program.command("help").description("Print a self-contained usage cheat sheet").action(() => {
+		console.log(`sm-merkle — Lido SM Merkle tree builder
+
+WHAT IT DOES
+  Build a Merkle tree from input, pin it to IPFS, and print the root + CID.
+  Pushing the root/CID on-chain is NOT this tool's job — that's @sm-lab/receipts.
+
+COMMANDS
+  addresses [addresses...]   build the addresses (vetted gate) tree (DEFAULT — bare args route here)
+  strikes <strikes>          build the strikes tree, pin to IPFS, print root + CID
+  rewards --source <file>    build the rewards tree from [noId, cumulativeShares] pairs
+  completion <shell>         print a bash|zsh|fish completion script (sm-merkle completion fish | source)
+  help                       print this cheat sheet
+
+FLAGS (all commands)
+  --no-upload          build/print the root only, skip IPFS pinning
+  -o, --out <path>     also write { treeRoot, treeCid } JSON to <path>
+  --json               print result as a single JSON value to stdout (machine-readable)
+
+FLAGS (addresses only)
+  --input <addr>       repeatable: add one address (can mix with positionals)
+  --source <file>      load from JSON array ["0x.."] or newline-delimited .txt
+                       (mutually exclusive with inline positionals / --input)
+
+ENV
+  IPFS_API_URL         pinning endpoint; unset → local @sm-lab/ipfs (http://127.0.0.1:5001).
+                       Pinata used only when PINATA_* creds are set (and IPFS_API_URL is unset).
+  PINATA_API_KEY/SECRET   Pinata credentials (or PINATA_JWT). Ignored by the mock.
+
+DATA FORMATS
+  addresses    JSON array ["0x..", ...] or newline-delimited text (# comments ok)
+  strikes      JSON array [{ nodeOperatorId, pubkey, strikes: number[] }]
+  rewards      JSON array [[nodeOperatorId, cumulativeShares], ...] (numbers or numeric strings)
+
+EXAMPLES
+  sm-merkle 0xABC 0xDEF                        # inline addresses → addresses (vetted gate) tree
+  sm-merkle addresses --source addrs.json --json
+  sm-merkle addresses --input 0xABC --input 0xDEF --no-upload
+  sm-merkle strikes strikes.json --no-upload --json
+  sm-merkle rewards --source rewards.json --json
+  sm-merkle addresses addrs.json -o config.json`);
+	});
+	program.addCommand(createCompletionCommand());
+	return program;
+}
+//#endregion
+//#region src/cli/index.ts
+buildProgram().parseAsync().catch((err) => {
+	console.error("Error:", err instanceof Error ? err.message : String(err));
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.mjs.map