@ariestools/cli 0.1.19 → 0.1.22

package/dist/node/datalake.mjs

@@ -1,6 +1,14 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { chmodSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { homedir } from "node:os";
+import os, { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import HTTP from "node:http";
+import HTTPS from "node:https";
+import PROCESS from "node:process";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import tty from "node:tty";
 //#region ../datalake-core/dist/browser/browser.mjs
 var DatalakeApiError = class extends Error {
 	code;
@@ -55,18 +63,485 @@ function datalakePlaneClearPath(id) {
 function datalakePlaneUsagePath(id) {
 	return `${datalakePlaneResourcePath(id)}/usage`;
 }
-var DATALAKE_CONTROL_OPERATIONS = [
+var DATALAKE_CONTROL_OPERATIONS$1 = [
 	"datalake:create",
 	"datalake:describe",
 	"datalake:list"
 ];
-var DATALAKE_DATA_OPERATIONS = [
+var DATALAKE_DATA_OPERATIONS$1 = [
 	"payload:append",
 	"payload:read",
 	"usage:read"
 ];
-DATALAKE_CONTROL_OPERATIONS.join(" ");
-DATALAKE_DATA_OPERATIONS.join(" ");
+DATALAKE_CONTROL_OPERATIONS$1.join(" ");
+DATALAKE_DATA_OPERATIONS$1.join(" ");
+//#endregion
+//#region ../../node_modules/.pnpm/@ariestools+sdk@8.3.0_@opentelemetry+api@1.9.1_zod@4.6.1/node_modules/@ariestools/sdk/dist/neutral/fetch.mjs
+var fetchErrorMarker = "$$xylabs-fetch-error";
+var codeTypes = {
+	ENOTFOUND: "dns",
+	EAI_AGAIN: "dns",
+	ECONNREFUSED: "connection-refused",
+	ECONNRESET: "connection-reset",
+	EPIPE: "connection-reset",
+	ETIMEDOUT: "connection-timeout",
+	UND_ERR_CONNECT_TIMEOUT: "connection-timeout",
+	UND_ERR_HEADERS_TIMEOUT: "timeout",
+	UND_ERR_BODY_TIMEOUT: "timeout",
+	EHOSTUNREACH: "unreachable",
+	ENETUNREACH: "unreachable",
+	CERT_HAS_EXPIRED: "tls",
+	DEPTH_ZERO_SELF_SIGNED_CERT: "tls",
+	UNABLE_TO_VERIFY_LEAF_SIGNATURE: "tls",
+	SELF_SIGNED_CERT_IN_CHAIN: "tls",
+	ERR_TLS_CERT_ALTNAME_INVALID: "tls"
+};
+function findErrorCode(error) {
+	let current = error;
+	for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
+		const code = current.code;
+		if (typeof code === "string") return code;
+		current = current.cause;
+	}
+}
+function typeFromCode(code) {
+	if (Object.hasOwn(codeTypes, code)) return codeTypes[code];
+	if (code.startsWith("CERT_") || code.startsWith("ERR_TLS_")) return "tls";
+}
+function classifyFetchError(error) {
+	if (error instanceof Error) {
+		if (error.name === "TimeoutError") return { type: "timeout" };
+		if (error.name === "AbortError") return { type: "aborted" };
+	}
+	const code = findErrorCode(error);
+	if (code !== void 0) {
+		const type = typeFromCode(code);
+		if (type !== void 0) return {
+			type,
+			code
+		};
+		return {
+			type: "unknown",
+			code
+		};
+	}
+	if (error instanceof TypeError && /fetch failed|failed to fetch|network/i.test(error.message)) return { type: "network" };
+	return { type: "unknown" };
+}
+var FetchError = class extends Error {
+	/** Cross-realm marker consumed by {@link isFetchError}. */
+	__fetchErrorMarker = fetchErrorMarker;
+	/** Raw unparseable body text for `parse` failures. */
+	body;
+	/** Node, undici, or TLS system error code when available. */
+	code;
+	/** HTTP method associated with the failed request. */
+	method;
+	/** Parsed response for rejected HTTP-status requests. */
+	response;
+	/** HTTP status when a response was received. */
+	status;
+	/** HTTP reason phrase when a response was received. */
+	statusText;
+	/** Classified reason for the fetch failure. */
+	type;
+	/** Request URL associated with the failure. */
+	url;
+	/** Creates a structured fetch error from a message and request context. */
+	constructor(message, context = {}) {
+		super(message, { cause: context.cause });
+		this.name = "FetchError";
+		this.type = context.type ?? "unknown";
+		this.code = context.code;
+		this.url = context.url;
+		this.method = context.method;
+		this.status = context.status;
+		this.statusText = context.statusText;
+		this.response = context.response;
+		this.body = context.body;
+	}
+	/** Returns a circular-reference-free representation for logs and telemetry. */
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			type: this.type,
+			code: this.code,
+			url: this.url,
+			method: this.method,
+			status: this.status,
+			statusText: this.statusText
+		};
+	}
+};
+function isFetchError(value) {
+	return value instanceof FetchError || typeof value === "object" && value !== null && value.__fetchErrorMarker === fetchErrorMarker;
+}
+function toFetchError(error, context = {}) {
+	if (isFetchError(error)) return error;
+	const { type, code } = classifyFetchError(error);
+	return new FetchError(error instanceof Error ? error.message : String(error), {
+		...context,
+		type,
+		code,
+		cause: error
+	});
+}
+function fetchDefault(input, init) {
+	return globalThis.fetch(input, init);
+}
+async function gzipString(body) {
+	const stream = new Blob([body]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Response(stream).arrayBuffer();
+}
+async function fetchCompress(url, options = {}) {
+	const { compressMinLength = 1024, fetcher = fetchDefault, ...init } = options;
+	try {
+		if (init.body !== void 0 && init.body !== null) {
+			const bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
+			if (bodyStr.length > compressMinLength) {
+				const headers = new Headers(init.headers);
+				headers.set("Content-Encoding", "gzip");
+				return await fetcher(url, {
+					...init,
+					body: await gzipString(bodyStr),
+					headers
+				});
+			}
+		}
+		return await fetcher(url, init);
+	} catch (error) {
+		throw toFetchError(error, {
+			url: url.toString(),
+			method: init.method
+		});
+	}
+}
+function validateMaxResponseBytes(maxResponseBytes) {
+	if (maxResponseBytes !== void 0 && (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes <= 0)) throw new RangeError("maxResponseBytes must be a positive safe integer");
+}
+function abortError(signal) {
+	const reason = signal.reason;
+	let isTimeout = false;
+	try {
+		isTimeout = typeof reason === "object" && reason !== null && "name" in reason && reason.name === "TimeoutError" || classifyFetchError(reason).type === "timeout";
+	} catch {}
+	return new FetchError("Response body read was aborted", {
+		type: isTimeout ? "timeout" : "aborted",
+		cause: reason
+	});
+}
+function readChunk(reader, signal) {
+	if (signal == null) return reader.read();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (outcome) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			if ("error" in outcome) reject(toFetchError(outcome.error));
+			else resolve(outcome.value);
+		};
+		const onAbort = () => finish({ error: abortError(signal) });
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		try {
+			reader.read().then((value) => signal.aborted ? onAbort() : finish({ value })).catch((error) => finish({ error }));
+		} catch (error) {
+			finish({ error });
+		}
+	});
+}
+function cancelReader(reader, reason) {
+	try {
+		reader.cancel(reason).catch(() => {});
+	} catch {}
+}
+async function readStreamText(reader, maxResponseBytes, signal, response) {
+	const decoder = new TextDecoder();
+	const parts = [];
+	let bytes = 0;
+	let completed = false;
+	let failure;
+	try {
+		while (true) {
+			const result = await readChunk(reader, signal);
+			if (signal?.aborted === true) throw abortError(signal);
+			if (result.done) {
+				parts.push(decoder.decode());
+				completed = true;
+				return parts.join("");
+			}
+			const chunk = result.value;
+			if (!ArrayBuffer.isView(chunk) || Object.prototype.toString.call(chunk) !== "[object Uint8Array]") throw new TypeError("Response body chunks must be Uint8Array values");
+			if (maxResponseBytes !== void 0) {
+				if (chunk.byteLength > maxResponseBytes - bytes) throw new FetchError("Response body exceeds maxResponseBytes", {
+					type: "response-too-large",
+					status: response.status,
+					statusText: response.statusText
+				});
+				bytes += chunk.byteLength;
+			}
+			const text = decoder.decode(chunk, { stream: true });
+			if (text !== "") parts.push(text);
+		}
+	} catch (error) {
+		failure = error;
+		throw error;
+	} finally {
+		if (!completed) cancelReader(reader, failure);
+		reader.releaseLock();
+	}
+}
+async function readResponseText(response, options = {}) {
+	const { maxResponseBytes, signal } = options;
+	validateMaxResponseBytes(maxResponseBytes);
+	if (maxResponseBytes === void 0 && signal == null) return await response.text();
+	if (response.bodyUsed) throw new TypeError("Response body has already been consumed");
+	const body = response.body;
+	if (body === null) {
+		if (signal?.aborted === true) throw abortError(signal);
+		return "";
+	}
+	return await readStreamText(body.getReader(), maxResponseBytes, signal, response);
+}
+function contextualizeReadError(error, context, options) {
+	const failure = toFetchError(error, context);
+	if (options.maxResponseBytes === void 0 && options.signal == null) return failure;
+	if ((failure.url !== void 0 || context.url === void 0) && (failure.method !== void 0 || context.method === void 0)) return failure;
+	return new FetchError(failure.message, {
+		body: failure.body,
+		cause: failure.cause,
+		code: failure.code,
+		method: failure.method ?? context.method,
+		response: failure.response,
+		status: failure.status,
+		statusText: failure.statusText,
+		type: failure.type,
+		url: failure.url ?? context.url
+	});
+}
+async function parseJsonResponse(response, context = {}, options = {}) {
+	let text;
+	try {
+		text = await readResponseText(response, options);
+	} catch (error) {
+		throw contextualizeReadError(error, context, options);
+	}
+	if (text.trim() === "") return null;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new FetchError("Failed to parse response body as JSON", {
+			type: "parse",
+			url: context.url,
+			method: context.method,
+			status: response.status,
+			statusText: response.statusText,
+			body: text,
+			cause: error
+		});
+	}
+}
+async function tryParseJson(response, options = {}, context = {}) {
+	let text;
+	try {
+		text = await readResponseText(response, options);
+	} catch (error) {
+		if (options.maxResponseBytes !== void 0 || options.signal != null) throw contextualizeReadError(error, context, options);
+		return null;
+	}
+	try {
+		return text.trim() === "" ? null : JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+function noop() {}
+function requestSignal(signal, timeout) {
+	if (timeout === void 0 || timeout === 0) return {
+		signal,
+		close: noop
+	};
+	const timeoutSignal = AbortSignal.timeout(timeout);
+	if (signal == null) return {
+		signal: timeoutSignal,
+		close: noop
+	};
+	const controller = new AbortController();
+	const close = () => {
+		signal.removeEventListener("abort", onCallerAbort);
+		timeoutSignal.removeEventListener("abort", onTimeout);
+	};
+	const abort = (source) => {
+		if (!controller.signal.aborted) controller.abort(source.reason);
+		close();
+	};
+	const onCallerAbort = () => abort(signal);
+	const onTimeout = () => abort(timeoutSignal);
+	signal.addEventListener("abort", onCallerAbort, { once: true });
+	timeoutSignal.addEventListener("abort", onTimeout, { once: true });
+	if (signal.aborted) onCallerAbort();
+	else if (timeoutSignal.aborted) onTimeout();
+	return {
+		signal: controller.signal,
+		close
+	};
+}
+var FetchClientError = class extends FetchError {
+	/** Effective request configuration, including the resolved request URL. */
+	config;
+	/** Creates an HTTP-status error with its response and request configuration. */
+	constructor(message, response, config) {
+		super(message, {
+			type: "http-status",
+			url: config.url,
+			method: config.method,
+			status: response.status,
+			statusText: response.statusText,
+			response
+		});
+		this.name = "FetchClientError";
+		this.config = config;
+	}
+};
+function buildHeaders(custom, includeContentType = false) {
+	const headers = new Headers();
+	headers.set("Accept", "application/json, text/plain, *.*");
+	if (includeContentType) headers.set("Content-Type", "application/json");
+	if (custom) {
+		const merged = new Headers(custom);
+		for (const [key, value] of merged.entries()) headers.set(key, value);
+	}
+	return headers;
+}
+function buildURL(config) {
+	const base = config.baseURL ?? "";
+	const path = config.url ?? "";
+	const url = base === "" ? new URL(path) : new URL(path, base);
+	if (config.params) for (const [key, value] of Object.entries(config.params)) url.searchParams.set(key, value);
+	return url.href;
+}
+var FetchClient = class _FetchClient {
+	/** Instance defaults shallow-merged beneath every request configuration. */
+	defaults;
+	/** Creates a client with reusable request defaults. */
+	constructor(defaults = {}) {
+		this.defaults = defaults;
+	}
+	/** Creates a client with the supplied request defaults. */
+	static create(config) {
+		return new _FetchClient(config);
+	}
+	/** Sends a `DELETE` request and parses its response as JSON. */
+	delete(url, config) {
+		return this.request({
+			...config,
+			url,
+			method: "DELETE"
+		});
+	}
+	/** Sends a `GET` request and parses its response as JSON. */
+	get(url, config) {
+		return this.request({
+			...config,
+			url,
+			method: "GET"
+		});
+	}
+	/** Serializes `data`, sends a `PATCH` request, and parses the JSON response. */
+	patch(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "PATCH"
+		});
+	}
+	/** Serializes `data`, sends a `POST` request, and parses the JSON response. */
+	post(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "POST"
+		});
+	}
+	/** Serializes `data`, sends a `PUT` request, and parses the JSON response. */
+	put(url, data, config) {
+		return this.request({
+			...config,
+			url,
+			data,
+			method: "PUT"
+		});
+	}
+	/**
+	* Resolves and executes a request using native fetch semantics.
+	* @returns Response metadata and parsed JSON, or `null` for an empty body.
+	* @throws {@link FetchClientError} when `validateStatus` rejects the status.
+	* @throws {@link FetchError} for transport or JSON parsing failures.
+	*/
+	async request(config) {
+		const merged = {
+			...this.defaults,
+			...config
+		};
+		const url = buildURL(merged);
+		const { baseURL: _baseURL, data: requestData, headers, maxResponseBytes, method = "GET", params: _params, signal, timeout, url: _url, validateStatus: validateStatusOption, ...requestInit } = merged;
+		validateMaxResponseBytes(maxResponseBytes);
+		const scope = requestSignal(signal, timeout);
+		try {
+			const init = {
+				...requestInit,
+				method,
+				headers: buildHeaders(headers, requestData !== void 0),
+				signal: scope.signal
+			};
+			if (requestData !== void 0) init.body = JSON.stringify(requestData);
+			const response = await fetchCompress(url, init);
+			const readOptions = {
+				maxResponseBytes,
+				signal: scope.signal
+			};
+			const result = {
+				data: response.ok ? await parseJsonResponse(response, {
+					url,
+					method
+				}, readOptions) : await tryParseJson(response, readOptions, {
+					url,
+					method
+				}),
+				headers: response.headers,
+				response,
+				status: response.status,
+				statusText: response.statusText
+			};
+			const validateStatus = validateStatusOption === void 0 ? (s) => s >= 200 && s < 300 : validateStatusOption;
+			if (validateStatus && !validateStatus(response.status)) throw new FetchClientError(`Request failed with status ${response.status} ${response.statusText}`, result, {
+				...merged,
+				method,
+				url
+			});
+			return result;
+		} finally {
+			scope.close();
+		}
+	}
+};
+new class _FetchJsonClient extends FetchClient {
+	/** Creates a JSON client with reusable request and compression defaults. */
+	constructor(config) {
+		super(config);
+	}
+	/** Creates a JSON client with the supplied defaults. */
+	static create(config) {
+		return new _FetchJsonClient(config);
+	}
+}();
 //#endregion
 //#region ../datalake-client/dist/node/index.mjs
 function getAriesHome() {
@@ -199,10 +674,11 @@ var LocalDatalakeClient = class {
 		const store = readStore();
 		const datalake = requireDatalake(store, request.datalakeId);
 		const existing = datalake.acl.findIndex((entry2) => entry2.principal === request.principal);
+		const grantedAtDate = /* @__PURE__ */ new Date();
 		const entry = {
 			principal: request.principal,
 			role: request.role,
-			grantedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			grantedAt: grantedAtDate.toISOString(),
 			grantedBy: LOCAL_OWNER_ID
 		};
 		if (existing === -1) datalake.acl.push(entry);
@@ -217,15 +693,17 @@ var LocalDatalakeClient = class {
 	async mintToken(request) {
 		const datalake = requireDatalake(readStore(), request.datalakeId);
 		const ttl = request.ttlSeconds ?? 3600;
+		const issued = Buffer.from(JSON.stringify({
+			dl: datalake.id,
+			role: request.role,
+			exp: Math.floor(Date.now() / 1e3) + ttl
+		})).toString("base64url");
+		const expiresAtDate = new Date(Date.now() + ttl * 1e3);
 		return {
-			token: `local.${Buffer.from(JSON.stringify({
-				dl: datalake.id,
-				role: request.role,
-				exp: Math.floor(Date.now() / 1e3) + ttl
-			})).toString("base64url")}`,
+			token: `local.${issued}`,
 			datalakeId: datalake.id,
 			role: request.role,
-			expiresAt: new Date(Date.now() + ttl * 1e3).toISOString(),
+			expiresAt: expiresAtDate.toISOString(),
 			url: datalake.url ?? `http://localhost:8080/datalakes/${datalake.name}`
 		};
 	}
@@ -378,6 +856,22 @@ function extractRequestBase(urlWithPossiblePath) {
 		return urlWithPossiblePath.replace(/\/$/, "");
 	}
 }
+function parsePayloadResponse(response, text, method) {
+	const payload = text.length > 0 ? JSON.parse(text) : void 0;
+	if (!response.ok) {
+		const errorBody = isApiErrorBody2(payload) ? payload : {
+			code: "internal",
+			message: "Unexpected " + response.status + " response from " + method + " data plane"
+		};
+		throw new DatalakeApiError(response.status, errorBody);
+	}
+	return payload;
+}
+function isApiErrorBody2(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
 var RestPayloadsClient = class {
 	authToken;
 	datalakeId;
@@ -458,24 +952,15 @@ var RestPayloadsClient = class {
 			data: void 0,
 			headers: response.headers
 		};
-		const text = await response.text();
-		const payload = text.length > 0 ? JSON.parse(text) : void 0;
-		if (!response.ok) {
-			const errorBody = isApiErrorBody2(payload) ? payload : {
-				code: "internal",
-				message: `Unexpected ${response.status} response from ${method} data plane`
-			};
-			throw new DatalakeApiError(response.status, errorBody);
-		}
 		return {
-			data: payload,
+			data: parsePayloadResponse(response, await response.text(), method),
 			headers: response.headers
 		};
 	}
 };
 function readInsertSummary(headers) {
 	const duplicatesRaw = headers.get(DATALAKE_HEADER_DUPLICATES);
-	const duplicates = duplicatesRaw === null ? 0 : Number.parseInt(duplicatesRaw, 10);
+	const duplicates = duplicatesRaw === null ? 0 : Math.trunc(Number(duplicatesRaw));
 	const rejectedRaw = headers.get(DATALAKE_HEADER_REJECTED);
 	const rejected = rejectedRaw === null || rejectedRaw.length === 0 ? [] : rejectedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
 	return {
@@ -483,10 +968,1007 @@ function readInsertSummary(headers) {
 		rejected
 	};
 }
-function isApiErrorBody2(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const maybe = value;
-	return typeof maybe.code === "string" && typeof maybe.message === "string";
+//#endregion
+//#region ../../node_modules/.pnpm/@ariestools+cli-kit-daemon@1.2.3_@ariestools+actor-model@1.3.0_@ariestools+sdk@8.3.0_@o_8cda624dab9c79c693e4473e20d01110/node_modules/@ariestools/cli-kit-daemon/dist/node/index.mjs
+function isProcessAlive(pid) {
+	try {
+		PROCESS.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+var require2 = createRequire(import.meta.url);
+var HEALTH_POLL_MS = 100;
+var STATUS_PING_TIMEOUT_MS = 1e3;
+var DEFAULT_DOWN_GRACE_MS = 2e3;
+var DOWN_POLL_MS = 50;
+var DEFAULT_LOG_LINES = 50;
+var STATUS_LABEL_WIDTH = 10;
+var DAEMON_STATUS_EXIT_CODES = {
+	/** Running and answering health probes. */
+	healthy: 0,
+	/** No live process for the recorded pid, or no state at all. */
+	notRunning: 3,
+	/** Process is alive but not answering health probes. */
+	unresponsive: 2
+};
+var IDENTITY = (text) => text;
+function resolveStyle(style) {
+	return {
+		dim: style?.dim ?? IDENTITY,
+		error: style?.error ?? IDENTITY,
+		info: style?.info ?? IDENTITY,
+		success: style?.success ?? IDENTITY,
+		warn: style?.warn ?? IDENTITY
+	};
+}
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatUptime(startedAt, now) {
+	const started = new Date(startedAt).getTime();
+	if (Number.isNaN(started)) return "";
+	const seconds = Math.max(0, Math.floor((now - started) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function createDaemonKit$1(config) {
+	const displayName = config.displayName;
+	const capitalizedName = displayName.charAt(0).toUpperCase() + displayName.slice(1);
+	const style = resolveStyle(config.style);
+	const io = config.host.io;
+	const paths = {
+		dir: () => path.join(config.homeDir(), config.dirName),
+		logPath: () => path.join(paths.dir(), "server.log"),
+		pidPath: () => path.join(paths.dir(), "pid"),
+		statePath: () => path.join(paths.dir(), "state.json")
+	};
+	function readState() {
+		const filePath = paths.statePath();
+		if (!existsSync(filePath)) return void 0;
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(filePath, "utf8"));
+		} catch {
+			return;
+		}
+		if (config.normalizeState === void 0) return parsed;
+		const normalized = config.normalizeState(parsed);
+		if (normalized === void 0) return void 0;
+		if (JSON.stringify(parsed) !== JSON.stringify(normalized)) writeState(normalized);
+		return normalized;
+	}
+	function writeState(state) {
+		const dir = paths.dir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const statePath = paths.statePath();
+		const temporaryStatePath = `${statePath}.${PROCESS.pid}.tmp`;
+		writeFileSync(temporaryStatePath, JSON.stringify(state, void 0, 2), "utf8");
+		renameSync(temporaryStatePath, statePath);
+		writeFileSync(paths.pidPath(), String(state.pid), "utf8");
+	}
+	function clearState() {
+		for (const filePath of [paths.statePath(), paths.pidPath()]) if (existsSync(filePath)) unlinkSync(filePath);
+	}
+	function resolveServerBin() {
+		const { bin } = config;
+		if (bin.embeddedRelPath !== void 0 && bin.embeddedRelPath.length > 0 && bin.resolveFromUrl !== void 0 && bin.resolveFromUrl.length > 0) {
+			const relativeSegments = bin.embeddedRelPath.split("/");
+			const binDir = path.dirname(fileURLToPath(bin.resolveFromUrl));
+			const embedded = path.join(binDir, ...relativeSegments);
+			if (existsSync(embedded)) return embedded;
+			const searchPaths = bin.searchPaths ?? [];
+			for (const searchPath of searchPaths) {
+				const candidate = path.resolve(binDir, searchPath, ...relativeSegments);
+				if (existsSync(candidate)) return candidate;
+			}
+		}
+		if (bin.packageName !== void 0 && bin.binRelPath !== void 0) try {
+			const packageJsonPath = require2.resolve(`${bin.packageName}/package.json`);
+			const binPath = path.join(path.dirname(packageJsonPath), ...bin.binRelPath.split("/"));
+			if (existsSync(binPath)) return binPath;
+		} catch {}
+		throw new Error(`${capitalizedName} binary not found. ${bin.installHint} (expected an embedded daemon beside the calling bin or a resolvable package bin)`);
+	}
+	function probeUrl(baseUrl) {
+		return `${baseUrl.replace(/\/$/, "")}${config.health?.path ?? ""}`;
+	}
+	async function probeOnce(baseUrl, timeoutMs, tlsCa) {
+		return await new Promise((resolve) => {
+			const url = new URL(probeUrl(baseUrl));
+			const request = (url.protocol === "https:" ? HTTPS : HTTP).get(url, { ca: tlsCa }, (response) => {
+				response.resume();
+				const status2 = response.statusCode ?? 0;
+				resolve(config.health?.anyResponse === true || status2 >= 200 && status2 < 300);
+			});
+			request.on("error", () => resolve(false));
+			if (timeoutMs !== void 0) request.setTimeout(timeoutMs, () => {
+				request.destroy();
+				resolve(false);
+			});
+		});
+	}
+	async function waitForHealth(baseUrl, timeoutMs, tlsCa) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			if (await probeOnce(baseUrl, void 0, tlsCa)) return true;
+			await delay(HEALTH_POLL_MS);
+		}
+		return false;
+	}
+	async function up(buildSpec) {
+		const existing = readState();
+		if (existing && isProcessAlive(existing.pid)) {
+			io.log(style.warn(`${displayName} already running (pid ${existing.pid}) at ${config.baseUrl(existing)}`));
+			return existing;
+		}
+		if (existing) clearState();
+		const spec = await buildSpec();
+		const binPath = resolveServerBin();
+		const dir = paths.dir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const logFd = openSync(paths.logPath(), "a");
+		const child = spawn(PROCESS.execPath, [binPath, ...spec.args ?? []], {
+			detached: true,
+			env: spec.env,
+			stdio: [
+				"ignore",
+				logFd,
+				logFd
+			]
+		});
+		child.unref();
+		if (child.pid === void 0) throw new Error(`Failed to spawn ${displayName} process`);
+		io.log(style.dim(`starting ${displayName} (pid ${child.pid})...`));
+		if (!await waitForHealth(spec.healthUrl, spec.timeoutMs, spec.healthTlsCa)) {
+			try {
+				PROCESS.kill(child.pid, "SIGTERM");
+			} catch {}
+			throw new Error(`${capitalizedName} did not become healthy within ${spec.timeoutMs / 1e3}s. Check logs at ${paths.logPath()}`);
+		}
+		const state = spec.buildState(child.pid);
+		writeState(state);
+		spec.onReady?.(state);
+		return state;
+	}
+	async function down(options = {}) {
+		const state = readState();
+		if (!state) {
+			io.log(style.warn(`${displayName} is not running`));
+			return;
+		}
+		const graceMs = options.gracePeriodMs ?? DEFAULT_DOWN_GRACE_MS;
+		const stopped = state;
+		function cleanup() {
+			config.postDown?.(stopped);
+			clearState();
+		}
+		if (!isProcessAlive(state.pid)) {
+			cleanup();
+			io.log(style.success(`${displayName} pid ${state.pid} was already stopped \u2014 cleaned up state`));
+			return;
+		}
+		try {
+			PROCESS.kill(state.pid, "SIGTERM");
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		const deadline = Date.now() + graceMs;
+		while (Date.now() < deadline && isProcessAlive(state.pid)) await delay(DOWN_POLL_MS);
+		if (isProcessAlive(state.pid)) try {
+			PROCESS.kill(state.pid, "SIGKILL");
+		} catch {}
+		cleanup();
+		io.log(style.success(`${displayName} pid ${state.pid} stopped`));
+	}
+	function printField(label, value) {
+		io.log(`  ${style.dim(`${label}:`.padEnd(STATUS_LABEL_WIDTH))}${value}`);
+	}
+	function statusLabel(isAlive, isHealthy) {
+		if (isAlive && isHealthy) return style.success("running + healthy");
+		if (isAlive) return style.warn("running but unresponsive");
+		return style.error("stale state (process gone)");
+	}
+	async function status() {
+		const state = readState();
+		if (!state) {
+			io.log(style.warn(`${displayName} not running`));
+			return {
+				exitCode: DAEMON_STATUS_EXIT_CODES.notRunning,
+				isAlive: false,
+				isHealthy: false
+			};
+		}
+		const isAlive = isProcessAlive(state.pid);
+		const tlsCa = config.health?.tlsCa?.(state);
+		const isHealthy = isAlive ? await probeOnce(config.baseUrl(state), STATUS_PING_TIMEOUT_MS, tlsCa) : false;
+		const uptime = formatUptime(state.startedAt, Date.now());
+		io.log(style.info(`${displayName} status`));
+		printField("state", statusLabel(isAlive, isHealthy));
+		printField("pid", String(state.pid));
+		const extraFields = config.statusFields?.(state) ?? [];
+		for (const [label, value] of extraFields) printField(label, value);
+		printField("started", `${state.startedAt}${uptime ? ` (${uptime})` : ""}`);
+		printField("log", paths.logPath());
+		let exitCode = DAEMON_STATUS_EXIT_CODES.healthy;
+		if (!isAlive) exitCode = DAEMON_STATUS_EXIT_CODES.notRunning;
+		else if (!isHealthy) exitCode = DAEMON_STATUS_EXIT_CODES.unresponsive;
+		return {
+			exitCode,
+			isAlive,
+			isHealthy,
+			state
+		};
+	}
+	async function logs(options = {}) {
+		const logPath = paths.logPath();
+		if (!existsSync(logPath)) {
+			io.log(style.warn(`no ${displayName} log file yet`));
+			return 0;
+		}
+		if (options.follow === true) {
+			const child = spawn("tail", [
+				"-n",
+				String(options.lines ?? DEFAULT_LOG_LINES),
+				"-f",
+				logPath
+			], { stdio: "inherit" });
+			return await new Promise((resolve) => {
+				child.on("exit", (code) => {
+					resolve(code ?? 0);
+				});
+			});
+		}
+		const tail = readFileSync(logPath, "utf8").split("\n").slice(-(options.lines ?? DEFAULT_LOG_LINES));
+		io.log(tail.join("\n"));
+		return 0;
+	}
+	async function reset() {
+		await down();
+		const dir = paths.dir();
+		if (!existsSync(dir)) {
+			io.log(style.success("nothing to reset"));
+			return;
+		}
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		io.log(style.success(`reset ${dir}`));
+	}
+	return {
+		clearState,
+		down,
+		logs,
+		paths,
+		readState,
+		reset,
+		resolveServerBin,
+		status,
+		up,
+		writeState
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@ariestools+cli-kit-node@1.2.3_@ariestools+actor-model@1.3.0_@ariestools+sdk@8.3.0_@ope_7b18c786a1c8bb7b1298534a22a75fd9/node_modules/@ariestools/cli-kit-node/dist/node/index.mjs
+function resolveEnvironmentValue(key, layers) {
+	for (const layer of layers) {
+		if (!Object.hasOwn(layer, key)) continue;
+		const value = layer[key];
+		if (value !== void 0) return value;
+	}
+}
+function mergeEnvironments(primary, ...fallbacks) {
+	const layers = [primary, ...fallbacks];
+	const keys = /* @__PURE__ */ new Set();
+	for (const layer of layers) for (const key of Object.keys(layer)) keys.add(key);
+	const result = {};
+	for (const key of keys) result[key] = resolveEnvironmentValue(key, layers);
+	return result;
+}
+var nodeProcessIO = {
+	get columns() {
+		return PROCESS.stdout.columns;
+	},
+	get isInteractive() {
+		return PROCESS.stdin.isTTY && PROCESS.stdout.isTTY;
+	},
+	error(...values) {
+		console.error(...values);
+	},
+	log(...values) {
+		console.log(...values);
+	},
+	async question(prompt) {
+		const readline = createInterface({
+			input: PROCESS.stdin,
+			output: PROCESS.stdout
+		});
+		try {
+			return await readline.question(prompt);
+		} finally {
+			readline.close();
+		}
+	},
+	warn(...values) {
+		console.warn(...values);
+	}
+};
+var DEFAULT_INTERRUPT_SIGNALS = ["SIGINT", "SIGTERM"];
+function createNodeProcessHost(options) {
+	const signals = options?.signals ?? DEFAULT_INTERRUPT_SIGNALS;
+	const environmentOverride = options?.environment;
+	const environmentDefaults = options?.environmentDefaults;
+	function resolveEnvironment() {
+		const primary = environmentOverride ?? PROCESS.env;
+		if (environmentDefaults === void 0) return primary;
+		return mergeEnvironments(primary, environmentDefaults);
+	}
+	return {
+		get argv() {
+			return PROCESS.argv;
+		},
+		get environment() {
+			return resolveEnvironment();
+		},
+		exit(code) {
+			PROCESS.exit(code);
+		},
+		get io() {
+			return nodeProcessIO;
+		},
+		get isDevelopment() {
+			return resolveEnvironment().NODE_ENV === "development";
+		},
+		onInterrupt(listener) {
+			const handleInterrupt = () => {
+				listener();
+			};
+			for (const signal of signals) PROCESS.on(signal, handleInterrupt);
+			return () => {
+				for (const signal of signals) PROCESS.off(signal, handleInterrupt);
+			};
+		}
+	};
+}
+var nodeProcessHost = createNodeProcessHost();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, postfix) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + postfix;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const isGotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, isGotCR ? index - 1 : index) + prefix + (isGotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/ansi-styles/index.js
+const ANSI_BACKGROUND_OFFSET = 10;
+const ANSI_UNDERLINE_OFFSET = 20;
+const wrapAnsi16 = (offset = 0) => (code) => `\u{1B}[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\u{1B}[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u{1B}[${38 + offset};2;${red};${green};${blue}m`;
+const wrapUnderlineAnsi = (code) => `\u{1B}[58;5;${code < 90 ? code - 30 : code - 90 + 8}m`;
+const styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		underlineDouble: ["4:2", 24],
+		underlineCurly: ["4:3", 24],
+		underlineDotted: ["4:4", 24],
+		underlineDashed: ["4:5", 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	},
+	underlineColor: {
+		underlineBlack: ["58;5;0", 59],
+		underlineRed: ["58;5;1", 59],
+		underlineGreen: ["58;5;2", 59],
+		underlineYellow: ["58;5;3", 59],
+		underlineBlue: ["58;5;4", 59],
+		underlineMagenta: ["58;5;5", 59],
+		underlineCyan: ["58;5;6", 59],
+		underlineWhite: ["58;5;7", 59],
+		underlineBlackBright: ["58;5;8", 59],
+		underlineGray: ["58;5;8", 59],
+		underlineGrey: ["58;5;8", 59],
+		underlineRedBright: ["58;5;9", 59],
+		underlineGreenBright: ["58;5;10", 59],
+		underlineYellowBright: ["58;5;11", 59],
+		underlineBlueBright: ["58;5;12", 59],
+		underlineMagentaBright: ["58;5;13", 59],
+		underlineCyanBright: ["58;5;14", 59],
+		underlineWhiteBright: ["58;5;15", 59]
+	}
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+Object.keys(styles$1.underlineColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u{1B}[${style[0]}m`,
+				close: `\u{1B}[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(Number.parseInt(style[0], 10), style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.underlineColor.close = "\x1B[59m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	styles$1.underlineColor.ansi = wrapUnderlineAnsi;
+	styles$1.underlineColor.ansi256 = wrapAnsi256(ANSI_UNDERLINE_OFFSET);
+	styles$1.underlineColor.ansi16m = wrapAnsi16m(ANSI_UNDERLINE_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[\da-f]{6}|[\da-f]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+const ansiStyles = assembleStyles();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : PROCESS.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = PROCESS;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function hasNumericForceColor() {
+	return /^\d+$/.test(env.FORCE_COLOR);
+}
+function envForceColor() {
+	if (!("FORCE_COLOR" in env)) return;
+	if (env.FORCE_COLOR === "false") return 0;
+	if (env.FORCE_COLOR === "true" || env.FORCE_COLOR.length === 0) return 1;
+	if (!hasNumericForceColor()) return;
+	return Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if (forceColor !== void 0 && hasNumericForceColor()) return forceColor;
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (PROCESS.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".", 1)[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(?:color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@6.0.0/node_modules/chalk/source/index.js
+const { stdout: stdoutColor, stderr: stderrColor } = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+const GENERATOR = Symbol("GENERATOR");
+const STYLER = Symbol("STYLER");
+const IS_EMPTY = Symbol("IS_EMPTY");
+const LEVEL = Symbol("LEVEL");
+const styles = Object.create(null);
+const assertValidLevel = (level) => {
+	if (!Number.isSafeInteger(level) || level < 0 || level > 3) throw new Error("The `level` should be an integer from 0 to 3");
+};
+const levelDescriptor = {
+	enumerable: true,
+	get() {
+		return this[LEVEL];
+	},
+	set(level) {
+		assertValidLevel(level);
+		this[LEVEL] = level;
+	}
+};
+const applyOptions = (object, options = {}) => {
+	if (options.level !== void 0) assertValidLevel(options.level);
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object[LEVEL] = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+const createModelConverters = (model, type) => {
+	const style = ansiStyles[type];
+	if (model === "rgb") {
+		const ansi = (red, green, blue) => style.ansi(ansiStyles.rgbToAnsi(red, green, blue));
+		const ansi256 = (red, green, blue) => style.ansi256(ansiStyles.rgbToAnsi256(red, green, blue));
+		return [
+			ansi,
+			ansi,
+			ansi256,
+			style.ansi16m
+		];
+	}
+	if (model === "hex") {
+		const ansi = (hex) => style.ansi(ansiStyles.hexToAnsi(hex));
+		const ansi256 = (hex) => style.ansi256(ansiStyles.hexToAnsi256(hex));
+		return [
+			ansi,
+			ansi,
+			ansi256,
+			(hex) => style.ansi16m(...ansiStyles.hexToRgb(hex))
+		];
+	}
+	const ansi = (code) => style.ansi(ansiStyles.ansi256ToAnsi(code));
+	return [
+		ansi,
+		ansi,
+		style.ansi256,
+		style.ansi256
+	];
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	const capitalizedModel = model[0].toUpperCase() + model.slice(1);
+	for (const [styleName, type] of [
+		[model, "color"],
+		["bg" + capitalizedModel, "bgColor"],
+		["underline" + capitalizedModel, "underlineColor"]
+	]) {
+		const { close } = ansiStyles[type];
+		const converters = createModelConverters(model, type);
+		styles[styleName] = { get() {
+			const styleFunction = function(first, second, third) {
+				const open = converters[this.level](first, second, third);
+				return createBuilder(this, createStyler(open, close, this[STYLER]), this[IS_EMPTY]);
+			};
+			Object.defineProperty(this, styleName, { value: styleFunction });
+			return styleFunction;
+		} };
+	}
+}
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => {
+		if (arguments_.length === 1) return applyStyle(builder, "" + arguments_[0]);
+		if (arguments_.length === 2) return applyStyle(builder, arguments_[0] + " " + arguments_[1]);
+		return applyStyle(builder, arguments_.join(" "));
+	};
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self[GENERATOR] ?? self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+const applyStyle = (self, string) => {
+	if (self[GENERATOR][LEVEL] <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, {
+	...styles,
+	level: levelDescriptor
+});
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+//#region ../datalake-core/dist/node/index.mjs
+var DATALAKE_CONTROL_AUDIENCE = "aries-datalake-control";
+var DATALAKE_CONTROL_OPERATIONS = [
+	"datalake:create",
+	"datalake:describe",
+	"datalake:list"
+];
+var DATALAKE_DATA_OPERATIONS = [
+	"payload:append",
+	"payload:read",
+	"usage:read"
+];
+DATALAKE_CONTROL_OPERATIONS.join(" ");
+DATALAKE_DATA_OPERATIONS.join(" ");
+//#endregion
+//#region ../cli-lib/dist/node/datalake.mjs
+var MONOREPO_BIN_SEARCH_PATHS = ["../../../cli/dist/bin", "../../../cli-internal/dist/bin"];
+function createDaemonKit(config) {
+	return createDaemonKit$1({
+		...config,
+		bin: {
+			...config.bin,
+			resolveFromUrl: import.meta.url,
+			searchPaths: MONOREPO_BIN_SEARCH_PATHS
+		},
+		homeDir: () => process.env.ARIES_HOME ?? path.join(homedir(), ".aries"),
+		host: nodeProcessHost,
+		style: {
+			dim: chalk.gray,
+			error: chalk.red,
+			info: chalk.cyan,
+			success: chalk.green,
+			warn: chalk.yellow
+		}
+	});
+}
+function normalizeDevState(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const state = value;
+	if (typeof state.pid !== "number" || !Number.isSafeInteger(state.pid) || state.pid <= 0) return void 0;
+	if (typeof state.startedAt !== "string") return void 0;
+	if (typeof state.controlUrl !== "string" || typeof state.planeUrl !== "string") return void 0;
+	const controlAudience = typeof state.controlAudience === "string" && state.controlAudience.length > 0 ? state.controlAudience : DATALAKE_CONTROL_AUDIENCE;
+	const corsOrigins = Array.isArray(state.corsOrigins) && state.corsOrigins.every((origin) => typeof origin === "string") ? [...new Set(state.corsOrigins)] : [];
+	const persistDir = typeof state.persistDir === "string" && state.persistDir.length > 0 ? state.persistDir : void 0;
+	return {
+		pid: state.pid,
+		startedAt: state.startedAt,
+		controlUrl: state.controlUrl,
+		planeUrl: state.planeUrl,
+		controlAudience,
+		corsOrigins,
+		...persistDir && { persistDir }
+	};
+}
+var devDaemon = createDaemonKit({
+	dirName: "dev",
+	displayName: "dev server",
+	bin: {
+		embeddedRelPath: "daemons/datalake-dev.mjs",
+		packageName: "@ariestools/aries-datalake-plane",
+		binRelPath: "dist/bin/devServer.mjs",
+		installHint: "Rebuild the CLI package so dist/bin/daemons/datalake-dev.mjs is embedded."
+	},
+	normalizeState: normalizeDevState,
+	health: { path: "/v1/health" },
+	baseUrl: (state) => state.controlUrl,
+	statusFields: (state) => [
+		["control", state.controlUrl],
+		["data", state.planeUrl],
+		["audience", state.controlAudience],
+		["cors", state.corsOrigins.join(", ") || "disabled"],
+		["store", state.persistDir ?? "in-memory"]
+	],
+	postDown: (state) => {
+		if (loadCredentials()?.baseUrl === state.controlUrl) clearCredentials();
+	}
+});
+var DEFAULT_TIMEOUT_MS = 1e3;
+async function inspectDatalakeDevServer(options = {}) {
+	const state = devDaemon.readState();
+	if (state === void 0) return {
+		schemaVersion: 1,
+		status: "stopped",
+		exitCode: 3,
+		process: {
+			running: false,
+			pid: null,
+			startedAt: null
+		},
+		endpoints: {
+			control: null,
+			plane: null
+		}
+	};
+	if (!isProcessAlive(state.pid)) return {
+		schemaVersion: 1,
+		status: "stale",
+		exitCode: 3,
+		process: {
+			running: false,
+			pid: state.pid,
+			startedAt: state.startedAt
+		},
+		endpoints: {
+			control: {
+				healthy: false,
+				url: state.controlUrl
+			},
+			plane: {
+				healthy: false,
+				url: state.planeUrl
+			}
+		}
+	};
+	const timeoutMs = normalizeTimeout(options.timeoutMs);
+	const [controlHealthy, planeHealthy] = await Promise.all([probeHealth(state.controlUrl, timeoutMs), probeHealth(state.planeUrl, timeoutMs)]);
+	const status = resolveStatus(controlHealthy, planeHealthy);
+	return {
+		schemaVersion: 1,
+		status,
+		exitCode: status === "healthy" ? 0 : 2,
+		process: {
+			running: true,
+			pid: state.pid,
+			startedAt: state.startedAt
+		},
+		endpoints: {
+			control: {
+				healthy: controlHealthy,
+				url: state.controlUrl
+			},
+			plane: {
+				healthy: planeHealthy,
+				url: state.planeUrl
+			}
+		}
+	};
+}
+function normalizeTimeout(value) {
+	if (value === void 0) return DEFAULT_TIMEOUT_MS;
+	if (!Number.isFinite(value) || value <= 0) throw new Error("timeoutMs must be a positive number");
+	return value;
+}
+async function probeHealth(baseUrl, timeoutMs) {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return (await fetch(`${baseUrl.replace(/\/$/, "")}/v1/health`, { signal: controller.signal })).ok;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+function resolveStatus(controlHealthy, planeHealthy) {
+	if (controlHealthy && planeHealthy) return "healthy";
+	if (controlHealthy || planeHealthy) return "degraded";
+	return "unresponsive";
 }
 //#endregion
-export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, loadCredentials, saveCredentials, setDefaultDatalake };
+export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, inspectDatalakeDevServer, loadCredentials, saveCredentials, setDefaultDatalake };