@sm-lab/keys 0.2.0

package/dist/cli.mjs

@@ -0,0 +1,718 @@
+#!/usr/bin/env node
+import { n as writeDepositDataFile, r as makeDepositKeys, s as CHAINS, t as toDepositDataJson } from "./io-BtF203qz.mjs";
+import { readFileSync } from "node:fs";
+import { Argument, Command, Option } 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
+const CHAIN_CHOICES = Object.keys(CHAINS);
+const WC_TYPE_CHOICES = ["0x01", "0x02"];
+/** Serialize bigint values to decimal strings; all other values pass through. */
+const bigintReplacer = (_k, v) => typeof v === "bigint" ? v.toString() : v;
+/** Run an async action; print thrown errors to stderr and exit 1. */
+function run(fn) {
+	fn().catch((err) => {
+		console.error("Error:", err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	});
+}
+function buildProgram(deps = { makeDepositKeys }) {
+	return new Command().name("sm-keys").description("Generate real BLS validator deposit data for Lido SM (mainnet/hoodi); human mode: deposit_data.json to stdout (or --out), mnemonic to stderr").version(readPackageVersion(import.meta.url)).addOption(new Option("--chain <name>", "target chain").choices(CHAIN_CHOICES).default("hoodi")).option("--count <n>", "number of validators", "1").addOption(new Option("--type <wc>", "withdrawal credentials type").choices(WC_TYPE_CHOICES).default("0x01")).option("--mnemonic <phrase>", "BIP-39 mnemonic (random if omitted)").option("--wc <address>", "override withdrawal address (default: Lido vault)").option("--start-index <n>", "first validator index", "0").option("-o, --out <path>", "write deposit_data.json to <path> (else stdout)").option("--json", "emit result as JSON to stdout (mnemonic + keys with 0x-prefixed hex)").addHelpText("after", `
+Examples:
+  sm-keys 2 --json
+  sm-keys --count 5 --chain mainnet --json
+  sm-keys --json --out deposit_data.json`).argument("[count]", "number of validators (positional alias for --count)").helpCommand(true).addCommand(createCompletionCommand()).action((countArg, opts) => {
+		run(async () => {
+			const result = await deps.makeDepositKeys({
+				chain: opts.chain,
+				count: Number(countArg ?? opts.count),
+				type: opts.type,
+				mnemonic: opts.mnemonic,
+				withdrawalAddress: opts.wc,
+				startIndex: Number(opts.startIndex)
+			});
+			const { mnemonic, keys } = result;
+			if (opts.json) {
+				console.log(JSON.stringify(result, bigintReplacer, 2));
+				return;
+			}
+			console.error(`mnemonic: ${mnemonic}`);
+			if (opts.out) {
+				writeDepositDataFile(opts.out, keys);
+				console.error(`wrote ${keys.length} key(s) to ${opts.out}`);
+			} else console.log(toDepositDataJson(keys));
+		});
+	});
+}
+//#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