@pixelzx/genesis 2026.5.3-2 → 2026.5.3-3

package/dist/register.subclis-BeGY5cHF.js

@@ -0,0 +1,3 @@
+import "./subcli-descriptors-B5nzvyS8.js";
+import { t as registerSubCliByName } from "./register.subclis-COA10rio.js";
+export { registerSubCliByName };

package/dist/register.subclis-COA10rio.js

@@ -0,0 +1,29 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-BIP3nEco.js";
+import { r as shouldRegisterPrimarySubcommandOnly, t as shouldEagerRegisterSubcommands } from "./command-registration-policy-B8ZdpbiI.js";
+import { i as buildCommandGroupEntries, n as registerSubCliByName$1, o as defineImportedProgramCommandGroupSpecs, r as registerSubCliCommands$1 } from "./register.subclis-core-DBrCeLqN.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-CfdK4t6G.js";
+import { n as getSubCliEntries } from "./subcli-descriptors-B5nzvyS8.js";
+//#region src/cli/program/register.subclis.ts
+const entrySpecs = [...defineImportedProgramCommandGroupSpecs([{
+	commandNames: ["completion"],
+	loadModule: () => import("./completion-cli-Du1dkhoP.js"),
+	exportName: "registerCompletionCli"
+}])];
+function resolveSubCliCommandGroups() {
+	return buildCommandGroupEntries(getSubCliEntries(), entrySpecs, (register) => register);
+}
+async function registerSubCliByName(program, name) {
+	if (await registerSubCliByName$1(program, name)) return true;
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(), name);
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	registerSubCliCommands$1(program, argv);
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveSubCliCommandGroups(), {
+		eager: shouldEagerRegisterSubcommands(),
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimarySubcommandOnly(argv))
+	});
+}
+//#endregion
+export { registerSubCliCommands as n, registerSubCliByName as t };

package/dist/register.subclis-core-DBrCeLqN.js

@@ -0,0 +1,243 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-BIP3nEco.js";
+import { r as shouldRegisterPrimarySubcommandOnly, t as shouldEagerRegisterSubcommands } from "./command-registration-policy-B8ZdpbiI.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-CfdK4t6G.js";
+import { n as getSubCliEntries$1, r as loadPrivateQaCliModule } from "./subcli-descriptors-B5nzvyS8.js";
+//#region src/cli/program/command-group-descriptors.ts
+function buildDescriptorIndex(descriptors) {
+	return new Map(descriptors.map((descriptor) => [descriptor.name, descriptor]));
+}
+function resolveCommandGroupEntries(descriptors, specs) {
+	const descriptorsByName = buildDescriptorIndex(descriptors);
+	return specs.map((spec) => ({
+		placeholders: spec.commandNames.map((name) => {
+			const descriptor = descriptorsByName.get(name);
+			if (!descriptor) throw new Error(`Unknown command descriptor: ${name}`);
+			return descriptor;
+		}),
+		register: spec.register
+	}));
+}
+function buildCommandGroupEntries(descriptors, specs, mapRegister) {
+	return resolveCommandGroupEntries(descriptors, specs).map((entry) => ({
+		placeholders: entry.placeholders,
+		register: mapRegister(entry.register)
+	}));
+}
+function defineImportedCommandGroupSpec(commandNames, loadModule, register) {
+	return {
+		commandNames,
+		register: async (args) => {
+			await register(await loadModule(), args);
+		}
+	};
+}
+function defineImportedProgramCommandGroupSpecs(definitions) {
+	return definitions.map((definition) => ({
+		commandNames: definition.commandNames,
+		register: async (program) => {
+			const register = (await definition.loadModule())[definition.exportName];
+			if (typeof register !== "function") throw new Error(`Missing program command registrar: ${definition.exportName}`);
+			await register(program);
+		}
+	}));
+}
+//#endregion
+//#region src/cli/program/register.subclis-core.ts
+async function registerSubCliWithPluginCommands(program, registerSubCli, pluginCliPosition) {
+	const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-CfP5iSkW.js");
+	if (pluginCliPosition === "before") await registerPluginCliCommandsFromValidatedConfig(program);
+	await registerSubCli();
+	if (pluginCliPosition === "after") await registerPluginCliCommandsFromValidatedConfig(program);
+}
+const entrySpecs = [
+	...defineImportedProgramCommandGroupSpecs([
+		{
+			commandNames: ["acp"],
+			loadModule: () => import("./acp-cli-NxFXWO1M.js"),
+			exportName: "registerAcpCli"
+		},
+		{
+			commandNames: ["gateway"],
+			loadModule: () => import("./gateway-cli-jaaJ3fg-.js"),
+			exportName: "registerGatewayCli"
+		},
+		{
+			commandNames: ["daemon"],
+			loadModule: () => import("./cli/daemon-cli.js"),
+			exportName: "registerDaemonCli"
+		},
+		{
+			commandNames: ["logs"],
+			loadModule: () => import("./logs-cli-DrKLI45U.js"),
+			exportName: "registerLogsCli"
+		},
+		{
+			commandNames: ["system"],
+			loadModule: () => import("./system-cli-DPiT7dwA.js"),
+			exportName: "registerSystemCli"
+		},
+		{
+			commandNames: ["models"],
+			loadModule: () => import("./models-cli-CZt8Jsll.js"),
+			exportName: "registerModelsCli"
+		},
+		{
+			commandNames: ["infer", "capability"],
+			loadModule: () => import("./capability-cli-mXxaAg87.js"),
+			exportName: "registerCapabilityCli"
+		},
+		{
+			commandNames: ["approvals"],
+			loadModule: () => import("./exec-approvals-cli-NfwQ3x1C.js"),
+			exportName: "registerExecApprovalsCli"
+		},
+		{
+			commandNames: ["exec-policy"],
+			loadModule: () => import("./exec-policy-cli-tmpS-qlM.js"),
+			exportName: "registerExecPolicyCli"
+		},
+		{
+			commandNames: ["nodes"],
+			loadModule: () => import("./nodes-cli-BspoieXR.js"),
+			exportName: "registerNodesCli"
+		},
+		{
+			commandNames: ["devices"],
+			loadModule: () => import("./devices-cli-DIvpz4kL.js"),
+			exportName: "registerDevicesCli"
+		},
+		{
+			commandNames: ["node"],
+			loadModule: () => import("./node-cli-BlCoOoMf.js"),
+			exportName: "registerNodeCli"
+		},
+		{
+			commandNames: ["sandbox"],
+			loadModule: () => import("./sandbox-cli-itOc7HPh.js"),
+			exportName: "registerSandboxCli"
+		},
+		{
+			commandNames: [
+				"tui",
+				"terminal",
+				"chat"
+			],
+			loadModule: () => import("./tui-cli-l39_SXF6.js"),
+			exportName: "registerTuiCli"
+		},
+		{
+			commandNames: ["cron"],
+			loadModule: () => import("./cron-cli-C5Gndyos.js"),
+			exportName: "registerCronCli"
+		},
+		{
+			commandNames: ["dns"],
+			loadModule: () => import("./dns-cli-BDSNnNzX.js"),
+			exportName: "registerDnsCli"
+		},
+		{
+			commandNames: ["docs"],
+			loadModule: () => import("./docs-cli-BbfVnYfF.js"),
+			exportName: "registerDocsCli"
+		},
+		{
+			commandNames: ["qa"],
+			loadModule: loadPrivateQaCliModule,
+			exportName: "registerQaLabCli"
+		},
+		{
+			commandNames: ["proxy"],
+			loadModule: () => import("./proxy-cli-C3rf-_N2.js"),
+			exportName: "registerProxyCli"
+		},
+		{
+			commandNames: ["hooks"],
+			loadModule: () => import("./hooks-cli-DDT-e8cJ.js"),
+			exportName: "registerHooksCli"
+		},
+		{
+			commandNames: ["webhooks"],
+			loadModule: () => import("./webhooks-cli-ClZehUnk.js"),
+			exportName: "registerWebhooksCli"
+		},
+		{
+			commandNames: ["qr"],
+			loadModule: () => import("./qr-cli-CIMpiVqT.js"),
+			exportName: "registerQrCli"
+		},
+		{
+			commandNames: ["clawbot"],
+			loadModule: () => import("./clawbot-cli-CSsLvJhI.js"),
+			exportName: "registerClawbotCli"
+		}
+	]),
+	{
+		commandNames: ["pairing"],
+		register: async (program) => {
+			await registerSubCliWithPluginCommands(program, async () => {
+				(await import("./pairing-cli-CKKGmQjs.js")).registerPairingCli(program);
+			}, "before");
+		}
+	},
+	{
+		commandNames: ["plugins"],
+		register: async (program) => {
+			await registerSubCliWithPluginCommands(program, async () => {
+				(await import("./plugins-cli-BYReZjY0.js")).registerPluginsCli(program);
+			}, "after");
+		}
+	},
+	...defineImportedProgramCommandGroupSpecs([
+		{
+			commandNames: ["channels"],
+			loadModule: () => import("./channels-cli-jNLEPssf.js"),
+			exportName: "registerChannelsCli"
+		},
+		{
+			commandNames: ["directory"],
+			loadModule: () => import("./directory-cli-DV1jDPkj.js"),
+			exportName: "registerDirectoryCli"
+		},
+		{
+			commandNames: ["security"],
+			loadModule: () => import("./security-cli-DWpmdyKz.js"),
+			exportName: "registerSecurityCli"
+		},
+		{
+			commandNames: ["secrets"],
+			loadModule: () => import("./secrets-cli-DsCbOPd8.js"),
+			exportName: "registerSecretsCli"
+		},
+		{
+			commandNames: ["skills"],
+			loadModule: () => import("./skills-cli-CSROtnca.js"),
+			exportName: "registerSkillsCli"
+		},
+		{
+			commandNames: ["update"],
+			loadModule: () => import("./update-cli-Iq8wyl0W.js"),
+			exportName: "registerUpdateCli"
+		}
+	])
+];
+function resolveSubCliCommandGroups() {
+	const descriptors = getSubCliEntries$1();
+	const descriptorNames = new Set(descriptors.map((descriptor) => descriptor.name));
+	return buildCommandGroupEntries(descriptors, entrySpecs.filter((spec) => spec.commandNames.every((name) => descriptorNames.has(name))), (register) => register);
+}
+function getSubCliEntries() {
+	return getSubCliEntries$1();
+}
+async function registerSubCliByName(program, name) {
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(), name);
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	const { primary } = resolveCliArgvInvocation(argv);
+	registerCommandGroups(program, resolveSubCliCommandGroups(), {
+		eager: shouldEagerRegisterSubcommands(),
+		primary,
+		registerPrimaryOnly: Boolean(primary && shouldRegisterPrimarySubcommandOnly(argv))
+	});
+}
+//#endregion
+export { defineImportedCommandGroupSpec as a, buildCommandGroupEntries as i, registerSubCliByName as n, defineImportedProgramCommandGroupSpecs as o, registerSubCliCommands as r, getSubCliEntries as t };

package/dist/register.wallet-D2TECwG5.js

@@ -0,0 +1,159 @@
+import { n as defaultRuntime, r as writeRuntimeJson } from "./runtime-CQ7eH0le.js";
+import { r as theme } from "./theme-BrRleVfL.js";
+import { n as runCommandWithRuntime } from "./cli-utils-CsLPn__A.js";
+import { a as initWallet, d as WALLET_CHAINS, i as importWallet, l as generateWalletMnemonic, n as getWalletBalanceForChain, o as quoteWalletTransaction, r as getWalletSummary, s as sendWallet, t as getWalletAccounts, u as LOCAL_KEYSTORE_WALLET_CHAINS } from "./service-BWLndtz9.js";
+//#region src/cli/program/register.wallet.ts
+const WALLET_CHAIN_SET = new Set(WALLET_CHAINS);
+async function readStdin(maxBytes = 64 * 1024) {
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of process.stdin) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+		total += buffer.length;
+		if (total > maxBytes) throw new Error("stdin input is too large");
+		chunks.push(buffer);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+async function readPassphrase(opts) {
+	const fromEnv = process.env.GENESIS_WALLET_PASSPHRASE?.trim();
+	if (fromEnv) return fromEnv;
+	if (opts.passphraseStdin) {
+		const value = (await readStdin(16 * 1024)).trim();
+		if (!value) throw new Error("--passphrase-stdin received an empty passphrase");
+		return value;
+	}
+	throw new Error("Set GENESIS_WALLET_PASSPHRASE or pass --passphrase-stdin.");
+}
+function parseChain(value) {
+	const chain = typeof value === "string" ? value.trim() : "";
+	if (!WALLET_CHAIN_SET.has(chain)) throw new Error(`--chain must be one of ${WALLET_CHAINS.join(", ")}`);
+	return chain;
+}
+function writeMaybeJson(opts, payload, text) {
+	if (opts.json) {
+		writeRuntimeJson(defaultRuntime, payload);
+		return;
+	}
+	text();
+}
+function formatAccountLine(account) {
+	const network = account.network ? ` ${theme.muted(`(${account.network})`)}` : "";
+	const derivation = account.derivationPath ? ` ${theme.muted(account.derivationPath)}` : "";
+	return `${theme.command(account.chain)} ${account.address}${network}${derivation}`;
+}
+async function showWalletSummary(opts) {
+	const summary = await getWalletSummary();
+	writeMaybeJson(opts, summary, () => {
+		defaultRuntime.log(theme.heading("Wallet"));
+		defaultRuntime.log(`Enabled: ${summary.enabled ? "yes" : "no"}`);
+		defaultRuntime.log(`Keystore: ${summary.keystore.exists ? "present" : "missing"}`);
+		if (summary.primaryAccount) defaultRuntime.log(`Primary: ${summary.primaryAccount}`);
+		if (summary.accounts.length === 0) defaultRuntime.log(theme.muted("No public wallet addresses found."));
+		else for (const account of summary.accounts) defaultRuntime.log(formatAccountLine(account));
+		for (const warning of summary.warnings) defaultRuntime.log(theme.warn(`Warning: ${warning}`));
+	});
+}
+function registerWalletCommand(program) {
+	const wallet = program.command("wallet").description("Manage the local encrypted wallet and show public addresses").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, () => showWalletSummary(opts));
+	});
+	wallet.command("init").description("Create a new encrypted local wallet").option("--passphrase-stdin", "Read the wallet passphrase from stdin", false).option("--overwrite", "Replace an existing wallet keystore", false).option("--show-mnemonic", "Print the generated mnemonic once in human-readable output", false).option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			if (opts.json && opts.showMnemonic) throw new Error("--show-mnemonic cannot be combined with --json.");
+			const passphrase = await readPassphrase(opts);
+			const mnemonic = opts.showMnemonic ? generateWalletMnemonic() : void 0;
+			const result = await initWallet({
+				passphrase,
+				mnemonic,
+				overwrite: Boolean(opts.overwrite),
+				chains: LOCAL_KEYSTORE_WALLET_CHAINS
+			});
+			writeMaybeJson(opts, result.summary, () => {
+				defaultRuntime.log(theme.success("Wallet initialized."));
+				if (mnemonic) {
+					defaultRuntime.log(theme.warn("Generated mnemonic, shown once:"));
+					defaultRuntime.log(mnemonic);
+				} else if (result.mnemonicGenerated) defaultRuntime.log(theme.warn("A new mnemonic was generated and encrypted locally. For recoverable funds, prefer `genesis wallet import --mnemonic-stdin` with your backed-up mnemonic."));
+				for (const account of result.summary.accounts) defaultRuntime.log(formatAccountLine(account));
+			});
+		});
+	});
+	wallet.command("import").description("Import a BIP39 mnemonic into the encrypted local wallet").requiredOption("--mnemonic-stdin", "Read the mnemonic from stdin").option("--overwrite", "Replace an existing wallet keystore", false).option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const result = await importWallet({
+				passphrase: await readPassphrase({}),
+				mnemonic: await readStdin(),
+				overwrite: Boolean(opts.overwrite),
+				chains: LOCAL_KEYSTORE_WALLET_CHAINS
+			});
+			writeMaybeJson(opts, result.summary, () => {
+				defaultRuntime.log(theme.success("Wallet imported."));
+				for (const account of result.summary.accounts) defaultRuntime.log(formatAccountLine(account));
+			});
+		});
+	});
+	wallet.command("list").description("List public wallet accounts").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const accounts = await getWalletAccounts();
+			writeMaybeJson(opts, { accounts }, () => {
+				for (const account of accounts) defaultRuntime.log(formatAccountLine(account));
+			});
+		});
+	});
+	wallet.command("address").description("Show public wallet addresses").option("--chain <chain>", `Filter by chain (${WALLET_CHAINS.join("|")})`).option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const chain = opts.chain ? parseChain(opts.chain) : null;
+			const accounts = (await getWalletAccounts()).filter((account) => chain ? account.chain === chain : true);
+			writeMaybeJson(opts, { accounts }, () => {
+				for (const account of accounts) defaultRuntime.log(formatAccountLine(account));
+			});
+		});
+	});
+	wallet.command("balance").description("Fetch a wallet balance").requiredOption("--chain <chain>", `Chain (${WALLET_CHAINS.join("|")})`).option("--account <id>", "Wallet account id").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const balance = await getWalletBalanceForChain({
+				chain: parseChain(opts.chain),
+				accountId: opts.account
+			});
+			writeMaybeJson(opts, balance, () => {
+				defaultRuntime.log(`${balance.chain} ${balance.address}: ${balance.amount} ${balance.asset}`);
+			});
+		});
+	});
+	wallet.command("quote").description("Quote a native wallet transfer").requiredOption("--chain <chain>", `Chain (${WALLET_CHAINS.join("|")})`).requiredOption("--to <address>", "Destination address").requiredOption("--amount <amount>", "Native asset amount").option("--account <id>", "Wallet account id").option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const quote = await quoteWalletTransaction({
+				chain: parseChain(opts.chain),
+				accountId: opts.account,
+				to: opts.to,
+				amount: opts.amount
+			});
+			writeMaybeJson(opts, quote, () => {
+				defaultRuntime.log(`${quote.amount} ${quote.asset}: ${quote.from} -> ${quote.to}`);
+				if (quote.estimatedFee) defaultRuntime.log(`Estimated fee: ${quote.estimatedFee} ${quote.asset}`);
+			});
+		});
+	});
+	wallet.command("send").description("Send a native wallet transfer").requiredOption("--chain <chain>", `Chain (${WALLET_CHAINS.join("|")})`).requiredOption("--to <address>", "Destination address").requiredOption("--amount <amount>", "Native asset amount").option("--account <id>", "Wallet account id").option("--passphrase-stdin", "Read the wallet passphrase from stdin", false).option("--yes", "Confirm and broadcast the transfer", false).option("--json", "Output JSON instead of text", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const passphrase = await readPassphrase(opts);
+			const result = await sendWallet({
+				chain: parseChain(opts.chain),
+				accountId: opts.account,
+				to: opts.to,
+				amount: opts.amount,
+				passphrase,
+				guard: {
+					yes: Boolean(opts.yes),
+					allowEnv: process.env
+				}
+			});
+			writeMaybeJson(opts, result, () => {
+				defaultRuntime.log(theme.success(`Broadcast ${result.chain} transaction ${result.txId}`));
+			});
+		});
+	});
+}
+//#endregion
+export { registerWalletCommand };

package/dist/reply-dispatch-runtime-CNsrlQxq.js

@@ -0,0 +1,13 @@
+import "./chunk-Db6q3o-B.js";
+import "./conversation-label-generator-BZ0jVweA.js";
+//#region src/plugin-sdk/reply-dispatch-runtime.ts
+const dispatchReplyWithBufferedBlockDispatcher = async (params) => {
+	const { dispatchReplyWithBufferedBlockDispatcher: dispatch } = await import("./provider-dispatcher-DMjvnMg1.js");
+	return await dispatch(params);
+};
+const dispatchReplyWithDispatcher = async (params) => {
+	const { dispatchReplyWithDispatcher: dispatch } = await import("./provider-dispatcher-DMjvnMg1.js");
+	return await dispatch(params);
+};
+//#endregion
+export { dispatchReplyWithDispatcher as n, dispatchReplyWithBufferedBlockDispatcher as t };

package/dist/reply-runtime-Cqu1YNSD.js

@@ -0,0 +1,11 @@
+import "./tokens-oGSgdkSq.js";
+import "./heartbeat-D5Ccke4p.js";
+import "./chunk-Db6q3o-B.js";
+import "./dispatch-CswKkiWZ.js";
+import "./inbound-dedupe-CnGzbzgn.js";
+import "./provider-dispatcher-C_R0buEs.js";
+import "./get-reply-7p41dlff.js";
+import "./abort-91r4UulC.js";
+import "./btw-command-C_PoQ81w.js";
+import "./conversation-label-generator-BZ0jVweA.js";
+export {};

package/dist/reply.runtime-DjHQKkER.js

@@ -0,0 +1,2 @@
+import { t as getReplyFromConfig } from "./get-reply-7p41dlff.js";
+export { getReplyFromConfig };

package/dist/reply.runtime.js

@@ -1 +1 @@
-export * from "./reply.runtime-CreZjwrI.js";
+export * from "./reply.runtime-DjHQKkER.js";

package/dist/restart-health-BvQlMuSR.js

@@ -0,0 +1,2 @@
+import { a as renderGatewayPortHealthDiagnostics, c as waitForGatewayHealthyListener, i as inspectGatewayRestart, l as waitForGatewayHealthyRestart, n as DEFAULT_RESTART_HEALTH_DELAY_MS, o as renderRestartDiagnostics, r as DEFAULT_RESTART_HEALTH_TIMEOUT_MS, s as terminateStaleGatewayPids, t as DEFAULT_RESTART_HEALTH_ATTEMPTS } from "./restart-health-Ddm7Ehby.js";
+export { DEFAULT_RESTART_HEALTH_ATTEMPTS, DEFAULT_RESTART_HEALTH_DELAY_MS, DEFAULT_RESTART_HEALTH_TIMEOUT_MS, inspectGatewayRestart, renderGatewayPortHealthDiagnostics, renderRestartDiagnostics, terminateStaleGatewayPids, waitForGatewayHealthyListener, waitForGatewayHealthyRestart };

package/dist/restart-health-Ddm7Ehby.js

@@ -0,0 +1,202 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-C1IzJjqi.js";
+import { v as sleep } from "./utils-DaGfogP-.js";
+import { a as inspectPortUsage, o as classifyPortListener, s as formatPortDiagnostics } from "./ports-BRobddkK.js";
+import { t as killProcessTree } from "./kill-tree-Dpy6bZkg.js";
+import { a as probeGateway } from "./probe-C-OcrhHU.js";
+//#region src/cli/daemon-cli/restart-health.ts
+const DEFAULT_RESTART_HEALTH_TIMEOUT_MS = 6e4;
+const DEFAULT_RESTART_HEALTH_DELAY_MS = 500;
+const DEFAULT_RESTART_HEALTH_ATTEMPTS = Math.ceil(DEFAULT_RESTART_HEALTH_TIMEOUT_MS / 500);
+const STOPPED_FREE_EARLY_EXIT_GRACE_MS = 1e4;
+const WINDOWS_STOPPED_FREE_EARLY_EXIT_GRACE_MS = 9e4;
+function hasListenerAttributionGap(portUsage) {
+	if (portUsage.status !== "busy" || portUsage.listeners.length > 0) return false;
+	if (portUsage.errors?.length) return true;
+	return portUsage.hints.some((hint) => hint.includes("process details are unavailable"));
+}
+function listenerOwnedByRuntimePid(params) {
+	return params.listener.pid === params.runtimePid || params.listener.ppid === params.runtimePid;
+}
+function looksLikeAuthClose(code, reason) {
+	if (code !== 1008) return false;
+	const normalized = normalizeLowercaseStringOrEmpty(reason);
+	return normalized.includes("auth") || normalized.includes("token") || normalized.includes("password") || normalized.includes("scope") || normalized.includes("role");
+}
+async function confirmGatewayReachable(port) {
+	const token = normalizeOptionalString(process.env.GENESIS_GATEWAY_TOKEN);
+	const password = normalizeOptionalString(process.env.GENESIS_GATEWAY_PASSWORD);
+	const probe = await probeGateway({
+		url: `ws://127.0.0.1:${port}`,
+		auth: token || password ? {
+			token,
+			password
+		} : void 0,
+		timeoutMs: 3e3,
+		includeDetails: false
+	});
+	return probe.ok || looksLikeAuthClose(probe.close?.code, probe.close?.reason);
+}
+async function inspectGatewayPortHealth(port) {
+	let portUsage;
+	try {
+		portUsage = await inspectPortUsage(port);
+	} catch (err) {
+		portUsage = {
+			port,
+			status: "unknown",
+			listeners: [],
+			hints: [],
+			errors: [String(err)]
+		};
+	}
+	let healthy = false;
+	if (portUsage.status === "busy") try {
+		healthy = await confirmGatewayReachable(port);
+	} catch {}
+	return {
+		portUsage,
+		healthy
+	};
+}
+async function inspectGatewayRestart(params) {
+	const env = params.env ?? process.env;
+	let runtime = { status: "unknown" };
+	try {
+		runtime = await params.service.readRuntime(env);
+	} catch (err) {
+		runtime = {
+			status: "unknown",
+			detail: String(err)
+		};
+	}
+	let portUsage;
+	try {
+		portUsage = await inspectPortUsage(params.port);
+	} catch (err) {
+		portUsage = {
+			port: params.port,
+			status: "unknown",
+			listeners: [],
+			hints: [],
+			errors: [String(err)]
+		};
+	}
+	if (portUsage.status === "busy" && runtime.status !== "running") try {
+		if (await confirmGatewayReachable(params.port)) return {
+			runtime,
+			portUsage,
+			healthy: true,
+			staleGatewayPids: []
+		};
+	} catch {}
+	const gatewayListeners = portUsage.status === "busy" ? portUsage.listeners.filter((listener) => classifyPortListener(listener, params.port) === "gateway") : [];
+	const fallbackListenerPids = params.includeUnknownListenersAsStale && process.platform === "win32" && runtime.status !== "running" && portUsage.status === "busy" ? portUsage.listeners.filter((listener) => classifyPortListener(listener, params.port) === "unknown").map((listener) => listener.pid).filter((pid) => Number.isFinite(pid)) : [];
+	const running = runtime.status === "running";
+	const runtimePid = runtime.pid;
+	const listenerAttributionGap = hasListenerAttributionGap(portUsage);
+	const ownsPort = runtimePid != null ? portUsage.listeners.some((listener) => listenerOwnedByRuntimePid({
+		listener,
+		runtimePid
+	})) || listenerAttributionGap : gatewayListeners.length > 0 || listenerAttributionGap;
+	let healthy = running && ownsPort;
+	if (!healthy && running && portUsage.status === "busy") try {
+		healthy = await confirmGatewayReachable(params.port);
+	} catch {}
+	const staleGatewayPids = Array.from(new Set([...gatewayListeners.filter((listener) => Number.isFinite(listener.pid)).filter((listener) => {
+		if (!running) return true;
+		if (runtimePid == null) return false;
+		return !listenerOwnedByRuntimePid({
+			listener,
+			runtimePid
+		});
+	}).map((listener) => listener.pid), ...fallbackListenerPids.filter((pid) => runtime.pid == null || pid !== runtime.pid || !running)]));
+	return {
+		runtime,
+		portUsage,
+		healthy,
+		staleGatewayPids
+	};
+}
+function shouldEarlyExitStoppedFree(snapshot, attempt, minAttempt) {
+	return attempt >= minAttempt && snapshot.runtime.status === "stopped" && snapshot.portUsage.status === "free";
+}
+function stoppedFreeEarlyExitGraceMs() {
+	return process.platform === "win32" ? WINDOWS_STOPPED_FREE_EARLY_EXIT_GRACE_MS : STOPPED_FREE_EARLY_EXIT_GRACE_MS;
+}
+function withWaitContext(snapshot, waitOutcome, elapsedMs) {
+	return {
+		...snapshot,
+		waitOutcome,
+		elapsedMs
+	};
+}
+async function waitForGatewayHealthyRestart(params) {
+	const attempts = params.attempts ?? DEFAULT_RESTART_HEALTH_ATTEMPTS;
+	const delayMs = params.delayMs ?? 500;
+	let snapshot = await inspectGatewayRestart({
+		service: params.service,
+		port: params.port,
+		env: params.env,
+		includeUnknownListenersAsStale: params.includeUnknownListenersAsStale
+	});
+	let consecutiveStoppedFreeCount = 0;
+	const STOPPED_FREE_THRESHOLD = 6;
+	const minAttemptForEarlyExit = Math.min(Math.ceil(stoppedFreeEarlyExitGraceMs() / delayMs), Math.floor(attempts / 2));
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		if (snapshot.healthy) return withWaitContext(snapshot, "healthy", attempt * delayMs);
+		if (snapshot.staleGatewayPids.length > 0 && snapshot.runtime.status !== "running") return withWaitContext(snapshot, "stale-pids", attempt * delayMs);
+		if (shouldEarlyExitStoppedFree(snapshot, attempt, minAttemptForEarlyExit)) {
+			consecutiveStoppedFreeCount += 1;
+			if (consecutiveStoppedFreeCount >= STOPPED_FREE_THRESHOLD) return withWaitContext(snapshot, "stopped-free", attempt * delayMs);
+		} else if (snapshot.runtime.status !== "stopped" || snapshot.portUsage.status !== "free") consecutiveStoppedFreeCount = 0;
+		await sleep(delayMs);
+		snapshot = await inspectGatewayRestart({
+			service: params.service,
+			port: params.port,
+			env: params.env,
+			includeUnknownListenersAsStale: params.includeUnknownListenersAsStale
+		});
+	}
+	return withWaitContext(snapshot, "timeout", attempts * delayMs);
+}
+async function waitForGatewayHealthyListener(params) {
+	const attempts = params.attempts ?? DEFAULT_RESTART_HEALTH_ATTEMPTS;
+	const delayMs = params.delayMs ?? 500;
+	let snapshot = await inspectGatewayPortHealth(params.port);
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		if (snapshot.healthy) return snapshot;
+		await sleep(delayMs);
+		snapshot = await inspectGatewayPortHealth(params.port);
+	}
+	return snapshot;
+}
+function renderPortUsageDiagnostics(snapshot) {
+	const lines = [];
+	if (snapshot.portUsage.status === "busy") lines.push(...formatPortDiagnostics(snapshot.portUsage));
+	else lines.push(`Gateway port ${snapshot.portUsage.port} status: ${snapshot.portUsage.status}.`);
+	if (snapshot.portUsage.errors?.length) lines.push(`Port diagnostics errors: ${snapshot.portUsage.errors.join("; ")}`);
+	return lines;
+}
+function renderRestartDiagnostics(snapshot) {
+	const lines = [];
+	const runtimeSummary = [
+		snapshot.runtime.status ? `status=${snapshot.runtime.status}` : null,
+		snapshot.runtime.state ? `state=${snapshot.runtime.state}` : null,
+		snapshot.runtime.pid != null ? `pid=${snapshot.runtime.pid}` : null,
+		snapshot.runtime.lastExitStatus != null ? `lastExit=${snapshot.runtime.lastExitStatus}` : null
+	].filter(Boolean).join(", ");
+	if (runtimeSummary) lines.push(`Service runtime: ${runtimeSummary}`);
+	lines.push(...renderPortUsageDiagnostics(snapshot));
+	return lines;
+}
+function renderGatewayPortHealthDiagnostics(snapshot) {
+	return renderPortUsageDiagnostics(snapshot);
+}
+async function terminateStaleGatewayPids(pids) {
+	const targets = Array.from(new Set(pids.filter((pid) => Number.isFinite(pid) && pid > 0)));
+	for (const pid of targets) killProcessTree(pid, { graceMs: 300 });
+	if (targets.length > 0) await sleep(500);
+	return targets;
+}
+//#endregion
+export { renderGatewayPortHealthDiagnostics as a, waitForGatewayHealthyListener as c, inspectGatewayRestart as i, waitForGatewayHealthyRestart as l, DEFAULT_RESTART_HEALTH_DELAY_MS as n, renderRestartDiagnostics as o, DEFAULT_RESTART_HEALTH_TIMEOUT_MS as r, terminateStaleGatewayPids as s, DEFAULT_RESTART_HEALTH_ATTEMPTS as t };