lmnr-cli 0.1.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1971 @@
+#!/usr/bin/env node
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let commander = require("commander");
+let path = require("path");
+path = __toESM(path);
+let pino = require("pino");
+pino = __toESM(pino);
+let pino_pretty = require("pino-pretty");
+let uuid = require("uuid");
+let chokidar = require("chokidar");
+chokidar = __toESM(chokidar);
+let http = require("http");
+http = __toESM(http);
+let events = require("events");
+let eventsource_parser = require("eventsource-parser");
+let child_process = require("child_process");
+let readline = require("readline");
+readline = __toESM(readline);
+
+//#region package.json
+var version$1 = "0.1.0-alpha.0";
+
+//#endregion
+//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/dotenv@17.2.3/node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = require("fs");
+	const path$1 = require("path");
+	const os = require("os");
+	const crypto$1 = require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options) {
+		options = options || {};
+		const vaultPath = _vaultPath(options);
+		options.path = vaultPath;
+		const result = DotenvModule.configDotenv(options);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const attrs = _instructions(result, keys[i].trim());
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options) {
+		if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) return options.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options) {
+		let possibleVaultPath = null;
+		if (options && options.path && options.path.length > 0) if (Array.isArray(options.path)) {
+			for (const filepath of options.path) if (fs.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+		else possibleVaultPath = path$1.resolve(process.cwd(), ".env.vault");
+		if (fs.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$1.join(os.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options) {
+		const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (debug || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options);
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		DotenvModule.populate(processEnv, parsed, options);
+		return { parsed };
+	}
+	function configDotenv(options) {
+		const dotenvPath = path$1.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options && options.processEnv != null) processEnv = options.processEnv;
+		let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+		if (options && options.encoding) encoding = options.encoding;
+		else if (debug) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options && options.path) if (!Array.isArray(options.path)) optionPaths = [_resolveHome(options.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path$2 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs.readFileSync(path$2, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options);
+		} catch (e) {
+			if (debug) _debug(`Failed to load ${path$2} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options);
+		debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$1.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options) {
+		if (_dotenvKey(options).length === 0) return DotenvModule.configDotenv(options);
+		const vaultPath = _vaultPath(options);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options);
+		}
+		return DotenvModule._configVault(options);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto$1.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options = {}) {
+		const debug = Boolean(options && options.debug);
+		const override = Boolean(options && options.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}));
+
+//#endregion
+//#region ../client/dist/index.mjs
+var import_main = require_main();
+var version = "0.8.2";
+function getLangVersion() {
+	if (typeof process !== "undefined" && process.versions && process.versions.node) return `node-${process.versions.node}`;
+	if (typeof navigator !== "undefined" && navigator.userAgent) return `browser-${navigator.userAgent}`;
+	return null;
+}
+var BaseResource = class {
+	constructor(baseHttpUrl, projectApiKey) {
+		this.baseHttpUrl = baseHttpUrl;
+		this.projectApiKey = projectApiKey;
+	}
+	headers() {
+		return {
+			Authorization: `Bearer ${this.projectApiKey}`,
+			"Content-Type": "application/json",
+			Accept: "application/json"
+		};
+	}
+	async handleError(response) {
+		const errorMsg = await response.text();
+		throw new Error(`${response.status} ${errorMsg}`);
+	}
+};
+var BrowserEventsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	async send({ sessionId, traceId, events: events$1 }) {
+		const payload = {
+			sessionId,
+			traceId,
+			events: events$1,
+			source: getLangVersion() ?? "javascript",
+			sdkVersion: version
+		};
+		const jsonString = JSON.stringify(payload);
+		const compressedStream = new Blob([jsonString], { type: "application/json" }).stream().pipeThrough(new CompressionStream("gzip"));
+		const compressedData = await new Response(compressedStream).arrayBuffer();
+		const response = await fetch(this.baseHttpUrl + "/v1/browser-sessions/events", {
+			method: "POST",
+			headers: {
+				...this.headers(),
+				"Content-Encoding": "gzip"
+			},
+			body: compressedData
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+function initializeLogger$1(options) {
+	const colorize = options?.colorize ?? true;
+	const level = options?.level ?? process.env.LMNR_LOG_LEVEL?.toLowerCase()?.trim() ?? "info";
+	return (0, pino.default)({ level }, (0, pino_pretty.PinoPretty)({
+		colorize,
+		minimumLevel: level
+	}));
+}
+const logger$2 = initializeLogger$1();
+const isStringUUID = (id) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id);
+const newUUID$1 = () => {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	else return (0, uuid.v4)();
+};
+const otelSpanIdToUUID = (spanId) => {
+	let id = spanId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	if (id.length !== 16) logger$2.warn(`Span ID ${spanId} is not 16 hex chars long. This is not a valid OpenTelemetry span ID.`);
+	if (!/^[0-9a-f]+$/.test(id)) {
+		logger$2.error(`Span ID ${spanId} is not a valid hex string. Generating a random UUID instead.`);
+		return newUUID$1();
+	}
+	return id.padStart(32, "0").replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+};
+const otelTraceIdToUUID = (traceId) => {
+	let id = traceId.toLowerCase();
+	if (id.startsWith("0x")) id = id.slice(2);
+	if (id.length !== 32) logger$2.warn(`Trace ID ${traceId} is not 32 hex chars long. This is not a valid OpenTelemetry trace ID.`);
+	if (!/^[0-9a-f]+$/.test(id)) {
+		logger$2.error(`Trace ID ${traceId} is not a valid hex string. Generating a random UUID instead.`);
+		return newUUID$1();
+	}
+	return id.replace(/^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/, "$1-$2-$3-$4-$5");
+};
+const slicePayload = (value, length) => {
+	if (value === null || value === void 0) return value;
+	const str = JSON.stringify(value);
+	if (str.length <= length) return value;
+	return str.slice(0, length) + "...";
+};
+const loadEnv = (options) => {
+	const nodeEnv = process.env.NODE_ENV || "development";
+	const envDir = process.cwd();
+	const envFiles = [
+		".env",
+		".env.local",
+		`.env.${nodeEnv}`,
+		`.env.${nodeEnv}.local`
+	];
+	const logLevel = process.env.LMNR_LOG_LEVEL ?? "info";
+	const verbose = ["debug", "trace"].includes(logLevel.trim().toLowerCase());
+	const quiet = options?.quiet ?? !verbose;
+	(0, import_main.config)({
+		path: options?.paths ?? envFiles.map((envFile) => path.resolve(envDir, envFile)),
+		quiet
+	});
+};
+const logger$1$1 = initializeLogger$1();
+const DEFAULT_DATASET_PULL_LIMIT = 100;
+const DEFAULT_DATASET_PUSH_BATCH_SIZE = 100;
+var DatasetsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* List all datasets.
+	*
+	* @returns {Promise<Dataset[]>} Array of datasets
+	*/
+	async listDatasets() {
+		const response = await fetch(this.baseHttpUrl + "/v1/datasets", {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Get a dataset by name.
+	*
+	* @param {string} name - Name of the dataset
+	* @returns {Promise<Dataset[]>} Array of datasets with matching name
+	*/
+	async getDatasetByName(name) {
+		const params = new URLSearchParams({ name });
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Push datapoints to a dataset.
+	*
+	* @param {Object} options - Push options
+	* @param {Datapoint<D, T>[]} options.points - Datapoints to push
+	* @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+	* @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+	* @param {number} [options.batchSize] - Batch size for pushing (default: 100)
+	* @param {boolean} [options.createDataset] - Whether to create the dataset if it doesn't exist
+	* @returns {Promise<PushDatapointsResponse | undefined>}
+	*/
+	async push({ points, name, id, batchSize = DEFAULT_DATASET_PUSH_BATCH_SIZE, createDataset = false }) {
+		if (!name && !id) throw new Error("Either name or id must be provided");
+		if (name && id) throw new Error("Only one of name or id must be provided");
+		if (createDataset && !name) throw new Error("Name must be provided when creating a new dataset");
+		const identifier = name ? { name } : { datasetId: id };
+		const totalBatches = Math.ceil(points.length / batchSize);
+		let response;
+		for (let i = 0; i < points.length; i += batchSize) {
+			const batchNum = Math.floor(i / batchSize) + 1;
+			logger$1$1.debug(`Pushing batch ${batchNum} of ${totalBatches}`);
+			const batch = points.slice(i, i + batchSize);
+			const fetchResponse = await fetch(this.baseHttpUrl + "/v1/datasets/datapoints", {
+				method: "POST",
+				headers: this.headers(),
+				body: JSON.stringify({
+					...identifier,
+					datapoints: batch.map((point) => ({
+						data: point.data,
+						target: point.target ?? {},
+						metadata: point.metadata ?? {}
+					})),
+					createDataset
+				})
+			});
+			if (fetchResponse.status !== 200 && fetchResponse.status !== 201) await this.handleError(fetchResponse);
+			response = await fetchResponse.json();
+		}
+		return response;
+	}
+	/**
+	* Pull datapoints from a dataset.
+	*
+	* @param {Object} options - Pull options
+	* @param {string} [options.name] - Name of the dataset (either name or id must be provided)
+	* @param {StringUUID} [options.id] - ID of the dataset (either name or id must be provided)
+	* @param {number} [options.limit] - Maximum number of datapoints to return (default: 100)
+	* @param {number} [options.offset] - Offset for pagination (default: 0)
+	* @returns {Promise<GetDatapointsResponse<D, T>>}
+	*/
+	async pull({ name, id, limit = DEFAULT_DATASET_PULL_LIMIT, offset = 0 }) {
+		if (!name && !id) throw new Error("Either name or id must be provided");
+		if (name && id) throw new Error("Only one of name or id must be provided");
+		const paramsObj = {
+			offset: offset.toString(),
+			limit: limit.toString()
+		};
+		if (name) paramsObj.name = name;
+		else paramsObj.datasetId = id;
+		const params = new URLSearchParams(paramsObj);
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets/datapoints?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+};
+const logger$3 = initializeLogger$1();
+const INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH = 16e6;
+var EvalsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Initialize an evaluation.
+	*
+	* @param {string} name - Name of the evaluation
+	* @param {string} groupName - Group name of the evaluation
+	* @param {Record<string, any>} metadata - Optional metadata
+	* @returns {Promise<InitEvaluationResponse>} Response from the evaluation initialization
+	*/
+	async init(name, groupName, metadata) {
+		const response = await fetch(this.baseHttpUrl + "/v1/evals", {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				name: name ?? null,
+				groupName: groupName ?? null,
+				metadata: metadata ?? null
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+	/**
+	* Create a new evaluation and return its ID.
+	*
+	* @param {string} [name] - Optional name of the evaluation
+	* @param {string} [groupName] - An identifier to group evaluations
+	* @param {Record<string, any>} [metadata] - Optional metadata
+	* @returns {Promise<StringUUID>} The evaluation ID
+	*/
+	async create(args) {
+		return (await this.init(args?.name, args?.groupName, args?.metadata)).id;
+	}
+	/**
+	* Create a new evaluation and return its ID.
+	* @deprecated use `create` instead.
+	*/
+	async createEvaluation(name, groupName, metadata) {
+		return (await this.init(name, groupName, metadata)).id;
+	}
+	/**
+	* Create a datapoint for an evaluation.
+	*
+	* @param {Object} options - Create datapoint options
+	* @param {string} options.evalId - The evaluation ID
+	* @param {D} options.data - The input data for the executor
+	* @param {T} [options.target] - The target/expected output for evaluators
+	* @param {Record<string, any>} [options.metadata] - Optional metadata
+	* @param {number} [options.index] - Optional index of the datapoint
+	* @param {string} [options.traceId] - Optional trace ID
+	* @returns {Promise<StringUUID>} The datapoint ID
+	*/
+	async createDatapoint({ evalId, data, target, metadata, index, traceId }) {
+		const datapointId = newUUID$1();
+		const partialDatapoint = {
+			id: datapointId,
+			data,
+			target,
+			index: index ?? 0,
+			traceId: traceId ?? newUUID$1(),
+			executorSpanId: newUUID$1(),
+			metadata
+		};
+		await this.saveDatapoints({
+			evalId,
+			datapoints: [partialDatapoint]
+		});
+		return datapointId;
+	}
+	/**
+	* Update a datapoint with evaluation results.
+	*
+	* @param {Object} options - Update datapoint options
+	* @param {string} options.evalId - The evaluation ID
+	* @param {string} options.datapointId - The datapoint ID
+	* @param {Record<string, number>} options.scores - The scores
+	* @param {O} [options.executorOutput] - The executor output
+	* @returns {Promise<void>}
+	*/
+	async updateDatapoint({ evalId, datapointId, scores, executorOutput }) {
+		const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints/${datapointId}`, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				executorOutput,
+				scores
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	/**
+	* Save evaluation datapoints.
+	*
+	* @param {Object} options - Save datapoints options
+	* @param {string} options.evalId - ID of the evaluation
+	* @param {EvaluationDatapoint<D, T, O>[]} options.datapoints - Datapoint to add
+	* @param {string} [options.groupName] - Group name of the evaluation
+	* @returns {Promise<void>} Response from the datapoint addition
+	*/
+	async saveDatapoints({ evalId, datapoints, groupName }) {
+		const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints`, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify({
+				points: datapoints.map((d) => ({
+					...d,
+					data: slicePayload(d.data, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH),
+					target: slicePayload(d.target, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH),
+					executorOutput: slicePayload(d.executorOutput, INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH)
+				})),
+				groupName: groupName ?? null
+			})
+		});
+		if (response.status === 413) return await this.retrySaveDatapoints({
+			evalId,
+			datapoints,
+			groupName
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	/**
+	* Get evaluation datapoints.
+	*
+	* @deprecated Use `client.datasets.pull()` instead.
+	* @param {Object} options - Get datapoints options
+	* @param {string} options.datasetName - Name of the dataset
+	* @param {number} options.offset - Offset at which to start the query
+	* @param {number} options.limit - Maximum number of datapoints to return
+	* @returns {Promise<GetDatapointsResponse>} Response from the datapoint retrieval
+	*/
+	async getDatapoints({ datasetName, offset, limit }) {
+		logger$3.warn("evals.getDatapoints() is deprecated. Use client.datasets.pull() instead.");
+		const params = new URLSearchParams({
+			name: datasetName,
+			offset: offset.toString(),
+			limit: limit.toString()
+		});
+		const response = await fetch(this.baseHttpUrl + `/v1/datasets/datapoints?${params.toString()}`, {
+			method: "GET",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+		return await response.json();
+	}
+	async retrySaveDatapoints({ evalId, datapoints, groupName, maxRetries = 25, initialLength = INITIAL_EVALUATION_DATAPOINT_MAX_DATA_LENGTH }) {
+		let length = initialLength;
+		let lastResponse = null;
+		for (let i = 0; i < maxRetries; i++) {
+			logger$3.debug(`Retrying save datapoints... ${i + 1} of ${maxRetries}, length: ${length}`);
+			const response = await fetch(this.baseHttpUrl + `/v1/evals/${evalId}/datapoints`, {
+				method: "POST",
+				headers: this.headers(),
+				body: JSON.stringify({
+					points: datapoints.map((d) => ({
+						...d,
+						data: slicePayload(d.data, length),
+						target: slicePayload(d.target, length),
+						executorOutput: slicePayload(d.executorOutput, length)
+					})),
+					groupName: groupName ?? null
+				})
+			});
+			lastResponse = response;
+			length = Math.floor(length / 2);
+			if (response.status !== 413) break;
+		}
+		if (lastResponse && !lastResponse.ok) await this.handleError(lastResponse);
+	}
+};
+var EvaluatorScoreSourceType = /* @__PURE__ */ function(EvaluatorScoreSourceType$1) {
+	EvaluatorScoreSourceType$1["Evaluator"] = "Evaluator";
+	EvaluatorScoreSourceType$1["Code"] = "Code";
+	return EvaluatorScoreSourceType$1;
+}(EvaluatorScoreSourceType || {});
+/**
+* Resource for creating evaluator scores
+*/
+var EvaluatorsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Create a score for a span or trace
+	*
+	* @param {ScoreOptions} options - Score creation options
+	* @param {string} options.name - Name of the score
+	* @param {string} [options.traceId] - The trace ID to score (will be attached to top-level span)
+	* @param {string} [options.spanId] - The span ID to score
+	* @param {Record<string, any>} [options.metadata] - Additional metadata
+	* @param {number} options.score - The score value (float)
+	* @returns {Promise<void>}
+	*
+	* @example
+	* // Score by trace ID (will attach to root span)
+	* await evaluators.score({
+	*   name: "quality",
+	*   traceId: "trace-id-here",
+	*   score: 0.95,
+	*   metadata: { model: "gpt-4" }
+	* });
+	*
+	* @example
+	* // Score by span ID
+	* await evaluators.score({
+	*   name: "relevance",
+	*   spanId: "span-id-here",
+	*   score: 0.87
+	* });
+	*/
+	async score(options) {
+		const { name, metadata, score } = options;
+		let payload;
+		if ("traceId" in options && options.traceId) {
+			const formattedTraceId = isStringUUID(options.traceId) ? options.traceId : otelTraceIdToUUID(options.traceId);
+			payload = {
+				name,
+				metadata,
+				score,
+				source: EvaluatorScoreSourceType.Code,
+				traceId: formattedTraceId
+			};
+		} else if ("spanId" in options && options.spanId) {
+			const formattedSpanId = isStringUUID(options.spanId) ? options.spanId : otelSpanIdToUUID(options.spanId);
+			payload = {
+				name,
+				metadata,
+				score,
+				source: EvaluatorScoreSourceType.Code,
+				spanId: formattedSpanId
+			};
+		} else throw new Error("Either 'traceId' or 'spanId' must be provided.");
+		const response = await fetch(this.baseHttpUrl + "/v1/evaluators/score", {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify(payload)
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+var RolloutSessionsResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Connects to the SSE stream for rollout debugging sessions
+	* Returns the Response object for streaming SSE events
+	*/
+	async connect({ sessionId, name, params, signal }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}`, {
+			method: "POST",
+			headers: {
+				...this.headers(),
+				"Accept": "text/event-stream"
+			},
+			body: JSON.stringify({
+				name,
+				params
+			}),
+			signal
+		});
+		if (!response.ok) throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+		if (!response.body) throw new Error("No response body");
+		return response;
+	}
+	async delete({ sessionId }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}`, {
+			method: "DELETE",
+			headers: this.headers()
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	async setStatus({ sessionId, status }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}/status`, {
+			method: "PATCH",
+			headers: this.headers(),
+			body: JSON.stringify({ status })
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+	async sendSpanUpdate({ sessionId, span }) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/rollouts/${sessionId}/update`, {
+			method: "PATCH",
+			headers: this.headers(),
+			body: JSON.stringify({
+				type: "spanStart",
+				spanId: otelSpanIdToUUID(span.spanId),
+				traceId: otelTraceIdToUUID(span.traceId),
+				parentSpanId: span.parentSpanId ? otelSpanIdToUUID(span.parentSpanId) : void 0,
+				attributes: span.attributes,
+				startTime: span.startTime,
+				name: span.name,
+				spanType: span.spanType
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+	}
+};
+var SqlResource = class extends BaseResource {
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	async query(sql, parameters = {}) {
+		const response = await fetch(`${this.baseHttpUrl}/v1/sql/query`, {
+			method: "POST",
+			headers: { ...this.headers() },
+			body: JSON.stringify({
+				query: sql,
+				parameters
+			})
+		});
+		if (!response.ok) await this.handleError(response);
+		return (await response.json()).data;
+	}
+};
+/** Resource for tagging traces. */
+var TagsResource = class extends BaseResource {
+	/** Resource for tagging traces. */
+	constructor(baseHttpUrl, projectApiKey) {
+		super(baseHttpUrl, projectApiKey);
+	}
+	/**
+	* Tag a trace with a list of tags. Note that the trace must be ended before
+	* tagging it. You may want to call `await Laminar.flush()` after the trace
+	* that you want to tag.
+	*
+	* @param {string | StringUUID} trace_id - The trace id to tag.
+	* @param {string[] | string} tags - The tag or list of tags to add to the trace.
+	* @returns {Promise<any>} The response from the server.
+	* @example
+	* ```javascript
+	* import { Laminar, observe, LaminarClient } from "@lmnr-ai/lmnr";
+	* Laminar.initialize();
+	* const client = new LaminarClient();
+	* let traceId: StringUUID | null = null;
+	* // Make sure this is called outside of traced context.
+	* await observe(
+	*   {
+	*     name: "my-trace",
+	*   },
+	*   async () => {
+	*     traceId = await Laminar.getTraceId();
+	*     await foo();
+	*   },
+	* );
+	*
+	* // or make sure the trace is ended by this point.
+	* await Laminar.flush();
+	* if (traceId) {
+	*   await client.tags.tag(traceId, ["tag1", "tag2"]);
+	* }
+	* ```
+	*/
+	async tag(trace_id, tags) {
+		const traceTags = Array.isArray(tags) ? tags : [tags];
+		const formattedTraceId = isStringUUID(trace_id) ? trace_id : otelTraceIdToUUID(trace_id);
+		const url = this.baseHttpUrl + "/v1/tag";
+		const payload = {
+			"traceId": formattedTraceId,
+			"names": traceTags
+		};
+		const response = await fetch(url, {
+			method: "POST",
+			headers: this.headers(),
+			body: JSON.stringify(payload)
+		});
+		if (!response.ok) await this.handleError(response);
+		return response.json();
+	}
+};
+var LaminarClient = class {
+	constructor({ baseUrl, projectApiKey, port } = {}) {
+		loadEnv();
+		this.projectApiKey = projectApiKey ?? process.env.LMNR_PROJECT_API_KEY;
+		const httpPort = port ?? (baseUrl?.match(/:\d{1,5}$/g) ? parseInt(baseUrl.match(/:\d{1,5}$/g)[0].slice(1)) : 443);
+		this.baseUrl = `${(baseUrl ?? process.env.LMNR_BASE_URL)?.replace(/\/$/, "").replace(/:\d{1,5}$/g, "") ?? "https://api.lmnr.ai"}:${httpPort}`;
+		this._browserEvents = new BrowserEventsResource(this.baseUrl, this.projectApiKey);
+		this._datasets = new DatasetsResource(this.baseUrl, this.projectApiKey);
+		this._evals = new EvalsResource(this.baseUrl, this.projectApiKey);
+		this._evaluators = new EvaluatorsResource(this.baseUrl, this.projectApiKey);
+		this._rolloutSessions = new RolloutSessionsResource(this.baseUrl, this.projectApiKey);
+		this._sql = new SqlResource(this.baseUrl, this.projectApiKey);
+		this._tags = new TagsResource(this.baseUrl, this.projectApiKey);
+	}
+	get browserEvents() {
+		return this._browserEvents;
+	}
+	get datasets() {
+		return this._datasets;
+	}
+	get evals() {
+		return this._evals;
+	}
+	get evaluators() {
+		return this._evaluators;
+	}
+	get rolloutSessions() {
+		return this._rolloutSessions;
+	}
+	get sql() {
+		return this._sql;
+	}
+	get tags() {
+		return this._tags;
+	}
+};
+
+//#endregion
+//#region src/cache-server.ts
+const DEFAULT_START_PORT = 35667;
+/**
+* Finds an available port starting from the given port number
+*/
+async function findAvailablePort(startPort) {
+	return new Promise((resolve, reject) => {
+		const server = http.createServer();
+		server.listen(startPort, () => {
+			const port = server.address().port;
+			server.close(() => resolve(port));
+		});
+		server.on("error", (err) => {
+			if (err.code === "EADDRINUSE") resolve(findAvailablePort(startPort + 1));
+			else reject(err);
+		});
+	});
+}
+/**
+* Parses request body as JSON
+*/
+function parseBody(req) {
+	return new Promise((resolve, reject) => {
+		let body = "";
+		req.on("data", (chunk) => {
+			body += chunk.toString();
+		});
+		req.on("end", () => {
+			try {
+				resolve(body ? JSON.parse(body) : {});
+			} catch (err) {
+				reject(/* @__PURE__ */ new Error(`Invalid JSON: ${err instanceof Error ? err.message : String(err)}`));
+			}
+		});
+		req.on("error", reject);
+	});
+}
+/**
+* Starts a local cache server for storing and retrieving cached LLM responses
+* during rollout debugging sessions.
+*
+* @param startPort - Optional starting port number (defaults to 35667)
+* @returns Server information including port, server instance, cache, and metadata setter
+*/
+async function startCacheServer(startPort = DEFAULT_START_PORT) {
+	const cache = /* @__PURE__ */ new Map();
+	let metadata = {
+		pathToCount: {},
+		overrides: void 0
+	};
+	const server = http.createServer((req, res) => {
+		(async () => {
+			res.setHeader("Access-Control-Allow-Origin", "*");
+			res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+			res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+			if (req.method === "OPTIONS") {
+				res.writeHead(200);
+				res.end();
+				return;
+			}
+			if (req.method === "GET" && req.url === "/health") {
+				res.writeHead(200, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ status: "ok" }));
+				return;
+			}
+			if (req.method === "POST" && req.url === "/cached") {
+				try {
+					const { path: path$2, index } = await parseBody(req);
+					if (typeof path$2 !== "string" || typeof index !== "number") {
+						res.writeHead(400, { "Content-Type": "application/json" });
+						res.end(JSON.stringify({ error: "Invalid request: path (string) and index (number) required" }));
+						return;
+					}
+					const cacheKey = `${index}:${path$2}`;
+					const response = {
+						span: cache.get(cacheKey),
+						pathToCount: metadata.pathToCount,
+						overrides: metadata.overrides
+					};
+					res.writeHead(200, { "Content-Type": "application/json" });
+					res.end(JSON.stringify(response));
+				} catch (err) {
+					res.writeHead(400, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+				}
+				return;
+			}
+			res.writeHead(404, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Not found" }));
+		})().catch((error) => {
+			if (!res.headersSent) {
+				res.writeHead(500, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: error instanceof Error ? error.message : "Internal server error" }));
+			}
+		});
+	});
+	const port = await findAvailablePort(startPort);
+	return new Promise((resolve, reject) => {
+		server.listen(port, () => {
+			resolve({
+				port,
+				server,
+				cache,
+				setMetadata: (newMetadata) => {
+					metadata = newMetadata;
+				}
+			});
+		});
+		server.on("error", reject);
+	});
+}
+
+//#endregion
+//#region src/sse-client.ts
+const HEARTBEAT_INTERVAL = 5e3;
+const MAX_MISSED_HEARTBEATS = 3;
+/**
+* SSE client for rollout debugging sessions
+* Connects to the Laminar backend and listens for run events
+*/
+var SSEClient = class extends events.EventEmitter {
+	constructor(options) {
+		super();
+		this.lastHeartbeat = Date.now();
+		this.isShutdown = false;
+		this.client = options.client;
+		this.sessionId = options.sessionId;
+		this.params = options.params;
+		this.name = options.name;
+	}
+	/**
+	* Connects to the SSE endpoint
+	*/
+	async connectAndListen() {
+		if (this.isShutdown) return;
+		this.abortController = new AbortController();
+		this.lastHeartbeat = Date.now();
+		try {
+			const response = await this.client.rolloutSessions.connect({
+				sessionId: this.sessionId,
+				params: this.params,
+				signal: this.abortController.signal,
+				name: this.name
+			});
+			this.emit("connected");
+			this.startHeartbeatCheck();
+			await this.parseSSEStream(response.body);
+		} catch (error) {
+			if (error.name === "AbortError") return;
+			this.emit("error", error);
+			if (!this.isShutdown) this.scheduleReconnect();
+		}
+	}
+	/**
+	* Parses SSE stream and emits events
+	*/
+	async parseSSEStream(body) {
+		const reader = body.getReader();
+		const decoder = new TextDecoder();
+		const parser = (0, eventsource_parser.createParser)({ onEvent: (event) => {
+			this.processSSEEvent(event);
+		} });
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				const chunk = decoder.decode(value, { stream: true });
+				parser.feed(chunk);
+			}
+		} finally {
+			reader.releaseLock();
+		}
+		if (!this.isShutdown) this.scheduleReconnect();
+	}
+	/**
+	* Processes a parsed SSE event
+	*/
+	processSSEEvent(event) {
+		if (!event.data) return;
+		try {
+			if (event.event === "heartbeat") {
+				this.lastHeartbeat = Date.now();
+				this.emit("heartbeat");
+			} else if (event.event === "run") {
+				const runEvent = {
+					event_type: "run",
+					data: JSON.parse(event.data)
+				};
+				this.emit("run", runEvent);
+			} else if (event.event === "handshake") {
+				const handshakeEvent = {
+					event_type: "handshake",
+					data: JSON.parse(event.data)
+				};
+				this.emit("handshake", handshakeEvent);
+			} else if (event.event === "stop") this.emit("stop");
+		} catch (error) {
+			this.emit("error", /* @__PURE__ */ new Error(`Failed to parse SSE event data: ${error}`));
+		}
+	}
+	/**
+	* Starts checking for missed heartbeats
+	*/
+	startHeartbeatCheck() {
+		this.stopHeartbeatCheck();
+		this.heartbeatCheckTimer = setInterval(() => {
+			if (Date.now() - this.lastHeartbeat > HEARTBEAT_INTERVAL * MAX_MISSED_HEARTBEATS) {
+				this.emit("heartbeat_timeout");
+				this.reconnect();
+			}
+		}, HEARTBEAT_INTERVAL);
+	}
+	/**
+	* Stops heartbeat checking
+	*/
+	stopHeartbeatCheck() {
+		if (this.heartbeatCheckTimer) {
+			clearInterval(this.heartbeatCheckTimer);
+			this.heartbeatCheckTimer = void 0;
+		}
+	}
+	/**
+	* Schedules a reconnection attempt
+	*/
+	scheduleReconnect() {
+		if (this.reconnectTimer || this.isShutdown) return;
+		this.emit("reconnecting");
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = void 0;
+			this.reconnect();
+		}, 1e3);
+	}
+	/**
+	* Reconnects to the SSE endpoint
+	*/
+	reconnect() {
+		this.disconnect(true);
+		this.connectAndListen().catch((error) => {
+			this.emit("error", error);
+		});
+	}
+	/**
+	* Disconnects from the SSE endpoint
+	*/
+	disconnect(stopReconnect = true) {
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = void 0;
+		}
+		this.stopHeartbeatCheck();
+		if (stopReconnect && this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = void 0;
+		}
+	}
+	/**
+	* Updates the function metadata (params, name) and reconnects
+	*/
+	updateMetadata(params, name) {
+		this.params = params;
+		this.name = name;
+		this.reconnect();
+	}
+	/**
+	* Shuts down the SSE client gracefully
+	*/
+	shutdown() {
+		this.isShutdown = true;
+		this.disconnect(true);
+		this.emit("shutdown");
+		this.removeAllListeners();
+	}
+};
+/**
+* Creates an SSE client (does not auto-connect)
+* Call client.connect() after registering event listeners
+*/
+function createSSEClient(options) {
+	return new SSEClient(options);
+}
+
+//#endregion
+//#region ../types/dist/index.mjs
+/**
+* Message prefix for protocol messages in stdout
+*/
+const WORKER_MESSAGE_PREFIX = "__LMNR_WORKER__:";
+
+//#endregion
+//#region src/utils.ts
+function initializeLogger(options) {
+	const colorize = options?.colorize ?? true;
+	const level = options?.level ?? process.env.LMNR_LOG_LEVEL?.toLowerCase()?.trim() ?? "info";
+	return (0, pino.default)({ level }, (0, pino_pretty.PinoPretty)({
+		colorize,
+		minimumLevel: level
+	}));
+}
+
+//#endregion
+//#region src/subprocess/executor.ts
+const logger$1 = initializeLogger();
+/**
+* Track and kill the currently running subprocess
+*/
+var SubprocessManager = class {
+	constructor() {
+		this.currentProcess = null;
+	}
+	/**
+	* Execute a subprocess and track it
+	*/
+	async execute(options) {
+		const { command, args, config: config$1 } = options;
+		const child = (0, child_process.spawn)(command, args, { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		this.currentProcess = child;
+		return new Promise((resolve, reject) => {
+			let result = void 0;
+			let hasError = false;
+			readline.createInterface({
+				input: child.stdout,
+				crlfDelay: Infinity
+			}).on("line", (line) => {
+				if (line.startsWith(WORKER_MESSAGE_PREFIX)) try {
+					const messageJson = line.substring(WORKER_MESSAGE_PREFIX.length);
+					const message = JSON.parse(messageJson);
+					switch (message.type) {
+						case "log":
+							logger$1[message.level](message.message);
+							break;
+						case "result":
+							result = message.data;
+							break;
+						case "error":
+							hasError = true;
+							logger$1.error(`Worker error: ${message.error}`);
+							if (message.stack) logger$1.error(message.stack);
+							break;
+					}
+				} catch {
+					logger$1.error(`Failed to parse worker protocol message: ${line}`);
+				}
+				else console.log(line);
+			});
+			child.stderr.on("data", (data) => {
+				process.stderr.write(data);
+			});
+			child.on("exit", (code, signal) => {
+				if (this.currentProcess?.pid === child.pid) this.currentProcess = null;
+				if (signal) reject(/* @__PURE__ */ new Error(`Worker terminated by signal: ${signal}`));
+				else if (code === 0) resolve(result);
+				else {
+					if (!hasError) logger$1.error(`Worker exited with code ${code}`);
+					reject(/* @__PURE__ */ new Error(`Worker exited with code ${code}`));
+				}
+			});
+			child.on("error", (error) => {
+				this.currentProcess = null;
+				reject(/* @__PURE__ */ new Error(`Failed to spawn worker: ${error.message}`));
+			});
+			child.stdin?.write(JSON.stringify(config$1) + "\n");
+			child.stdin?.end();
+		});
+	}
+	/**
+	* Kill the currently running subprocess
+	*/
+	kill() {
+		if (this.currentProcess) {
+			const processToKill = this.currentProcess;
+			this.currentProcess.kill("SIGTERM");
+			setTimeout(() => {
+				if (processToKill && processToKill.exitCode === null) {
+					logger$1.warn("Child process did not terminate, using SIGKILL");
+					processToKill.kill("SIGKILL");
+				}
+			}, 5e3);
+		}
+	}
+	/**
+	* Check if a subprocess is currently running
+	*/
+	isRunning() {
+		return this.currentProcess !== null;
+	}
+};
+
+//#endregion
+//#region src/worker-registry.ts
+/**
+* Default workers mapped by file extension
+*/
+const DEFAULT_WORKERS = {
+	".ts": {
+		command: "node",
+		args: []
+	},
+	".cts": {
+		command: "node",
+		args: []
+	},
+	".mts": {
+		command: "node",
+		args: []
+	},
+	".tsx": {
+		command: "node",
+		args: []
+	},
+	".jsx": {
+		command: "node",
+		args: []
+	},
+	".js": {
+		command: "node",
+		args: []
+	},
+	".mjs": {
+		command: "node",
+		args: []
+	},
+	".cjs": {
+		command: "node",
+		args: []
+	},
+	".py": {
+		command: "python3",
+		args: ["-m", "lmnr.cli.worker"]
+	}
+};
+/**
+* Get the worker command for a given file path or module.
+* Resolves the TypeScript worker dynamically from @lmnr-ai/lmnr package.
+*/
+function getWorkerCommand(filePath, options) {
+	if (options?.pythonModule) return {
+		command: "python3",
+		args: ["-m", "lmnr.cli.worker"]
+	};
+	if (!filePath) throw new Error("Either filePath or pythonModule must be provided");
+	const ext = path.extname(filePath);
+	if (!DEFAULT_WORKERS[ext]) throw new Error(`Unsupported file extension: ${ext}. Supported extensions: ${Object.keys(DEFAULT_WORKERS).join(", ")}`);
+	const worker = DEFAULT_WORKERS[ext];
+	if ([
+		".ts",
+		".tsx",
+		".js",
+		".mjs",
+		".cjs",
+		".mts",
+		".cts",
+		".jsx"
+	].includes(ext)) try {
+		const workerPath = require.resolve("@lmnr-ai/lmnr/dist/cli/worker/index.cjs");
+		return {
+			command: worker.command,
+			args: [workerPath]
+		};
+	} catch (error) {
+		throw new Error(`Failed to resolve TypeScript/JavaScript worker from @lmnr-ai/lmnr package. Make sure @lmnr-ai/lmnr is installed. Error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return worker;
+}
+
+//#endregion
+//#region src/commands/dev.ts
+const logger = initializeLogger();
+const TS_JS_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".mjs",
+	".cjs",
+	".jsx",
+	".mts",
+	".cts"
+];
+const EXTENSIONS_TO_DISCOVER_METADATA = [...TS_JS_EXTENSIONS, ".py"];
+/**
+* Discovers function metadata for TypeScript and JavaScript files by:
+* 1. Extracting TypeScript metadata (params with types from source - TS only)
+* 2. Building and loading the module with esbuild
+* 3. Selecting the appropriate function
+* 4. Matching metadata by span name
+*
+* For JavaScript files, TypeScript metadata extraction fails gracefully, but runtime
+* parameter extraction via regex still works (param names without types).
+*/
+const discoverTypeScriptMetadata = async (filePath, options) => {
+	const lmnrPackage = "@lmnr-ai/lmnr";
+	const { extractRolloutFunctions } = require(`${lmnrPackage}/dist/cli/worker/ts-parser.cjs`);
+	const { buildFile, loadModule, selectRolloutFunction } = require(`${lmnrPackage}/dist/cli/worker/build.cjs`);
+	let paramsMetadata;
+	try {
+		paramsMetadata = extractRolloutFunctions(filePath);
+		logger.debug(`Extracted TypeScript metadata for ${paramsMetadata?.size} functions`);
+	} catch (error) {
+		logger.warn("Failed to extract TypeScript metadata, falling back to runtime parsing: " + (error instanceof Error ? error.message : String(error)));
+	}
+	loadModule({
+		filename: filePath,
+		moduleText: await buildFile(filePath, {
+			externalPackages: options.externalPackages,
+			dynamicImportsToSkip: options.dynamicImportsToSkip
+		})
+	});
+	const selectedFunction = selectRolloutFunction(options.function);
+	if (paramsMetadata) {
+		logger.debug(`Available TS metadata keys: ${Array.from(paramsMetadata.keys()).join(", ")}`);
+		logger.debug(`Looking for span name: ${selectedFunction.name} (runtime key: ${selectedFunction.exportName})`);
+		let foundMetadata = null;
+		for (const [exportName, metadata] of paramsMetadata.entries()) {
+			logger.debug(`Checking ${exportName}: span name = ${metadata.name}, export name = ${exportName}`);
+			if (metadata.name === selectedFunction.name) {
+				foundMetadata = metadata;
+				logger.debug(`Match. Export name: ${exportName}, span name: ${metadata.name}`);
+				break;
+			}
+		}
+		if (foundMetadata) {
+			selectedFunction.params = foundMetadata.params;
+			logger.debug(`Using TypeScript metadata for span: ${selectedFunction.name}`);
+		} else logger.info(`No TypeScript metadata found for span name: ${selectedFunction.name}`);
+	}
+	return {
+		functionName: selectedFunction.name,
+		params: selectedFunction.params || []
+	};
+};
+/**
+* Helper to execute subprocess commands
+*/
+const execCommand = async (command, args) => new Promise((resolve, reject) => {
+	const { spawn: spawn$1 } = require("child_process");
+	const child = spawn$1(command, args);
+	let stdout = "";
+	let stderr = "";
+	child.stdout.on("data", (data) => {
+		stdout += data.toString();
+	});
+	child.stderr.on("data", (data) => {
+		stderr += data.toString();
+	});
+	child.on("close", (code) => {
+		if (code === 0) resolve({
+			stdout,
+			stderr
+		});
+		else reject(/* @__PURE__ */ new Error(`Command failed with code ${code}: ${stderr}`));
+	});
+	child.on("error", (error) => {
+		reject(error);
+	});
+});
+/**
+* Discovers function metadata for Python files/modules by calling the lmnr Python CLI
+*/
+const discoverPythonMetadata = async (filePathOrModule, options) => {
+	logger.debug(`Discovering Python metadata for ${filePathOrModule}`);
+	const args = ["discover"];
+	if (options.pythonModule) args.push("--module", options.pythonModule);
+	else args.push("--file", filePathOrModule);
+	if (options.function) args.push("--function", options.function);
+	try {
+		const result = await execCommand("lmnr", args);
+		const response = JSON.parse(result.stdout);
+		return {
+			functionName: response.name,
+			params: response.params || []
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logger.error(`Failed to discover Python metadata: ${errorMessage}`);
+		if (errorMessage.toLowerCase().includes("command not found") || errorMessage.includes("spawn lmnr ENOENT")) {
+			logger.info(`HINT: Make sure latest version of \`lmnr\` python package is installed. \`pip install --upgrade lmnr\`, or if you are running this command from a virtual environment, make sure to activate it. For \`uv\` users, rerun the command with \`uv run\`, e.g. "uv run npx lmnr-cli dev ${filePathOrModule}"`);
+			process.exit(1);
+		}
+		const defaultName = options.pythonModule ? options.pythonModule.split(".").pop() || "main" : path.basename(filePathOrModule, ".py");
+		return {
+			functionName: options.function || defaultName,
+			params: []
+		};
+	}
+};
+/**
+* Generic metadata discovery dispatcher that routes to language-specific implementations
+*/
+const discoverFunctionMetadata = async (filePathOrModule, options) => {
+	if (options.pythonModule) return await discoverPythonMetadata(filePathOrModule, options);
+	const ext = path.extname(filePathOrModule);
+	if (TS_JS_EXTENSIONS.includes(ext)) return await discoverTypeScriptMetadata(filePathOrModule, options);
+	if (ext === ".py") return await discoverPythonMetadata(filePathOrModule, options);
+	logger.warn(`No metadata discovery available for ${ext} files`);
+	return {
+		functionName: options.function || path.basename(filePathOrModule, ext),
+		params: []
+	};
+};
+function newUUID() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return (0, uuid.v4)();
+}
+function getFrontendUrl(baseUrl, frontendPort) {
+	let url = baseUrl ?? "https://api.lmnr.ai";
+	if (url === "https://api.lmnr.ai") url = "https://www.laminar.sh";
+	url = url.replace(/\/$/, "");
+	if (/localhost|127\.0\.0\.1/.test(url)) {
+		const port = frontendPort ?? url.match(/:\d{1,5}$/g)?.[0]?.slice(1) ?? 5667;
+		url = url.replace(/:\d{1,5}$/g, "");
+		return `${url}:${port}`;
+	}
+	return url;
+}
+/**
+* Parses request arguments, attempting JSON parse for strings
+*/
+const tryParseArg = (arg) => {
+	if (typeof arg === "string") try {
+		return JSON.parse(arg);
+	} catch {
+		return arg;
+	}
+	return arg;
+};
+/**
+* Handles a run event from the backend
+*/
+const handleRunEvent = async (event, sessionId, filePathOrModule, client, cacheServerPort, cache, setMetadata, options, subprocessManager) => {
+	logger.debug("Received run event");
+	const { trace_id, path_to_count, args: rawArgs, overrides } = event.data;
+	const parsedArgs = Array.isArray(rawArgs) ? rawArgs.map(tryParseArg) : Object.fromEntries(Object.entries(rawArgs).map(([key, value]) => [key, tryParseArg(value)]));
+	cache.clear();
+	setMetadata({
+		pathToCount: {},
+		overrides
+	});
+	try {
+		if (!trace_id || trace_id.trim() === "") logger.info("No spans in cache, starting fresh");
+		else {
+			const paths = Object.keys(path_to_count || {});
+			if (paths.length === 0) logger.info("No spans to cache, starting fresh");
+			else {
+				const query = `
+          SELECT name, input, output, attributes, path
+          FROM spans
+          WHERE trace_id = {traceId:UUID}
+            AND path IN {paths:String[]}
+          ORDER BY start_time ASC
+        `;
+				logger.debug(`Querying spans from trace ${trace_id}...`);
+				const spans = await client.sql.query(query, {
+					traceId: trace_id,
+					paths
+				});
+				logger.debug(`Received ${spans.length} spans from backend`);
+				const spansByPath = {};
+				for (const span of spans) {
+					const path$2 = span.path;
+					if (!spansByPath[path$2]) spansByPath[path$2] = [];
+					spansByPath[path$2].push(span);
+				}
+				for (const [path$2, pathSpans] of Object.entries(spansByPath)) {
+					const maxCount = path_to_count?.[path$2] || 0;
+					const spansToCache = pathSpans.slice(0, maxCount);
+					spansToCache.forEach((span, index) => {
+						let parsedInput = span.input;
+						let parsedOutput = span.output;
+						let parsedAttributes = span.attributes;
+						try {
+							parsedInput = typeof span.input === "string" ? JSON.parse(span.input) : span.input;
+						} catch {}
+						try {
+							parsedOutput = typeof span.output === "string" ? span.output : JSON.stringify(span.output);
+						} catch {
+							parsedOutput = String(span.output);
+						}
+						try {
+							parsedAttributes = typeof span.attributes === "string" ? JSON.parse(span.attributes) : span.attributes;
+						} catch {
+							parsedAttributes = {};
+						}
+						const cachedSpan = {
+							name: span.name,
+							input: parsedInput,
+							output: parsedOutput,
+							attributes: parsedAttributes
+						};
+						const cacheKey = `${index}:${path$2}`;
+						cache.set(cacheKey, cachedSpan);
+					});
+					logger.info(`Cached ${spansToCache.length} spans for path: ${path$2}`);
+				}
+				setMetadata({
+					pathToCount: path_to_count || {},
+					overrides
+				});
+			}
+		}
+		const baseUrl = options.baseUrl ?? process.env.LMNR_BASE_URL ?? "https://api.lmnr.ai";
+		const httpPort = options.port ?? (baseUrl.match(/:\d{1,5}$/g) ? parseInt(baseUrl.match(/:\d{1,5}$/g)[0].slice(1)) : 443);
+		const grpcPort = options.grpcPort ?? 8443;
+		const env = {
+			LMNR_ROLLOUT_SESSION_ID: sessionId,
+			LMNR_ROLLOUT_STATE_SERVER_ADDRESS: `http://localhost:${cacheServerPort}`
+		};
+		const workerConfig = {
+			filePath: options.pythonModule ? void 0 : filePathOrModule,
+			modulePath: options.pythonModule,
+			functionName: options.function,
+			args: parsedArgs,
+			env,
+			cacheServerPort,
+			baseUrl,
+			projectApiKey: options.projectApiKey,
+			httpPort,
+			grpcPort,
+			externalPackages: options.externalPackages,
+			dynamicImportsToSkip: options.dynamicImportsToSkip
+		};
+		const workerCommand = options.command ? {
+			command: options.command,
+			args: options.commandArgs ?? []
+		} : getWorkerCommand(options.pythonModule ? void 0 : filePathOrModule, options);
+		try {
+			await client.rolloutSessions.setStatus({
+				sessionId,
+				status: "RUNNING"
+			});
+		} catch (error) {
+			logger.error(`Error setting rollout session status: ${error instanceof Error ? error.message : error}`);
+		}
+		await subprocessManager.execute({
+			command: workerCommand.command,
+			args: workerCommand.args,
+			config: workerConfig
+		});
+		try {
+			await client.rolloutSessions.setStatus({
+				sessionId,
+				status: "FINISHED"
+			});
+		} catch (error) {
+			logger.error(`Error setting rollout session status: ${error instanceof Error ? error.message : error}`);
+		}
+	} catch (error) {
+		logger.error(`Error handling run event: ${error instanceof Error ? error.message : error}`);
+		if (error instanceof Error && error.stack) logger.error(error.stack);
+		try {
+			await client.rolloutSessions.setStatus({
+				sessionId,
+				status: "FINISHED"
+			});
+		} catch (error$1) {
+			logger.error(`Error setting rollout session status: ${error$1 instanceof Error ? error$1.message : error$1}`);
+		}
+	}
+};
+/**
+* Main dev command handler
+*/
+async function runDev(filePath, options = {}) {
+	const isPythonModule = !!options.pythonModule;
+	const filePathOrModule = filePath || options.pythonModule;
+	const sessionId = newUUID();
+	const client = new LaminarClient({
+		baseUrl: options.baseUrl,
+		projectApiKey: options.projectApiKey,
+		port: options.port
+	});
+	logger.debug("Starting cache server...");
+	const { port: cacheServerPort, server: cacheServer, cache, setMetadata } = await startCacheServer();
+	logger.debug(`Cache server started on port ${cacheServerPort}`);
+	const subprocessManager = new SubprocessManager();
+	let functionName = options.function;
+	let params = [];
+	try {
+		if (isPythonModule || filePath && EXTENSIONS_TO_DISCOVER_METADATA.includes(path.extname(filePath))) {
+			logger.debug("Discovering rollout functions...");
+			const metadata = await discoverFunctionMetadata(filePathOrModule, options);
+			functionName = metadata.functionName;
+			params = metadata.params;
+			logger.info(`Serving function: ${functionName}`);
+			logger.debug(`Function parameters: ${JSON.stringify(params, null, 2)}`);
+		} else if (filePath) {
+			functionName = options.function || path.basename(filePath, path.extname(filePath));
+			logger.warn(`Metadata discovery not available for ${path.extname(filePath)} files`);
+		}
+	} catch (error) {
+		logger.error("Failed to discover rollout functions: " + (error instanceof Error ? error.message : String(error)));
+		cacheServer.close();
+		throw error;
+	}
+	logger.debug("Setting up file watcher...");
+	const watcher = chokidar.default.watch(".", {
+		ignored: (path$2) => {
+			const ignoredDirs = [
+				"node_modules",
+				".git",
+				"dist",
+				"build",
+				".next",
+				"coverage",
+				".turbo",
+				"tmp",
+				"temp",
+				"venv",
+				".venv",
+				"virtualenv",
+				".virtualenv",
+				"__pycache__",
+				".pytest_cache",
+				".ruff_cache",
+				".mypy_cache",
+				".cache",
+				".DS_Store"
+			];
+			if (path$2.split(/[/\\]/).some((segment) => ignoredDirs.includes(segment))) return true;
+			if (path$2.endsWith(".log") || path$2.endsWith(".map")) return true;
+			return false;
+		},
+		persistent: true,
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 100,
+			pollInterval: 100
+		}
+	});
+	logger.debug("Setting up SSE client...");
+	let sseClient = null;
+	try {
+		sseClient = createSSEClient({
+			client,
+			sessionId,
+			params,
+			name: functionName ?? ""
+		});
+		sseClient.on("heartbeat", () => {
+			logger.debug("Heartbeat received");
+		});
+		sseClient.on("run", (event) => {
+			if (subprocessManager.isRunning()) {
+				logger.warn("Rollout is already running, skipping new run");
+				return;
+			}
+			handleRunEvent(event, sessionId, filePathOrModule, client, cacheServerPort, cache, setMetadata, options, subprocessManager).catch((error) => {
+				logger.error("Unhandled error in run event handler: " + (error instanceof Error ? error.message : String(error)));
+			});
+		});
+		sseClient.on("handshake", (event) => {
+			const projectId = event.data.project_id;
+			const sessionId$1 = event.data.session_id;
+			const frontendUrl = getFrontendUrl(options.baseUrl, options.frontendPort);
+			logger.info(`View your session at ${frontendUrl}/project/${projectId}/rollout-sessions/${sessionId$1}`);
+		});
+		sseClient.on("error", (error) => {
+			logger.warn(`Error connecting to backend: ${error.message}`);
+		});
+		sseClient.on("reconnecting", () => {
+			logger.info("Reconnecting to backend...");
+		});
+		sseClient.on("heartbeat_timeout", () => {
+			logger.debug("Heartbeat timeout, reconnecting...");
+		});
+		sseClient.on("stop", () => {
+			logger.debug("Cancelling current run...");
+			subprocessManager.kill();
+			logger.info("Current run cancelled");
+		});
+		watcher.on("change", (changedPath) => {
+			logger.info(`File changed: ${changedPath}, reloading...`);
+			if (subprocessManager.isRunning()) {
+				logger.warn("Cancelling current run due to file change");
+				subprocessManager.kill();
+			}
+			if (isPythonModule || filePath && EXTENSIONS_TO_DISCOVER_METADATA.includes(path.extname(filePath))) discoverFunctionMetadata(filePathOrModule, options).then((metadata) => {
+				logger.debug(`Updated function metadata: ${metadata.functionName}`);
+				logger.debug(`Updated parameters: ${JSON.stringify(metadata.params, null, 2)}`);
+				if (sseClient) {
+					sseClient.updateMetadata(metadata.params, metadata.functionName);
+					logger.debug("Notified backend of metadata changes");
+				}
+			}).catch((error) => {
+				logger.error("Failed to update function metadata: " + (error instanceof Error ? error.message : String(error)));
+			});
+		});
+		const shutdown = () => {
+			logger.debug("Shutting down...");
+			logger.debug("Closing file watcher...");
+			watcher.close().catch((error) => {
+				logger.error(`Failed to close file watcher: ${error instanceof Error ? error.message : error}`);
+			});
+			subprocessManager.kill();
+			logger.debug("Deleting rollout session...");
+			client.rolloutSessions.delete({ sessionId }).then(() => {
+				if (sseClient) sseClient.shutdown();
+				cacheServer.close(() => {
+					logger.debug("Cache server closed");
+				});
+				process.exit(0);
+			}).catch((error) => {
+				logger.warn(`Failed to delete rollout session: ${error instanceof Error ? error.message : error}`);
+				process.exit(1);
+			});
+		};
+		process.on("SIGINT", shutdown);
+		process.on("SIGTERM", shutdown);
+		process.stdin.resume();
+		logger.debug("Connecting to backend...");
+		await sseClient.connectAndListen();
+	} catch (error) {
+		logger.error("Failed to start dev command: " + (error instanceof Error ? error.message : String(error)));
+		try {
+			await client.rolloutSessions.delete({ sessionId });
+		} catch {}
+		await watcher.close();
+		cacheServer.close(() => {
+			process.exit(1);
+		});
+	}
+}
+
+//#endregion
+//#region src/index.ts
+async function main() {
+	const program = new commander.Command();
+	program.name("lmnr-cli").description("CLI for Laminar AI rollout debugging").version(version$1, "-v, --version", "display version number");
+	program.command("dev").description("Start a rollout debugging session").argument("[file]", "Path to file containing the agent function(s). Either `file` or `-m` must be provided.").option("-m, --python-module <module>", "Python module path (e.g., src.myfile). Either `file` or `-m` must be provided.").option("--function <name>", "Specific function to serve (if multiple rollout functions found)").option("--project-api-key <key>", "Project API key. If not provided, reads from LMNR_PROJECT_API_KEY env variable").option("--base-url <url>", "Base URL for the Laminar API. Defaults to https://api.lmnr.ai or LMNR_BASE_URL env variable").option("--port <port>", "Port for the Laminar API. Defaults to 443", (val) => parseInt(val, 10)).option("--grpc-port <port>", "Port for the Laminar gRPC backend. Defaults to 8443", (val) => parseInt(val, 10)).option("--frontend-port <port>", "Port for the Laminar frontend. Defaults to 5667", (val) => parseInt(val, 10)).option("--external-packages <packages...>", "[ADVANCED] List of packages to pass as external to esbuild. This will not link the packages directly into the dev file, but will instead require them at runtime. Read more: https://esbuild.github.io/api/#external").option("--dynamic-imports-to-skip <modules...>", "[ADVANCED] List of module names to skip when encountered as dynamic imports. These dynamic imports will resolve to an empty module to prevent build failures. This is meant to skip the imports that are not used in the rollout itself.").option("--command <command>", "[ADVANCED] Custom command to run the worker (e.g., python3, node)").option("--command-args <args...>", "[ADVANCED] Arguments for the custom command").action(async (file, options) => {
+		if (!file && !options.pythonModule) {
+			console.error("Error: Must provide either a file path or --python-module (-m) flag");
+			process.exit(1);
+		}
+		if (file && options.pythonModule) {
+			console.error("Error: Cannot specify both file path and --python-module (-m) flag");
+			process.exit(1);
+		}
+		await runDev(file, options);
+	}).addHelpText("after", `
+Examples:
+  $ lmnr-cli dev agent.ts                    # TypeScript file
+  $ lmnr-cli dev agent.py                    # Python file (script mode)
+  $ lmnr-cli dev -m src.agent                # Python module (module mode)
+  $ lmnr-cli dev agent.ts --function myAgent # Specific function
+`);
+	await program.parseAsync();
+}
+main().catch((err) => {
+	console.error(err instanceof Error ? err.message : err);
+	process.exit(1);
+});
+
+//#endregion
+//# sourceMappingURL=index.cjs.map