@pixelzx/genesis 2026.5.5-4 → 2026.5.5-5

package/dist/register.subclis-Dv1wGW3g.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-yolio5T8.js";
+import { i as buildCommandGroupEntries, n as registerSubCliByName$1, o as defineImportedProgramCommandGroupSpecs, r as registerSubCliCommands$1 } from "./register.subclis-core-Bko3H89P.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-q1NXEnfT.js";
+import { n as getSubCliEntries } from "./subcli-descriptors-CBq4zT3w.js";
+//#region src/cli/program/register.subclis.ts
+const entrySpecs = [...defineImportedProgramCommandGroupSpecs([{
+	commandNames: ["completion"],
+	loadModule: () => import("./completion-cli-CpaOR4Y2.js"),
+	exportName: "registerCompletionCli"
+}])];
+function resolveSubCliCommandGroups() {
+	return buildCommandGroupEntries(getSubCliEntries(), entrySpecs, (register) => register);
+}
+async function registerSubCliByName(program, name, options) {
+	if (await registerSubCliByName$1(program, name, options)) 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-DwIbjIAj.js

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

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

@@ -0,0 +1,249 @@
+import { t as resolveCliArgvInvocation } from "./argv-invocation-BIP3nEco.js";
+import { r as shouldRegisterPrimarySubcommandOnly, t as shouldEagerRegisterSubcommands } from "./command-registration-policy-yolio5T8.js";
+import { i as registerCommandGroups, r as registerCommandGroupByName } from "./register-command-groups-q1NXEnfT.js";
+import { n as getSubCliEntries$1, r as loadPrivateQaCliModule } from "./subcli-descriptors-CBq4zT3w.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, options) {
+	if (options.registerPluginCliCommands === false) {
+		await registerSubCli();
+		return;
+	}
+	const { registerPluginCliCommandsFromValidatedConfig } = await import("./cli-ChQYhws1.js");
+	if (pluginCliPosition === "before") await registerPluginCliCommandsFromValidatedConfig(program);
+	await registerSubCli();
+	if (pluginCliPosition === "after") await registerPluginCliCommandsFromValidatedConfig(program);
+}
+function buildEntrySpecs(options = {}) {
+	return [
+		...defineImportedProgramCommandGroupSpecs([
+			{
+				commandNames: ["acp"],
+				loadModule: () => import("./acp-cli-z6OXmifV.js"),
+				exportName: "registerAcpCli"
+			},
+			{
+				commandNames: ["gateway"],
+				loadModule: () => import("./gateway-cli-DiXT82AL.js"),
+				exportName: "registerGatewayCli"
+			},
+			{
+				commandNames: ["daemon"],
+				loadModule: () => import("./cli/daemon-cli.js"),
+				exportName: "registerDaemonCli"
+			},
+			{
+				commandNames: ["logs"],
+				loadModule: () => import("./logs-cli-BosZUQjD.js"),
+				exportName: "registerLogsCli"
+			},
+			{
+				commandNames: ["system"],
+				loadModule: () => import("./system-cli-BDBKF4EX.js"),
+				exportName: "registerSystemCli"
+			},
+			{
+				commandNames: ["models"],
+				loadModule: () => import("./models-cli-yBKYg40-.js"),
+				exportName: "registerModelsCli"
+			},
+			{
+				commandNames: ["infer", "capability"],
+				loadModule: () => import("./capability-cli-OTV_9-o3.js"),
+				exportName: "registerCapabilityCli"
+			},
+			{
+				commandNames: ["approvals"],
+				loadModule: () => import("./exec-approvals-cli-CX0ETYsT.js"),
+				exportName: "registerExecApprovalsCli"
+			},
+			{
+				commandNames: ["exec-policy"],
+				loadModule: () => import("./exec-policy-cli-F3L_mLPh.js"),
+				exportName: "registerExecPolicyCli"
+			},
+			{
+				commandNames: ["nodes"],
+				loadModule: () => import("./nodes-cli-C6i6IIFh.js"),
+				exportName: "registerNodesCli"
+			},
+			{
+				commandNames: ["devices"],
+				loadModule: () => import("./devices-cli-DZZgB4A7.js"),
+				exportName: "registerDevicesCli"
+			},
+			{
+				commandNames: ["node"],
+				loadModule: () => import("./node-cli-B0h1wrXR.js"),
+				exportName: "registerNodeCli"
+			},
+			{
+				commandNames: ["sandbox"],
+				loadModule: () => import("./sandbox-cli-CPs_gL72.js"),
+				exportName: "registerSandboxCli"
+			},
+			{
+				commandNames: [
+					"tui",
+					"terminal",
+					"chat"
+				],
+				loadModule: () => import("./tui-cli-24oh_Prd.js"),
+				exportName: "registerTuiCli"
+			},
+			{
+				commandNames: ["cron"],
+				loadModule: () => import("./cron-cli-5AWYX_JN.js"),
+				exportName: "registerCronCli"
+			},
+			{
+				commandNames: ["dns"],
+				loadModule: () => import("./dns-cli-z20808Yz.js"),
+				exportName: "registerDnsCli"
+			},
+			{
+				commandNames: ["docs"],
+				loadModule: () => import("./docs-cli-D0X5YC2-.js"),
+				exportName: "registerDocsCli"
+			},
+			{
+				commandNames: ["qa"],
+				loadModule: loadPrivateQaCliModule,
+				exportName: "registerQaLabCli"
+			},
+			{
+				commandNames: ["proxy"],
+				loadModule: () => import("./proxy-cli-B5AHii2_.js"),
+				exportName: "registerProxyCli"
+			},
+			{
+				commandNames: ["hooks"],
+				loadModule: () => import("./hooks-cli-DcTAWUQx.js"),
+				exportName: "registerHooksCli"
+			},
+			{
+				commandNames: ["webhooks"],
+				loadModule: () => import("./webhooks-cli-lrEfJsYQ.js"),
+				exportName: "registerWebhooksCli"
+			},
+			{
+				commandNames: ["qr"],
+				loadModule: () => import("./qr-cli-BRKmL1xp.js"),
+				exportName: "registerQrCli"
+			},
+			{
+				commandNames: ["clawbot"],
+				loadModule: () => import("./clawbot-cli-BOy_NgZZ.js"),
+				exportName: "registerClawbotCli"
+			}
+		]),
+		{
+			commandNames: ["pairing"],
+			register: async (program) => {
+				await registerSubCliWithPluginCommands(program, async () => {
+					(await import("./pairing-cli-kZkl_DC7.js")).registerPairingCli(program);
+				}, "before", options);
+			}
+		},
+		{
+			commandNames: ["plugins"],
+			register: async (program) => {
+				await registerSubCliWithPluginCommands(program, async () => {
+					(await import("./plugins-cli-xVUY8V-3.js")).registerPluginsCli(program);
+				}, "after", options);
+			}
+		},
+		...defineImportedProgramCommandGroupSpecs([
+			{
+				commandNames: ["channels"],
+				loadModule: () => import("./channels-cli-I85GHTus.js"),
+				exportName: "registerChannelsCli"
+			},
+			{
+				commandNames: ["directory"],
+				loadModule: () => import("./directory-cli-DNMdDpqd.js"),
+				exportName: "registerDirectoryCli"
+			},
+			{
+				commandNames: ["security"],
+				loadModule: () => import("./security-cli-BiBQQ-88.js"),
+				exportName: "registerSecurityCli"
+			},
+			{
+				commandNames: ["secrets"],
+				loadModule: () => import("./secrets-cli-ukRqmE6x.js"),
+				exportName: "registerSecretsCli"
+			},
+			{
+				commandNames: ["skills"],
+				loadModule: () => import("./skills-cli-DCr7N_Sq.js"),
+				exportName: "registerSkillsCli"
+			},
+			{
+				commandNames: ["update"],
+				loadModule: () => import("./update-cli-YBhNTeZV.js"),
+				exportName: "registerUpdateCli"
+			}
+		])
+	];
+}
+function resolveSubCliCommandGroups(options) {
+	const descriptors = getSubCliEntries$1();
+	const descriptorNames = new Set(descriptors.map((descriptor) => descriptor.name));
+	return buildCommandGroupEntries(descriptors, buildEntrySpecs(options).filter((spec) => spec.commandNames.every((name) => descriptorNames.has(name))), (register) => register);
+}
+function getSubCliEntries() {
+	return getSubCliEntries$1();
+}
+async function registerSubCliByName(program, name, options) {
+	return registerCommandGroupByName(program, resolveSubCliCommandGroups(options), 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/reply-dispatch-runtime-yjhlGmQa.js

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

package/dist/reply-media-paths.runtime-CuKBYqSs.js

@@ -0,0 +1,2 @@
+import { n as createReplyMediaPathNormalizer, t as createReplyMediaContext } from "./reply-media-paths.runtime-kh3iabdJ.js";
+export { createReplyMediaContext, createReplyMediaPathNormalizer };

package/dist/reply-media-paths.runtime-kh3iabdJ.js

@@ -0,0 +1,146 @@
+import { r as logVerbose } from "./globals-C5IxqXPj.js";
+import { p as resolveSessionAgentId } from "./agent-scope-CDjZLqNk.js";
+import { m as resolveSendableOutboundReplyParts } from "./reply-payload-ChFsXpe2.js";
+import { t as isPassThroughRemoteMediaSource } from "./media-source-url-DmLXU187.js";
+import { o as resolveSandboxedMediaSource, r as resolveAllowedManagedMediaPath, t as assertMediaNotDataUrl } from "./sandbox-paths-qD2i6WjF.js";
+import { d as toRelativeWorkspacePath, l as resolvePathFromInput, t as resolveAgentScopedOutboundMediaAccess } from "./read-capability-7xOdYqOo.js";
+import { t as resolveChannelAccountMediaMaxMb } from "./configured-max-bytes-QLaG-zSy.js";
+import { t as MEDIA_MAX_BYTES } from "./store-Fge4lGwN.js";
+import { a as ensureSandboxWorkspaceForSession } from "./sandbox-DAnx9TYc.js";
+import { t as resolveOutboundAttachmentFromUrl } from "./outbound-attachment-CTpQ1O5C.js";
+import path from "node:path";
+//#region src/auto-reply/reply/reply-media-paths.ts
+const FILE_URL_RE = /^file:\/\//i;
+const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
+const SCHEME_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+const HAS_FILE_EXT_RE = /\.\w{1,10}$/;
+function isLikelyLocalMediaSource(media) {
+	return FILE_URL_RE.test(media) || media.startsWith("/") || media.startsWith("./") || media.startsWith("../") || media.startsWith("~") || WINDOWS_DRIVE_RE.test(media) || media.startsWith("\\\\") || !SCHEME_RE.test(media) && (media.includes("/") || media.includes("\\") || HAS_FILE_EXT_RE.test(media));
+}
+function getPayloadMediaList(payload) {
+	return resolveSendableOutboundReplyParts(payload).mediaUrls;
+}
+function resolveReplyMediaMaxBytes(params) {
+	const limitMb = resolveChannelAccountMediaMaxMb(params) ?? params.cfg.agents?.defaults?.mediaMaxMb;
+	return typeof limitMb === "number" && Number.isFinite(limitMb) && limitMb > 0 ? Math.floor(limitMb * 1024 * 1024) : MEDIA_MAX_BYTES;
+}
+function formatBlockedReplyMediaWarning() {
+	return "⚠️ Media failed.";
+}
+function createReplyMediaPathNormalizer(params) {
+	const agentId = params.agentId ?? (params.sessionKey ? resolveSessionAgentId({
+		sessionKey: params.sessionKey,
+		config: params.cfg
+	}) : void 0);
+	const maxBytes = resolveReplyMediaMaxBytes({
+		cfg: params.cfg,
+		channel: params.messageProvider,
+		accountId: params.accountId
+	});
+	let sandboxRootPromise;
+	const persistedMediaBySource = /* @__PURE__ */ new Map();
+	const resolveSandboxRoot = async () => {
+		if (!sandboxRootPromise) sandboxRootPromise = ensureSandboxWorkspaceForSession({
+			config: params.cfg,
+			sessionKey: params.sessionKey,
+			workspaceDir: params.workspaceDir
+		}).then((sandbox) => sandbox?.workspaceDir);
+		return await sandboxRootPromise;
+	};
+	const resolveMediaAccessForSource = (media) => resolveAgentScopedOutboundMediaAccess({
+		cfg: params.cfg,
+		agentId,
+		workspaceDir: params.workspaceDir,
+		mediaSources: [media],
+		sessionKey: params.sessionKey,
+		messageProvider: params.sessionKey ? void 0 : params.messageProvider,
+		accountId: params.accountId,
+		requesterSenderId: params.requesterSenderId,
+		requesterSenderName: params.requesterSenderName,
+		requesterSenderUsername: params.requesterSenderUsername,
+		requesterSenderE164: params.requesterSenderE164,
+		groupId: params.groupId,
+		groupChannel: params.groupChannel,
+		groupSpace: params.groupSpace
+	});
+	const persistLocalReplyMedia = async (media) => {
+		if (!isLikelyLocalMediaSource(media)) return media;
+		const managedMediaPath = await resolveAllowedManagedMediaPath(media);
+		if (managedMediaPath) return managedMediaPath;
+		const cached = persistedMediaBySource.get(media);
+		if (cached) return await cached;
+		const persistPromise = resolveOutboundAttachmentFromUrl(media, maxBytes, { mediaAccess: resolveMediaAccessForSource(media) }).then((saved) => saved.path).catch((err) => {
+			persistedMediaBySource.delete(media);
+			throw err;
+		});
+		persistedMediaBySource.set(media, persistPromise);
+		return await persistPromise;
+	};
+	const resolveWorkspaceRelativeMedia = (media) => {
+		return resolvePathFromInput(toRelativeWorkspacePath(params.workspaceDir, media, { cwd: params.workspaceDir }), params.workspaceDir);
+	};
+	const normalizeMediaSource = async (raw) => {
+		const media = raw.trim();
+		if (!media) return media;
+		assertMediaNotDataUrl(media);
+		if (isPassThroughRemoteMediaSource(media)) return media;
+		const isRelativeLocalMedia = isLikelyLocalMediaSource(media) && !FILE_URL_RE.test(media) && !media.startsWith("~") && !path.isAbsolute(media) && !WINDOWS_DRIVE_RE.test(media);
+		const sandboxRoot = await resolveSandboxRoot();
+		if (sandboxRoot) {
+			let sandboxResolvedMedia;
+			try {
+				sandboxResolvedMedia = await resolveSandboxedMediaSource({
+					media,
+					sandboxRoot
+				});
+			} catch (err) {
+				if (FILE_URL_RE.test(media)) throw new Error("Host-local MEDIA file URLs are blocked in normal replies. Use a safe path or the message tool.", { cause: err });
+				throw err;
+			}
+			return await persistLocalReplyMedia(sandboxResolvedMedia);
+		}
+		if (isRelativeLocalMedia) return await persistLocalReplyMedia(resolveWorkspaceRelativeMedia(media));
+		if (!isLikelyLocalMediaSource(media)) return media;
+		if (FILE_URL_RE.test(media)) throw new Error("Host-local MEDIA file URLs are blocked in normal replies. Use a safe path or the message tool.");
+		return await persistLocalReplyMedia(media);
+	};
+	return async (payload) => {
+		const mediaList = getPayloadMediaList(payload);
+		if (mediaList.length === 0) return payload;
+		const normalizedMedia = [];
+		const seen = /* @__PURE__ */ new Set();
+		let firstMediaDropError;
+		for (const media of mediaList) {
+			let normalized;
+			try {
+				normalized = await normalizeMediaSource(media);
+			} catch (err) {
+				firstMediaDropError ??= err;
+				logVerbose(`dropping blocked reply media ${media}: ${String(err)}`);
+				continue;
+			}
+			if (!normalized || seen.has(normalized)) continue;
+			seen.add(normalized);
+			normalizedMedia.push(normalized);
+		}
+		if (normalizedMedia.length === 0) {
+			const warning = firstMediaDropError ? formatBlockedReplyMediaWarning() : void 0;
+			return {
+				...payload,
+				text: warning ? payload.text ? `${payload.text}\n${warning}` : warning : payload.text,
+				mediaUrl: void 0,
+				mediaUrls: void 0
+			};
+		}
+		return {
+			...payload,
+			mediaUrl: normalizedMedia[0],
+			mediaUrls: normalizedMedia
+		};
+	};
+}
+function createReplyMediaContext(params) {
+	return { normalizePayload: createReplyMediaPathNormalizer(params) };
+}
+//#endregion
+export { createReplyMediaPathNormalizer as n, createReplyMediaContext as t };

package/dist/reply-media-paths.runtime.js

@@ -1 +1 @@
-export * from "./reply-media-paths.runtime-DCj1JhDR.js";
+export * from "./reply-media-paths.runtime-kh3iabdJ.js";

package/dist/reply-runtime-POkwAYBF.js

@@ -0,0 +1,11 @@
+import "./tokens-Bq9TB3gs.js";
+import "./heartbeat-DFFJQW7H.js";
+import "./chunk-CMvONy3a.js";
+import "./dispatch-CRDSpd0f.js";
+import "./inbound-dedupe-CGuVucqF.js";
+import "./provider-dispatcher-RVQ5ny3p.js";
+import "./get-reply-DZ2b8RH0.js";
+import "./abort-Eo7XsA03.js";
+import "./btw-command-DGuvquyH.js";
+import "./conversation-label-generator-CNvvC18B.js";
+export {};

package/dist/reply.runtime-BZy3p8kg.js

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

package/dist/reply.runtime.js

@@ -1 +1 @@
-export * from "./reply.runtime-B990ty9C.js";
+export * from "./reply.runtime-BZy3p8kg.js";

package/dist/restart-health-BNrBfydi.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-A3zmoqnI.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 };

package/dist/restart-health-wL13AbJS.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-BNrBfydi.js";
+export { DEFAULT_RESTART_HEALTH_ATTEMPTS, DEFAULT_RESTART_HEALTH_DELAY_MS, DEFAULT_RESTART_HEALTH_TIMEOUT_MS, inspectGatewayRestart, renderGatewayPortHealthDiagnostics, renderRestartDiagnostics, terminateStaleGatewayPids, waitForGatewayHealthyListener, waitForGatewayHealthyRestart };