@andrew_l/app 0.3.8 → 0.4.1

package/dist/index.mjs

@@ -1,527 +1,435 @@
-import { env, getLoggerLevel, noop, isFunction, typeOf, EJSON, captureStackTrace, def, isSkip, defer, toError, SimpleEventEmitter, camelCase, capitalize, asyncForEach, pickPrefixed, isError, Scheduler, isObject, assert, catchError, isString, getFileExtension, uniq, isNumber, kebabCase, arrayable, AsyncIterableQueue, ResourcePool, CancellablePromise } from '@andrew_l/toolkit';
-import os from 'node:os';
-import path from 'node:path';
-import { createConsola, LogLevels } from 'consola';
-import { isShuttingDown, onShutdownError, onShutdown, processGraceful } from '@andrew_l/graceful';
-import * as cp from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { Option, InvalidArgumentError, Command } from 'commander';
-import fs from 'node:fs';
-import dotenv from 'dotenv';
-import { getColor } from 'consola/utils';
-import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { Box, Text, useStdout, useInput, render } from 'ink';
-import { createContext, useState, useEffect, useContext } from 'react';
-
+import { AsyncIterableQueue, CancellablePromise, EJSON, ResourcePool, Scheduler, SimpleEventEmitter, arrayable, assert, asyncForEach, camelCase, capitalize, captureStackTrace, catchError, def, defer, env, getFileExtension, getLoggerLevel, isError, isFunction, isNumber, isObject, isSkip, isString, kebabCase, noop, pickPrefixed, toError, typeOf, uniq } from "@andrew_l/toolkit";
+import os from "node:os";
+import path from "node:path";
+import { LogLevels, createConsola } from "consola";
+import { isShuttingDown, onShutdown, onShutdownError, processGraceful } from "@andrew_l/graceful";
+import * as cp from "node:child_process";
+import { EventEmitter } from "node:events";
+import { Command, InvalidArgumentError, Option } from "commander";
+import fs from "node:fs";
+import dotenv from "dotenv";
+import { getColor } from "consola/utils";
+import { Box, Text, render, useInput, useStdout } from "ink";
+import { createContext, useContext, useEffect, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 const CONFIG = Object.freeze({
-  IS_VRUN: env.bool("VRUN", false),
-  WATCH_MODE: env.bool("VRUN_WATCH", false),
-  /**
-   * Root path of application
-   */
-  APP_ROOT: env.string("APP_ROOT") || null,
-  /**
-   * Typescript resolver mode
-   */
-  TS_MODE: env.string(
-    "VRUN_TS_MODE",
-    process.execArgv.some((v) => v.includes("tsx/dist/loader.mjs")) ? "tsx" : ""
-  ) || null,
-  /**
-   * List of disabled workers
-   */
-  WORKER_DISABLED: new Set(env.list("WORKER_DISABLE", "string"))
+	IS_VRUN: env.bool("VRUN", false),
+	WATCH_MODE: env.bool("VRUN_WATCH", false),
+	APP_ROOT: env.string("APP_ROOT") || null,
+	TS_MODE: env.string("VRUN_TS_MODE", process.execArgv.some((v) => v.includes("tsx/dist/loader.mjs")) ? "tsx" : "") || null,
+	WORKER_DISABLED: new Set(env.list("WORKER_DISABLE", "string"))
 });
-
 const isHelpArgument = (argv) => {
-  if (!Array.isArray(argv)) {
-    argv = [argv];
-  }
-  return argv.includes("--help") || argv.includes("-h");
+	if (!Array.isArray(argv)) argv = [argv];
+	return argv.includes("--help") || argv.includes("-h");
 };
 function extractOptionsArgs(argv) {
-  const result = [];
-  let flag = false;
-  for (const value of argv) {
-    if (value.startsWith("--")) {
-      flag = true;
-      result.push(value);
-      continue;
-    }
-    if (flag) {
-      result.push(value);
-      flag = false;
-    }
-  }
-  return result;
+	const result = [];
+	let flag = false;
+	for (const value of argv) {
+		if (value.startsWith("--")) {
+			flag = true;
+			result.push(value);
+			continue;
+		}
+		if (flag) {
+			result.push(value);
+			flag = false;
+		}
+	}
+	return result;
 }
-
 function filePathFromStack(stack) {
-  const stackLines = stack.trim().split("\n");
-  const callerLine = stackLines[0];
-  let filePath = null;
-  const patterns = [
-    /\((.+):(\d+):(\d+)\)$/,
-    // (file:line:col)
-    /at\s+(.+):(\d+):(\d+)$/,
-    // at file:line:col
-    /\s+at\s+(.+):(\d+):(\d+)$/,
-    // at file:line:col with spaces
-    /\(file:\/\/(.+):(\d+):(\d+)\)$/,
-    // (file://path:line:col)
-    /file:\/\/(.+):(\d+):(\d+)$/
-    // file://path:line:col
-  ];
-  for (const pattern of patterns) {
-    const match = callerLine.match(pattern);
-    if (match) {
-      filePath = match[1];
-      break;
-    }
-  }
-  if (!filePath) {
-    return null;
-  }
-  if (filePath.startsWith("file://")) {
-    filePath = filePath.replace("file://", "");
-  }
-  if (process.platform === "win32") {
-    filePath = filePath.replace(/\//g, "\\");
-    if (filePath.match(/^[A-Za-z]:\\/)) ; else if (filePath.startsWith("\\")) ; else {
-      filePath = path.resolve(filePath);
-    }
-  }
-  return path.normalize(filePath);
+	const callerLine = stack.trim().split("\n")[0];
+	let filePath = null;
+	for (const pattern of [
+		/\((.+):(\d+):(\d+)\)$/,
+		/at\s+(.+):(\d+):(\d+)$/,
+		/\s+at\s+(.+):(\d+):(\d+)$/,
+		/\(file:\/\/(.+):(\d+):(\d+)\)$/,
+		/file:\/\/(.+):(\d+):(\d+)$/
+	]) {
+		const match = callerLine.match(pattern);
+		if (match) {
+			filePath = match[1];
+			break;
+		}
+	}
+	if (!filePath) return null;
+	if (filePath.startsWith("file://")) filePath = filePath.replace("file://", "");
+	if (process.platform === "win32") {
+		filePath = filePath.replace(/\//g, "\\");
+		if (filePath.match(/^[A-Za-z]:\\/)) {} else if (filePath.startsWith("\\")) {} else filePath = path.resolve(filePath);
+	}
+	return path.normalize(filePath);
 }
-
 function isMainFile(filepath) {
-  const cwd = process.cwd();
-  return process.argv.some((arg) => filepath.endsWith(path.resolve(cwd, arg)));
+	const cwd = process.cwd();
+	return process.argv.some((arg) => filepath.endsWith(path.resolve(cwd, arg)));
 }
-
 const createLogger = (tagName) => {
-  const log2 = createConsola({
-    formatOptions: { date: false },
-    level: LogLevels[getLoggerLevel()],
-    fancy: true,
-    defaults: {
-      tag: tagName
-    }
-  });
-  log2.extend = (tagName2) => createLogger(tagName2);
-  return log2;
+	const log = createConsola({
+		formatOptions: { date: false },
+		level: LogLevels[getLoggerLevel()],
+		fancy: true,
+		defaults: { tag: tagName }
+	});
+	log.extend = (tagName) => createLogger(tagName);
+	return log;
 };
 const log = createLogger();
 const noopLogger = {
-  debug: noop,
-  error: noop,
-  extend: () => noopLogger,
-  info: noop,
-  log: noop,
-  warn: noop
+	debug: noop,
+	error: noop,
+	extend: () => noopLogger,
+	info: noop,
+	log: noop,
+	warn: noop
 };
-
 function formatLogEvent(event, fields) {
-  if (!fields) return event;
-  const parts = [];
-  for (const key in fields) {
-    if (key === "vrun_app_thread_message") continue;
-    const v = fields[key];
-    if (v === void 0) continue;
-    parts.push(`${key}=${formatField(v)}`);
-  }
-  return parts.length ? `${event} ${parts.join(" ")}` : event;
+	if (!fields) return event;
+	const parts = [];
+	for (const key in fields) {
+		if (key === "vrun_app_thread_message") continue;
+		const v = fields[key];
+		if (v === void 0) continue;
+		parts.push(`${key}=${formatField(v)}`);
+	}
+	return parts.length ? `${event} ${parts.join(" ")}` : event;
 }
 function formatField(value) {
-  switch (typeOf(value)) {
-    case "array":
-    case "object":
-      return EJSON.stringify(value);
-    default: {
-      return String(value);
-    }
-  }
+	switch (typeOf(value)) {
+		case "array":
+		case "object": return EJSON.stringify(value);
+		default: return String(value);
+	}
 }
 function createAppLogger(definition) {
-  return definition.logger === false ? noopLogger : isFunction(definition.logger) ? definition.logger(definition) : definition.logger || createLogger(definition.name);
+	return definition.logger === false ? noopLogger : isFunction(definition.logger) ? definition.logger(definition) : definition.logger || createLogger(definition.name);
 }
-
 const APP_INSTANCE_STATE = {
-  INIT: "init",
-  IN_SETUP: "in-setup",
-  SETUP: "setup",
-  IN_STOP: "in-stop",
-  IN_RUN: "in-run",
-  RUN: "run",
-  STOP: "stop",
-  IN_SHUTDOWN: "in-shutdown",
-  SHUTDOWN: "shutdown",
-  ERROR: "error"
+	INIT: "init",
+	IN_SETUP: "in-setup",
+	SETUP: "setup",
+	IN_STOP: "in-stop",
+	IN_RUN: "in-run",
+	RUN: "run",
+	STOP: "stop",
+	IN_SHUTDOWN: "in-shutdown",
+	SHUTDOWN: "shutdown",
+	ERROR: "error"
 };
 const APP_DEF = Symbol("app-definition");
 function defineApp(definition) {
-  const result = {
-    filePath: filePathFromStack(captureStackTrace(defineApp)),
-    ...definition
-  };
-  def(result, APP_DEF, true);
-  if (!CONFIG.IS_VRUN) {
-    if (result.filePath) {
-      if (isMainFile(result.filePath)) {
-        Promise.resolve().then(function () { return index; }).then((m) => {
-          m.cli.runApp({
-            cliName: "app",
-            scriptFile: result.filePath,
-            argv: extractOptionsArgs(process.argv.slice(1))
-          });
-        });
-      }
-    }
-  }
-  return result;
+	const result = {
+		filePath: filePathFromStack(captureStackTrace(defineApp)),
+		...definition
+	};
+	def(result, APP_DEF, true);
+	if (!CONFIG.IS_VRUN) {
+		if (result.filePath) {
+			if (isMainFile(result.filePath)) import("./_chunks/cli.mjs").then((m) => {
+				m.cli.runApp({
+					cliName: "app",
+					scriptFile: result.filePath,
+					argv: extractOptionsArgs(process.argv.slice(1))
+				});
+			});
+		}
+	}
+	return result;
 }
 function createAppInstance(definition) {
-  const setupState = createSetupState(definition);
-  return {
-    definition,
-    props: null,
-    setupState,
-    eventBus: new SimpleEventEmitter(),
-    mutexName: null,
-    mutexQueue: Promise.resolve(),
-    state: APP_INSTANCE_STATE.INIT,
-    logger: setupState.log
-  };
+	const setupState = createSetupState(definition);
+	return {
+		definition,
+		props: null,
+		setupState,
+		eventBus: new SimpleEventEmitter(),
+		mutexName: null,
+		mutexQueue: Promise.resolve(),
+		state: APP_INSTANCE_STATE.INIT,
+		logger: setupState.log
+	};
 }
 function isAppDefinition(value) {
-  return value?.[APP_DEF] === true;
-}
-async function startApp(app, props) {
-  const instance = isAppDefinition(app) ? createAppInstance(app) : app;
-  const setupResult = await setupApp(instance, props);
-  if (isSkip(setupResult)) {
-    return setupResult;
-  }
-  const runResult = await runApp$1(instance);
-  if (isSkip(runResult)) {
-    await shutdownApp(instance);
-    return runResult;
-  }
-  return {
-    success: true,
-    code: "start_app",
-    app: instance
-  };
-}
-async function setupApp(instance, props) {
-  const mutexResolve = await mutexAcquire(instance, "setup");
-  if (instance.state !== APP_INSTANCE_STATE.INIT) {
-    mutexResolve();
-    return {
-      skip: true,
-      code: "setup_app",
-      reason: `application in ${instance.state} state`
-    };
-  }
-  setState$1(instance, APP_INSTANCE_STATE.IN_SETUP);
-  const { setup } = instance.definition;
-  if (isFunction(setup)) {
-    try {
-      const setupResult = await setup.call(instance.setupState, props);
-      Object.assign(instance.setupState, setupResult);
-    } catch (error) {
-      setState$1(instance, APP_INSTANCE_STATE.ERROR);
-      mutexResolve();
-      return {
-        code: "setup_app",
-        skip: true,
-        reason: "setup function throw error",
-        error: toError(error)
-      };
-    }
-  }
-  instance.props = props;
-  setState$1(instance, APP_INSTANCE_STATE.SETUP);
-  mutexResolve();
-  return {
-    success: true,
-    code: "setup_app"
-  };
-}
-async function runApp$1(instance) {
-  const mutexResolve = await mutexAcquire(instance, "run");
-  if (instance.state !== APP_INSTANCE_STATE.SETUP) {
-    mutexResolve();
-    return {
-      skip: true,
-      code: "execute_app",
-      reason: `application in ${instance.state} state`
-    };
-  }
-  const { entry } = instance.definition;
-  setState$1(instance, APP_INSTANCE_STATE.IN_RUN);
-  instance.logger.info("Starting...");
-  if (isFunction(entry)) {
-    try {
-      await entry.call(instance.setupState, instance.props);
-    } catch (error) {
-      setState$1(instance, APP_INSTANCE_STATE.ERROR);
-      mutexResolve();
-      return {
-        skip: true,
-        code: "execute_app",
-        reason: "entry function throw error",
-        error: toError(error)
-      };
-    }
-  }
-  setState$1(instance, APP_INSTANCE_STATE.RUN);
-  mutexResolve();
-  instance.logger.info("Started");
-  return {
-    success: true,
-    code: "execute_app"
-  };
-}
-async function stopApp(instance) {
-  const mutexResolve = await mutexAcquire(instance, "stop");
-  if (instance.state !== APP_INSTANCE_STATE.RUN) {
-    mutexResolve();
-    return {
-      skip: true,
-      code: "stop_app",
-      reason: `application in ${instance.state} state`
-    };
-  }
-  const { stop } = instance.definition;
-  setState$1(instance, APP_INSTANCE_STATE.IN_STOP);
-  instance.logger.info("Stopping...");
-  let stopErr;
-  if (isFunction(stop)) {
-    try {
-      await stop.call(instance.setupState, instance.props);
-    } catch (err) {
-      setState$1(instance, APP_INSTANCE_STATE.ERROR);
-      stopErr = toError(err);
-    }
-  }
-  mutexResolve();
-  if (stopErr) {
-    return {
-      skip: true,
-      code: "stop_app",
-      reason: "stop function throw error",
-      error: stopErr
-    };
-  }
-  setState$1(instance, APP_INSTANCE_STATE.STOP);
-  instance.logger.info("Stopped");
-  return {
-    success: true,
-    code: "stop_app"
-  };
-}
-async function shutdownApp(instance) {
-  await stopApp(instance);
-  const mutexResolve = await mutexAcquire(instance, "shutdown");
-  if (instance.state !== APP_INSTANCE_STATE.STOP && instance.state !== APP_INSTANCE_STATE.SETUP && instance.state !== APP_INSTANCE_STATE.ERROR) {
-    mutexResolve();
-    return {
-      skip: true,
-      code: "shutdown_app",
-      reason: `application in ${instance.state} state`
-    };
-  }
-  const { shutdown } = instance.definition;
-  setState$1(instance, APP_INSTANCE_STATE.IN_SHUTDOWN);
-  instance.logger.info("Shutdown...");
-  let shutdownErr;
-  if (isFunction(shutdown)) {
-    try {
-      await shutdown.call(instance.setupState, instance.props);
-    } catch (err) {
-      shutdownErr = toError(err);
-    }
-  }
-  instance.props = null;
-  instance.setupState = createSetupState(instance.definition);
-  mutexResolve();
-  if (shutdownErr) {
-    setState$1(instance, APP_INSTANCE_STATE.ERROR);
-    return {
-      skip: true,
-      code: "shutdown_app",
-      reason: "shutdown function throw error",
-      error: shutdownErr
-    };
-  }
-  setState$1(instance, APP_INSTANCE_STATE.SHUTDOWN);
-  return {
-    success: true,
-    code: "shutdown_app"
-  };
+	return value?.[APP_DEF] === true;
+}
+function startApp(app, props) {
+	const instance = isAppDefinition(app) ? createAppInstance(app) : app;
+	return setupApp(instance, props).then((setupResult) => {
+		if (isSkip(setupResult)) return setupResult;
+		return runApp(instance).then((runResult) => {
+			if (isSkip(runResult)) return shutdownApp(instance).then(() => runResult);
+			return {
+				success: true,
+				code: "start_app",
+				app: instance
+			};
+		});
+	});
+}
+function setupApp(instance, props) {
+	return mutexAcquire(instance, "setup").then((mutexResolve) => {
+		if (instance.state !== APP_INSTANCE_STATE.INIT) {
+			mutexResolve();
+			return {
+				skip: true,
+				code: "setup_app",
+				reason: `application in ${instance.state} state`
+			};
+		}
+		setState$1(instance, APP_INSTANCE_STATE.IN_SETUP);
+		const { setup } = instance.definition;
+		let setupPromise = Promise.resolve();
+		if (isFunction(setup)) setupPromise = setupPromise.then(() => setup.call(instance.setupState, props)).then((setupResult) => void Object.assign(instance.setupState, setupResult));
+		return setupPromise.then(() => {
+			instance.props = props;
+			setState$1(instance, APP_INSTANCE_STATE.SETUP);
+			return {
+				success: true,
+				code: "setup_app"
+			};
+		}).catch((error) => {
+			setState$1(instance, APP_INSTANCE_STATE.ERROR);
+			return {
+				code: "setup_app",
+				skip: true,
+				reason: "setup function throw error",
+				error: toError(error)
+			};
+		}).finally(() => mutexResolve());
+	});
+}
+function runApp(instance) {
+	return mutexAcquire(instance, "run").then((mutexResolve) => {
+		if (instance.state !== APP_INSTANCE_STATE.SETUP) {
+			mutexResolve();
+			return {
+				skip: true,
+				code: "execute_app",
+				reason: `application in ${instance.state} state`
+			};
+		}
+		const { entry } = instance.definition;
+		setState$1(instance, APP_INSTANCE_STATE.IN_RUN);
+		instance.logger.info("Starting...");
+		let entryPromise = Promise.resolve();
+		if (isFunction(entry)) entryPromise = entryPromise.then(() => entry.call(instance.setupState, instance.props));
+		return entryPromise.then(() => {
+			setState$1(instance, APP_INSTANCE_STATE.RUN);
+			instance.logger.info("Started");
+			return {
+				success: true,
+				code: "execute_app"
+			};
+		}).catch((error) => {
+			setState$1(instance, APP_INSTANCE_STATE.ERROR);
+			return {
+				skip: true,
+				code: "execute_app",
+				reason: "entry function throw error",
+				error: toError(error)
+			};
+		}).finally(() => mutexResolve());
+	});
+}
+function stopApp(instance) {
+	return mutexAcquire(instance, "stop").then((mutexResolve) => {
+		if (instance.state !== APP_INSTANCE_STATE.RUN) {
+			mutexResolve();
+			return {
+				skip: true,
+				code: "stop_app",
+				reason: `application in ${instance.state} state`
+			};
+		}
+		const { stop } = instance.definition;
+		setState$1(instance, APP_INSTANCE_STATE.IN_STOP);
+		instance.logger.info("Stopping...");
+		let stopPromise = Promise.resolve();
+		if (isFunction(stop)) stopPromise = stopPromise.then(() => stop.call(instance.setupState, instance.props));
+		return stopPromise.then(() => {
+			setState$1(instance, APP_INSTANCE_STATE.STOP);
+			instance.logger.info("Stopped");
+			return {
+				success: true,
+				code: "stop_app"
+			};
+		}).catch((err) => {
+			setState$1(instance, APP_INSTANCE_STATE.ERROR);
+			return {
+				skip: true,
+				code: "stop_app",
+				reason: "stop function throw error",
+				error: toError(err)
+			};
+		}).finally(() => mutexResolve());
+	});
+}
+function shutdownApp(instance) {
+	return stopApp(instance).then(() => mutexAcquire(instance, "shutdown")).then((mutexResolve) => {
+		if (instance.state !== APP_INSTANCE_STATE.STOP && instance.state !== APP_INSTANCE_STATE.SETUP && instance.state !== APP_INSTANCE_STATE.ERROR) {
+			mutexResolve();
+			return {
+				skip: true,
+				code: "shutdown_app",
+				reason: `application in ${instance.state} state`
+			};
+		}
+		const { shutdown } = instance.definition;
+		setState$1(instance, APP_INSTANCE_STATE.IN_SHUTDOWN);
+		instance.logger.info("Shutdown...");
+		let shutdownPromise = Promise.resolve();
+		if (isFunction(shutdown)) shutdownPromise = shutdownPromise.then(() => shutdown.call(instance.setupState, instance.props));
+		return shutdownPromise.then(() => {
+			setState$1(instance, APP_INSTANCE_STATE.SHUTDOWN);
+			return {
+				success: true,
+				code: "shutdown_app"
+			};
+		}).catch((shutdownErr) => {
+			setState$1(instance, APP_INSTANCE_STATE.ERROR);
+			return {
+				skip: true,
+				code: "shutdown_app",
+				reason: "shutdown function throw error",
+				error: shutdownErr
+			};
+		}).finally(() => {
+			instance.props = null;
+			instance.setupState = createSetupState(instance.definition);
+			mutexResolve();
+		});
+	});
 }
 function appWaitShutdown(instance) {
-  if (instance.state === APP_INSTANCE_STATE.SHUTDOWN) {
-    return Promise.resolve();
-  }
-  const q = defer();
-  instance.eventBus.once("state:shutdown", q.resolve);
-  instance.eventBus.once("error", q.reject);
-  return q.promise.finally(() => {
-    instance.eventBus.off("state:shutdown", q.resolve);
-    instance.eventBus.off("error", q.reject);
-  });
+	if (instance.state === APP_INSTANCE_STATE.SHUTDOWN) return Promise.resolve();
+	const q = defer();
+	instance.eventBus.once("state:shutdown", q.resolve);
+	instance.eventBus.once("error", q.reject);
+	return q.promise.finally(() => {
+		instance.eventBus.off("state:shutdown", q.resolve);
+		instance.eventBus.off("error", q.reject);
+	});
 }
 function createSetupState(definition) {
-  const setupState = {
-    log: createAppLogger(definition)
-  };
-  if (definition.methods) {
-    for (const [key, fn] of Object.entries(definition.methods)) {
-      setupState[key] = fn.bind(setupState);
-    }
-  }
-  return setupState;
+	const setupState = { log: createAppLogger(definition) };
+	if (definition.methods) for (const [key, fn] of Object.entries(definition.methods)) setupState[key] = fn.bind(setupState);
+	return setupState;
 }
 function mutexAcquire(instance, name) {
-  let outerResolve;
-  const acquirePromise = new Promise((res) => {
-    outerResolve = res;
-  });
-  instance.mutexQueue = instance.mutexQueue.then(
-    () => new Promise((innerResolve) => {
-      instance.mutexName = name;
-      outerResolve(() => {
-        instance.mutexName = null;
-        innerResolve();
-      });
-    })
-  );
-  return acquirePromise;
+	let outerResolve;
+	const acquirePromise = new Promise((res) => {
+		outerResolve = res;
+	});
+	instance.mutexQueue = instance.mutexQueue.then(() => new Promise((innerResolve) => {
+		instance.mutexName = name;
+		outerResolve(() => {
+			instance.mutexName = null;
+			innerResolve();
+		});
+	}));
+	return acquirePromise;
 }
 function setState$1(app, newState) {
-  const oldState = app.state;
-  if (newState !== oldState) {
-    app.state = newState;
-    app.eventBus.emit("state", newState, oldState);
-    app.eventBus.emit(`state:${newState}`);
-  }
+	const oldState = app.state;
+	if (newState !== oldState) {
+		app.state = newState;
+		app.eventBus.emit("state", newState, oldState);
+		app.eventBus.emit(`state:${newState}`);
+	}
 }
-
 function createAppHub(definitions) {
-  const app = defineApp({
-    name: "app-hub",
-    description: `Application wrapper around: ${definitions.map((v) => v.name).join(", ")}`,
-    logger: false,
-    props: prefixifyProps(definitions),
-    setup(props) {
-      const instances = [];
-      const setupSkips = [];
-      return asyncForEach(definitions, (definition) => {
-        const appProps = getPrefixedProps(definition, props);
-        const instance = createAppInstance(definition);
-        instances.push(instance);
-        return setupApp(instance, appProps).then((setupResult) => {
-          if (isSkip(setupResult)) {
-            setupSkips.push({ ...setupResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (setupSkips.length) {
-          throw skipExecsToError("setup", setupSkips);
-        }
-        return { instances };
-      });
-    },
-    entry() {
-      const runSkips = [];
-      return asyncForEach(this.instances, (instance) => {
-        return runApp$1(instance).then((runResult) => {
-          if (isSkip(runResult)) {
-            runSkips.push({ ...runResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (runSkips.length) {
-          throw skipExecsToError("start", runSkips);
-        }
-      });
-    },
-    stop() {
-      const stopSkips = [];
-      return asyncForEach(this.instances, (instance) => {
-        return stopApp(instance).then((stopResult) => {
-          if (isSkip(stopResult)) {
-            stopSkips.push({ ...stopResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (stopSkips.length) {
-          throw skipExecsToError("stop", stopSkips);
-        }
-      });
-    },
-    shutdown() {
-      const shutdownSkips = [];
-      return asyncForEach(this.instances, (instance) => {
-        return shutdownApp(instance).then((shutdownResult) => {
-          if (isSkip(shutdownResult)) {
-            shutdownSkips.push({ ...shutdownResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (shutdownSkips.length) {
-          throw skipExecsToError("shutdown", shutdownSkips);
-        }
-      });
-    }
-  });
-  return app;
+	return defineApp({
+		name: "app-hub",
+		description: `Application wrapper around: ${definitions.map((v) => v.name).join(", ")}`,
+		logger: false,
+		props: prefixifyProps(definitions),
+		setup(props) {
+			const instances = [];
+			const setupSkips = [];
+			return asyncForEach(definitions, (definition) => {
+				const appProps = getPrefixedProps(definition, props);
+				const instance = createAppInstance(definition);
+				instances.push(instance);
+				return setupApp(instance, appProps).then((setupResult) => {
+					if (isSkip(setupResult)) setupSkips.push({
+						...setupResult,
+						app: instance
+					});
+				});
+			}).then(() => {
+				if (setupSkips.length) throw skipExecsToError("setup", setupSkips);
+				return { instances };
+			});
+		},
+		entry() {
+			const runSkips = [];
+			return asyncForEach(this.instances, (instance) => {
+				return runApp(instance).then((runResult) => {
+					if (isSkip(runResult)) runSkips.push({
+						...runResult,
+						app: instance
+					});
+				});
+			}).then(() => {
+				if (runSkips.length) throw skipExecsToError("start", runSkips);
+			});
+		},
+		stop() {
+			const stopSkips = [];
+			return asyncForEach(this.instances, (instance) => {
+				return stopApp(instance).then((stopResult) => {
+					if (isSkip(stopResult)) stopSkips.push({
+						...stopResult,
+						app: instance
+					});
+				});
+			}).then(() => {
+				if (stopSkips.length) throw skipExecsToError("stop", stopSkips);
+			});
+		},
+		shutdown() {
+			const shutdownSkips = [];
+			return asyncForEach(this.instances, (instance) => {
+				return shutdownApp(instance).then((shutdownResult) => {
+					if (isSkip(shutdownResult)) shutdownSkips.push({
+						...shutdownResult,
+						app: instance
+					});
+				});
+			}).then(() => {
+				if (shutdownSkips.length) throw skipExecsToError("shutdown", shutdownSkips);
+			});
+		}
+	});
 }
 function skipExecsToError(verb, skips) {
-  const getError = (r) => {
-    if ("error" in r && isError(r.error)) {
-      return r.error.stack ? `
-${r.error.message}
-${r.error.stack}` : `
-${r.error.message}`;
-    }
-    return "";
-  };
-  const lines = skips.map(
-    (s) => s.reason ? `  ${s.app.definition.name} [${s.code}]: ${s.reason}${getError(s).replaceAll("\n", "\n    ")}` : `  ${s.app.definition.name} [${s.code}]${getError(s).replaceAll("\n", "\n    ")}`
-  );
-  return new Error(
-    `Failed to ${verb} ${skips.length} app(s):
-${lines.join("\n")}`,
-    { cause: "error" in skips[0] ? skips[0].error : void 0 }
-  );
+	const getError = (r) => {
+		if ("error" in r && isError(r.error)) return r.error.stack ? `\n${r.error.message}\n${r.error.stack}` : `\n${r.error.message}`;
+		return "";
+	};
+	const lines = skips.map((s) => s.reason ? `  ${s.app.definition.name} [${s.code}]: ${s.reason}${getError(s).replaceAll("\n", "\n    ")}` : `  ${s.app.definition.name} [${s.code}]${getError(s).replaceAll("\n", "\n    ")}`);
+	return new Error(`Failed to ${verb} ${skips.length} app(s):\n${lines.join("\n")}`, { cause: "error" in skips[0] ? skips[0].error : void 0 });
 }
 function getPrefixedProps(definition, props) {
-  const result = pickPrefixed(props, {
-    prefix: camelCase(definition.name),
-    prefixTrim: true
-  });
-  for (const [key, value] of Object.entries(result)) {
-    const propName = key.charAt(0).toLowerCase() + key.slice(1).toLowerCase();
-    result[propName] = value;
-    delete result[key];
-  }
-  return result;
+	const result = pickPrefixed(props, {
+		prefix: camelCase(definition.name),
+		prefixTrim: true
+	});
+	for (const [key, value] of Object.entries(result)) {
+		const propName = key.charAt(0).toLowerCase() + key.slice(1).toLowerCase();
+		result[propName] = value;
+		delete result[key];
+	}
+	return result;
 }
 function prefixifyProps(definitions) {
-  const props = {};
-  for (const definition of definitions) {
-    if (definition.props) {
-      for (const [propName, prop] of Object.entries(definition.props)) {
-        props[camelCase(`${definition.name}${capitalize(propName)}`)] = prop;
-      }
-    }
-  }
-  return props;
+	const props = {};
+	for (const definition of definitions) if (definition.props) for (const [propName, prop] of Object.entries(definition.props)) props[camelCase(`${definition.name}${capitalize(propName)}`)] = prop;
+	return props;
 }
-
 const MAX_RESTARTS = 3;
 const HEARTBEAT_INTERVAL_MS = 5e3;
 const HEARTBEAT_TIMEOUT_MS = 1e4;
@@ -589,2036 +497,1806 @@ onShutdown('app', async () => {
 });
 `;
 function setState(w, next) {
-  const prev = w.state;
-  if (prev === next) return;
-  w.state = next;
-  w.writeLog("debug", "state", { from: prev, to: next });
-  w.eventBus.emit("state", next, prev);
+	const prev = w.state;
+	if (prev === next) return;
+	w.state = next;
+	w.writeLog("debug", "state", {
+		from: prev,
+		to: next
+	});
+	w.eventBus.emit("state", next, prev);
 }
 function spawnChild(w) {
-  w.writeLog("debug", "thread.spawn.start", {
-    script: path.basename(w.scriptFile),
-    thread: w.threadId
-  });
-  setState(w, "init");
-  const child = cp.spawn(
-    process.execPath,
-    ["--input-type=module", "-e", bootstrapCode],
-    {
-      stdio: w.threadProps.__inheritIO !== false ? ["pipe", "inherit", "inherit", "ipc"] : ["pipe", "pipe", "pipe", "ipc"],
-      env: {
-        ...process.env,
-        VRUN_PROCESS_SCRIPT_FILE: w.scriptFile,
-        VRUN_PROCESS_ID: String(w.threadId)
-      }
-    }
-  );
-  w.child = child;
-  const onData = (chunk) => {
-    const text = chunk.toString("utf8");
-    for (const line of text.split(/\r?\n/)) {
-      if (line.length === 0) continue;
-      w.eventBus.emit("log", parseRawLogLine(line));
-    }
-  };
-  child.stdout?.on("data", onData);
-  child.stderr?.on("data", onData);
-  child.on("message", (msg) => {
-    if (isThreadMessage(msg)) {
-      w.eventBus.emit("message", msg);
-      w.eventBus.emit(`msg:${msg.type}`, msg);
-    }
-  });
-  child.once("exit", (code, signal) => {
-    w.eventBus.emit("exit", code, signal);
-  });
-  child.on("error", (err) => {
-    w.writeLog("error", "thread.spawn.error", { message: err.message });
-    w.eventBus.emit("error", err);
-  });
+	w.writeLog("debug", "thread.spawn.start", {
+		script: path.basename(w.scriptFile),
+		thread: w.threadId
+	});
+	setState(w, "init");
+	const child = cp.spawn(process.execPath, [
+		"--input-type=module",
+		"-e",
+		bootstrapCode
+	], {
+		stdio: w.threadProps.__inheritIO !== false ? [
+			"pipe",
+			"inherit",
+			"inherit",
+			"ipc"
+		] : [
+			"pipe",
+			"pipe",
+			"pipe",
+			"ipc"
+		],
+		env: {
+			...process.env,
+			VRUN_PROCESS_SCRIPT_FILE: w.scriptFile,
+			VRUN_PROCESS_ID: String(w.threadId)
+		}
+	});
+	w.child = child;
+	const onData = (chunk) => {
+		const text = chunk.toString("utf8");
+		for (const line of text.split(/\r?\n/)) {
+			if (line.length === 0) continue;
+			w.eventBus.emit("log", parseRawLogLine(line));
+		}
+	};
+	child.stdout?.on("data", onData);
+	child.stderr?.on("data", onData);
+	child.on("message", (msg) => {
+		if (isThreadMessage(msg)) {
+			w.eventBus.emit("message", msg);
+			w.eventBus.emit(`msg:${msg.type}`, msg);
+		}
+	});
+	child.once("exit", (code, signal) => {
+		w.eventBus.emit("exit", code, signal);
+	});
+	child.on("error", (err) => {
+		w.writeLog("error", "thread.spawn.error", { message: err.message });
+		w.eventBus.emit("error", err);
+	});
 }
 function startHeartbeat(w) {
-  w.lastPong = Date.now();
-  w.heartbeatTimer = setInterval(() => {
-    if (w.state !== APP_INSTANCE_STATE.RUN) {
-      clearInterval(w.heartbeatTimer);
-      return;
-    }
-    const since = Date.now() - w.lastPong;
-    if (since > HEARTBEAT_TIMEOUT_MS) {
-      clearInterval(w.heartbeatTimer);
-      w.writeLog("warn", "heartbeat.miss", { since_ms: since });
-      restartThreadApp(w).catch((err) => w.eventBus.emit("error", err));
-      return;
-    }
-    if (w.child.connected) {
-      w.child.send(createThreadMessage("ping", {}));
-    }
-  }, HEARTBEAT_INTERVAL_MS);
+	w.lastPong = Date.now();
+	w.heartbeatTimer = setInterval(() => {
+		if (w.state !== APP_INSTANCE_STATE.RUN) {
+			clearInterval(w.heartbeatTimer);
+			return;
+		}
+		const since = Date.now() - w.lastPong;
+		if (since > HEARTBEAT_TIMEOUT_MS) {
+			clearInterval(w.heartbeatTimer);
+			w.writeLog("warn", "heartbeat.miss", { since_ms: since });
+			restartThreadApp(w).catch((err) => w.eventBus.emit("error", err));
+			return;
+		}
+		if (w.child.connected) w.child.send(createThreadMessage("ping", {}));
+	}, HEARTBEAT_INTERVAL_MS);
 }
 function waitForExit(w, timeoutMs) {
-  if (isThreadExit(w)) {
-    return Promise.resolve();
-  }
-  return new Promise((resolve) => {
-    w.writeLog("info", "thread.exit.waiting", { timeout_ms: timeoutMs });
-    const cleanup = () => {
-      clearTimeout(slowTimer);
-      clearTimeout(killTimer);
-      w.child.off("exit", onExit);
-    };
-    const onExit = () => {
-      cleanup();
-      resolve();
-    };
-    const halfway = Math.floor(timeoutMs / 2);
-    const slowTimer = setTimeout(() => {
-      w.writeLog("warn", "thread.exit.slow", { elapsed_ms: halfway });
-    }, halfway);
-    const killTimer = setTimeout(() => {
-      cleanup();
-      try {
-        w.writeLog("warn", "thread.exit.force-kill", { timeout_ms: timeoutMs });
-        w.child.kill("SIGKILL");
-      } catch {
-      }
-      resolve();
-    }, timeoutMs);
-    w.child.once("exit", onExit);
-  });
+	if (isThreadExit(w)) return Promise.resolve();
+	return new Promise((resolve) => {
+		w.writeLog("info", "thread.exit.waiting", { timeout_ms: timeoutMs });
+		const cleanup = () => {
+			clearTimeout(slowTimer);
+			clearTimeout(killTimer);
+			w.child.off("exit", onExit);
+		};
+		const onExit = () => {
+			cleanup();
+			resolve();
+		};
+		const halfway = Math.floor(timeoutMs / 2);
+		const slowTimer = setTimeout(() => {
+			w.writeLog("warn", "thread.exit.slow", { elapsed_ms: halfway });
+		}, halfway);
+		const killTimer = setTimeout(() => {
+			cleanup();
+			try {
+				w.writeLog("warn", "thread.exit.force-kill", { timeout_ms: timeoutMs });
+				w.child.kill("SIGKILL");
+			} catch {}
+			resolve();
+		}, timeoutMs);
+		w.child.once("exit", onExit);
+	});
 }
 function waitForThreadReady(w) {
-  if (w.state === "ready") {
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      w.eventBus.off("ready", onReady);
-      w.eventBus.off("error", onError);
-      w.eventBus.off("exit", onExit);
-    };
-    const onReady = () => {
-      resolve();
-      cleanup();
-    };
-    const onExit = (code) => {
-      reject(new Error(`Child exited before ready (code=${code ?? "null"})`));
-      cleanup();
-    };
-    const onError = (error) => {
-      reject(error);
-      cleanup();
-    };
-    w.eventBus.once("ready", onReady);
-    w.eventBus.once("error", onError);
-    w.eventBus.once("exit", onExit);
-  });
+	if (w.state === "ready") return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			w.eventBus.off("ready", onReady);
+			w.eventBus.off("error", onError);
+			w.eventBus.off("exit", onExit);
+		};
+		const onReady = () => {
+			resolve();
+			cleanup();
+		};
+		const onExit = (code) => {
+			reject(/* @__PURE__ */ new Error(`Child exited before ready (code=${code ?? "null"})`));
+			cleanup();
+		};
+		const onError = (error) => {
+			reject(error);
+			cleanup();
+		};
+		w.eventBus.once("ready", onReady);
+		w.eventBus.once("error", onError);
+		w.eventBus.once("exit", onExit);
+	});
 }
 function sendAndWait(w, message, replyType, timeout = 3e4) {
-  return new Promise((resolve) => {
-    const eventName = `msg:${replyType}`;
-    const cleanup = () => {
-      w.eventBus.off(eventName, onReply);
-      w.eventBus.off("exit", onExit);
-      clearTimeout(timer);
-    };
-    const timer = setTimeout(() => {
-      cleanup();
-      w.writeLog("error", "parent.ipc.timeout", {
-        waiting: replyType,
-        ms: timeout
-      });
-      resolve({
-        skip: true,
-        code: "parent.ipc.timeout",
-        reason: `Thread ${path.basename(w.scriptFile)} timed out waiting for "${replyType}"`
-      });
-    }, timeout);
-    const onReply = (reply) => {
-      cleanup();
-      resolve({
-        success: true,
-        code: "parent.ipc.recv",
-        reply
-      });
-    };
-    const onExit = () => {
-      const reason = `thread.exit (code=${w.child.exitCode} signal=${w.child.signalCode ?? "null"})`;
-      w.writeLog("debug", "parent.ipc.skipped", {
-        waiting: replyType,
-        reason
-      });
-      resolve({ skip: true, code: "thread.exit", reason });
-      return;
-    };
-    if (isThreadExit(w)) {
-      return void onExit();
-    }
-    w.eventBus.once("exit", onExit);
-    w.eventBus.once(eventName, onReply);
-    w.writeLog("debug", "parent.ipc.send", message);
-    try {
-      w.child.send(message);
-    } catch (err) {
-      const error = toError(err);
-      w.writeLog("error", "parent.ipc.fail", {
-        message,
-        error: error.message
-      });
-      cleanup();
-      resolve({
-        skip: true,
-        code: "parent.ipc.fail",
-        reason: error.message
-      });
-    }
-  });
+	return new Promise((resolve) => {
+		const eventName = `msg:${replyType}`;
+		const cleanup = () => {
+			w.eventBus.off(eventName, onReply);
+			w.eventBus.off("exit", onExit);
+			clearTimeout(timer);
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			w.writeLog("error", "parent.ipc.timeout", {
+				waiting: replyType,
+				ms: timeout
+			});
+			resolve({
+				skip: true,
+				code: "parent.ipc.timeout",
+				reason: `Thread ${path.basename(w.scriptFile)} timed out waiting for "${replyType}"`
+			});
+		}, timeout);
+		const onReply = (reply) => {
+			cleanup();
+			resolve({
+				success: true,
+				code: "parent.ipc.recv",
+				reply
+			});
+		};
+		const onExit = () => {
+			const reason = `thread.exit (code=${w.child.exitCode} signal=${w.child.signalCode ?? "null"})`;
+			w.writeLog("debug", "parent.ipc.skipped", {
+				waiting: replyType,
+				reason
+			});
+			resolve({
+				skip: true,
+				code: "thread.exit",
+				reason
+			});
+		};
+		if (isThreadExit(w)) {
+			onExit();
+			return;
+		}
+		w.eventBus.once("exit", onExit);
+		w.eventBus.once(eventName, onReply);
+		w.writeLog("debug", "parent.ipc.send", message);
+		try {
+			w.child.send(message);
+		} catch (err) {
+			const error = toError(err);
+			w.writeLog("error", "parent.ipc.fail", {
+				message,
+				error: error.message
+			});
+			cleanup();
+			resolve({
+				skip: true,
+				code: "parent.ipc.fail",
+				reason: error.message
+			});
+		}
+	});
 }
 function initThread(threadId, scriptFile, threadProps) {
-  const w = {
-    threadId,
-    scriptFile,
-    threadProps,
-    pid: 0,
-    state: APP_INSTANCE_STATE.INIT,
-    restartCount: 0,
-    lastPong: 0,
-    child: null,
-    scheduler: new Scheduler(),
-    eventBus: new EventEmitter(),
-    writeLog(level, event, fields) {
-      w.eventBus.emit("log", {
-        level,
-        text: formatLogEvent(event, fields),
-        ts: Date.now()
-      });
-    }
-  };
-  w.eventBus.setMaxListeners(0);
-  const onJobPhase = (phase) => (job) => {
-    w.writeLog("debug", `job.${job.jobName ?? "untitled"}.${phase}`);
-  };
-  w.scheduler.onJob(onJobPhase("queue"));
-  w.scheduler.onJobStart(onJobPhase("start"));
-  w.scheduler.onJobComplete(onJobPhase("done"));
-  w.eventBus.on("exit", (code, signal) => {
-    const prevState = w.state;
-    if (signal) {
-      w.writeLog("warn", "thread.exit.signal", { signal, code });
-    } else if (code === 0 || code === null) {
-      w.writeLog("info", "thread.exit.clean", { code });
-    } else {
-      w.writeLog("error", "thread.exit.crash", { code });
-    }
-    setState(w, "shutdown");
-    clearInterval(w.heartbeatTimer);
-    w.pid = 0;
-    if (prevState === APP_INSTANCE_STATE.RUN && !isShuttingDown()) {
-      restartThreadApp(w).catch((err) => w.eventBus.emit("error", err));
-    }
-  });
-  w.eventBus.on("message", (msg) => {
-    w.writeLog("debug", "parent.ipc.recv", msg);
-    switch (msg.type) {
-      case "app-state": {
-        setState(w, msg.state);
-        break;
-      }
-      case "ready": {
-        w.pid = msg.pid;
-        w.eventBus.emit("pid", msg.pid);
-        setState(w, "ready");
-        w.writeLog("debug", "thread.spawn.ready");
-        w.eventBus.emit("ready");
-        break;
-      }
-      case "pong": {
-        w.lastPong = Date.now();
-        break;
-      }
-    }
-  });
-  spawnChild(w);
-  return w;
+	const w = {
+		threadId,
+		scriptFile,
+		threadProps,
+		pid: 0,
+		state: APP_INSTANCE_STATE.INIT,
+		restartCount: 0,
+		lastPong: 0,
+		child: null,
+		scheduler: new Scheduler(),
+		eventBus: new EventEmitter(),
+		writeLog(level, event, fields) {
+			w.eventBus.emit("log", {
+				level,
+				text: formatLogEvent(event, fields),
+				ts: Date.now()
+			});
+		}
+	};
+	w.eventBus.setMaxListeners(0);
+	const onJobPhase = (phase) => (job) => {
+		w.writeLog("debug", `job.${job.jobName ?? "untitled"}.${phase}`);
+	};
+	w.scheduler.onJob(onJobPhase("queue"));
+	w.scheduler.onJobStart(onJobPhase("start"));
+	w.scheduler.onJobComplete(onJobPhase("done"));
+	w.eventBus.on("exit", (code, signal) => {
+		const prevState = w.state;
+		if (signal) w.writeLog("warn", "thread.exit.signal", {
+			signal,
+			code
+		});
+		else if (code === 0 || code === null) w.writeLog("info", "thread.exit.clean", { code });
+		else w.writeLog("error", "thread.exit.crash", { code });
+		setState(w, "shutdown");
+		clearInterval(w.heartbeatTimer);
+		w.pid = 0;
+		if (prevState === APP_INSTANCE_STATE.RUN && !isShuttingDown()) restartThreadApp(w).catch((err) => w.eventBus.emit("error", err));
+	});
+	w.eventBus.on("message", (msg) => {
+		w.writeLog("debug", "parent.ipc.recv", msg);
+		switch (msg.type) {
+			case "app-state":
+				setState(w, msg.state);
+				break;
+			case "ready":
+				w.pid = msg.pid;
+				w.eventBus.emit("pid", msg.pid);
+				setState(w, "ready");
+				w.writeLog("debug", "thread.spawn.ready");
+				w.eventBus.emit("ready");
+				break;
+			case "pong":
+				w.lastPong = Date.now();
+				break;
+		}
+	});
+	spawnChild(w);
+	return w;
 }
 function withLifecycle(w, phase, fn) {
-  w.writeLog("debug", `lifecycle.${phase}.begin`);
-  return fn().then(
-    (result) => {
-      w.writeLog("debug", `lifecycle.${phase}.done`);
-      return result;
-    },
-    (error) => {
-      w.writeLog("error", `lifecycle.${phase}.fail`, {
-        message: String(error && error.message || error)
-      });
-      throw error;
-    }
-  );
+	w.writeLog("debug", `lifecycle.${phase}.begin`);
+	return fn().then((result) => {
+		w.writeLog("debug", `lifecycle.${phase}.done`);
+		return result;
+	}, (error) => {
+		w.writeLog("error", `lifecycle.${phase}.fail`, { message: String(error && error.message || error) });
+		throw error;
+	});
 }
 function setupThreadApp(w) {
-  return w.scheduler.queueJobWait(
-    () => withLifecycle(w, "setupThreadApp", () => doSetupThread(w)),
-    { jobName: "setupThreadApp" }
-  );
+	return w.scheduler.queueJobWait(() => withLifecycle(w, "setupThreadApp", () => doSetupThread(w)), { jobName: "setupThreadApp" });
 }
 function doSetupThread(w) {
-  setState(w, APP_INSTANCE_STATE.IN_SETUP);
-  return sendAndWait(
-    w,
-    createThreadMessage("setup", {
-      props: w.threadProps
-    }),
-    "setup_done"
-  ).then(noop);
+	setState(w, APP_INSTANCE_STATE.IN_SETUP);
+	return sendAndWait(w, createThreadMessage("setup", { props: w.threadProps }), "setup_done").then(noop);
 }
 function startThreadApp(w) {
-  return w.scheduler.queueJobWait(
-    () => withLifecycle(w, "startThreadApp", () => doStartThreadApp(w)),
-    { jobName: "startThreadApp" }
-  );
+	return w.scheduler.queueJobWait(() => withLifecycle(w, "startThreadApp", () => doStartThreadApp(w)), { jobName: "startThreadApp" });
 }
 function doStartThreadApp(w) {
-  setState(w, APP_INSTANCE_STATE.IN_RUN);
-  return sendAndWait(w, createThreadMessage("start", {}), "start_done").then(
-    () => {
-      if (w.state === APP_INSTANCE_STATE.RUN) {
-        startHeartbeat(w);
-      }
-    }
-  );
+	setState(w, APP_INSTANCE_STATE.IN_RUN);
+	return sendAndWait(w, createThreadMessage("start", {}), "start_done").then(() => {
+		if (w.state === APP_INSTANCE_STATE.RUN) startHeartbeat(w);
+	});
 }
 function stopThreadApp(w) {
-  return w.scheduler.queueJobWait(
-    () => withLifecycle(w, "stopThreadApp", () => doStopThreadApp(w)),
-    { jobName: "stopThreadApp" }
-  );
+	return w.scheduler.queueJobWait(() => withLifecycle(w, "stopThreadApp", () => doStopThreadApp(w)), { jobName: "stopThreadApp" });
 }
 function doStopThreadApp(w) {
-  setState(w, APP_INSTANCE_STATE.IN_STOP);
-  clearInterval(w.heartbeatTimer);
-  return sendAndWait(w, createThreadMessage("stop", {}), "stop_done").then(
-    noop
-  );
+	setState(w, APP_INSTANCE_STATE.IN_STOP);
+	clearInterval(w.heartbeatTimer);
+	return sendAndWait(w, createThreadMessage("stop", {}), "stop_done").then(noop);
 }
 function shutdownThreadApp(w) {
-  return w.scheduler.queueJobWait(
-    () => withLifecycle(w, "shutdownThreadApp", () => doShutdownThreadApp(w)),
-    { jobName: "shutdownThreadApp" }
-  );
+	return w.scheduler.queueJobWait(() => withLifecycle(w, "shutdownThreadApp", () => doShutdownThreadApp(w)), { jobName: "shutdownThreadApp" });
 }
 function doShutdownThreadApp(w) {
-  setState(w, "shutdown");
-  clearInterval(w.heartbeatTimer);
-  return (w.child.connected ? sendAndWait(
-    w,
-    createThreadMessage("shutdown", {}),
-    "shutdown_done",
-    SHUTDOWN_REPLY_TIMEOUT_MS
-  ) : Promise.resolve()).then(() => waitForExit(w, SHUTDOWN_EXIT_TIMEOUT_MS));
+	setState(w, "shutdown");
+	clearInterval(w.heartbeatTimer);
+	return (w.child.connected ? sendAndWait(w, createThreadMessage("shutdown", {}), "shutdown_done", SHUTDOWN_REPLY_TIMEOUT_MS) : Promise.resolve()).then(() => waitForExit(w, SHUTDOWN_EXIT_TIMEOUT_MS));
 }
 function restartThreadApp(w) {
-  if (w.restartCount >= MAX_RESTARTS) {
-    return Promise.reject(
-      new Error(`Thread ${w.threadId} exceeded max restarts (${MAX_RESTARTS})`)
-    );
-  }
-  return w.scheduler.queueJobWait(
-    () => withLifecycle(
-      w,
-      "restartThreadApp",
-      () => doShutdownThreadApp(w).then(() => {
-        w.restartCount++;
-        spawnChild(w);
-        return waitForThreadReady(w);
-      }).then(() => doSetupThread(w)).then(() => doStartThreadApp(w))
-    ),
-    { jobName: "restartThreadApp" }
-  );
+	if (w.restartCount >= MAX_RESTARTS) return Promise.reject(/* @__PURE__ */ new Error(`Thread ${w.threadId} exceeded max restarts (${MAX_RESTARTS})`));
+	return w.scheduler.queueJobWait(() => withLifecycle(w, "restartThreadApp", () => doShutdownThreadApp(w).then(() => {
+		w.restartCount++;
+		spawnChild(w);
+		return waitForThreadReady(w);
+	}).then(() => doSetupThread(w)).then(() => doStartThreadApp(w))), { jobName: "restartThreadApp" });
 }
 function isThreadMessage(value) {
-  return isObject(value) && !!value.vrun_app_thread_message;
+	return isObject(value) && !!value.vrun_app_thread_message;
 }
 function createThreadMessage(type, msg) {
-  return {
-    type,
-    ...msg,
-    vrun_app_thread_message: true
-  };
+	return {
+		type,
+		...msg,
+		vrun_app_thread_message: true
+	};
 }
 function parseRawLogLine(line) {
-  const trimmed = line.trimEnd();
-  const lower = trimmed.toLowerCase();
-  let level = "info";
-  if (lower.includes("error") || lower.includes("\u2716") || lower.includes("[error]")) {
-    level = "error";
-  } else if (lower.includes("warn") || lower.includes("\u26A0")) {
-    level = "warn";
-  } else if (lower.includes("debug") || lower.includes("\u2699")) {
-    level = "debug";
-  }
-  return { ts: Date.now(), level, text: trimmed };
+	const trimmed = line.trimEnd();
+	const lower = trimmed.toLowerCase();
+	let level = "info";
+	if (lower.includes("error") || lower.includes("✖") || lower.includes("[error]")) level = "error";
+	else if (lower.includes("warn") || lower.includes("⚠")) level = "warn";
+	else if (lower.includes("debug") || lower.includes("⚙")) level = "debug";
+	return {
+		ts: Date.now(),
+		level,
+		text: trimmed
+	};
 }
 function isThreadExit(w) {
-  return w.child.exitCode !== null || w.child.signalCode !== null || !w.child.connected;
+	return w.child.exitCode !== null || w.child.signalCode !== null || !w.child.connected;
 }
-
 function createAppThread(definition) {
-  const scriptFile = definition.filePath;
-  assert.ok(
-    scriptFile,
-    `Failed to detect definition file path for: ${definition.name}`
-  );
-  const app = defineApp({
-    name: definition.name,
-    description: definition.description,
-    props: {
-      ...definition.props || {},
-      threads: {
-        type: Number,
-        description: "Amount of threads",
-        default: () => 1,
-        parser: (v) => parseInt(v)
-      }
-    },
-    logger: false,
-    setup(props) {
-      const { threads = 1, ...threadProps } = props;
-      assert.greaterThan(threads, 0, "threads expected to be greater than 0");
-      const managedThreads = Array.from(
-        { length: threads },
-        (_, i) => initThread(i + 1, scriptFile, threadProps)
-      );
-      if (props.__inheritIO !== false) {
-        for (const w of managedThreads) {
-          const childLogger = createAppLogger({
-            ...definition,
-            name: `${definition.name}.${w.threadId}`
-          });
-          w.eventBus.on("log", (entry) => {
-            childLogger[entry.level](entry.text);
-          });
-        }
-      }
-      return Promise.all(managedThreads.map((w) => waitForThreadReady(w))).then(() => Promise.all(managedThreads.map((w) => setupThreadApp(w)))).then(() => ({ managedThreads }));
-    },
-    entry() {
-      return Promise.all(this.managedThreads.map((w) => startThreadApp(w))).then(
-        noop
-      );
-    },
-    stop() {
-      return Promise.all(this.managedThreads.map((w) => stopThreadApp(w))).then(
-        noop
-      );
-    },
-    shutdown() {
-      return Promise.all(
-        this.managedThreads.map((w) => shutdownThreadApp(w))
-      ).then(() => {
-        this.managedThreads = [];
-      });
-    }
-  });
-  return app;
-}
-function createAppThreadInstance({
-  definition,
-  parentPort,
-  threadId,
-  onShutdown = noop
-}) {
-  definition = { ...definition };
-  definition.name += "." + threadId;
-  const instance = createAppInstance(definition);
-  const log = instance.logger;
-  const postMessage = (message, cb) => {
-    log.debug(formatLogEvent("child.ipc.send", message));
-    parentPort.postMessage(message, cb);
-  };
-  instance.eventBus.on("state", (newState) => {
-    postMessage(createThreadMessage("app-state", { state: newState }));
-  });
-  parentPort.on("message", async (message) => {
-    if (!isThreadMessage(message)) return;
-    log.debug(formatLogEvent("child.ipc.recv", message));
-    switch (message.type) {
-      case "setup": {
-        const result = await setupApp(instance, message.props);
-        postMessage(createThreadMessage("setup_done", { result }));
-        break;
-      }
-      case "start": {
-        const result = await runApp$1(instance);
-        postMessage(createThreadMessage("start_done", { result }));
-        break;
-      }
-      case "stop": {
-        const result = await stopApp(instance);
-        postMessage(createThreadMessage("stop_done", { result }));
-        break;
-      }
-      case "shutdown": {
-        const result = await shutdownApp(instance);
-        postMessage(createThreadMessage("shutdown_done", { result }), () => {
-          setImmediate(() => {
-            catchError(onShutdown);
-            if (isFunction(parentPort.close)) {
-              parentPort.close();
-            }
-          });
-        });
-        break;
-      }
-      case "ping": {
-        postMessage(createThreadMessage("pong", {}));
-        break;
-      }
-    }
-  });
-  postMessage(
-    createThreadMessage("ready", {
-      pid: process.pid
-    })
-  );
-  return instance;
-}
-
-const TYPESCRIPT_EXTENSIONS = ["mts", "cts", "ts"];
-const JAVASCRIPT_EXTENSIONS = ["js", "mjs", "cjs"];
+	const scriptFile = definition.filePath;
+	assert.ok(scriptFile, `Failed to detect definition file path for: ${definition.name}`);
+	return defineApp({
+		name: definition.name,
+		description: definition.description,
+		props: {
+			...definition.props || {},
+			threads: {
+				type: Number,
+				description: "Amount of threads",
+				default: () => 1,
+				parser: (v) => parseInt(v)
+			}
+		},
+		logger: false,
+		setup(props) {
+			const { threads = 1, ...threadProps } = props;
+			assert.greaterThan(threads, 0, "threads expected to be greater than 0");
+			const managedThreads = Array.from({ length: threads }, (_, i) => initThread(i + 1, scriptFile, threadProps));
+			if (props.__inheritIO !== false) for (const w of managedThreads) {
+				const childLogger = createAppLogger({
+					...definition,
+					name: `${definition.name}.${w.threadId}`
+				});
+				w.eventBus.on("log", (entry) => {
+					childLogger[entry.level](entry.text);
+				});
+			}
+			return Promise.all(managedThreads.map((w) => waitForThreadReady(w))).then(() => Promise.all(managedThreads.map((w) => setupThreadApp(w)))).then(() => ({ managedThreads }));
+		},
+		entry() {
+			return Promise.all(this.managedThreads.map((w) => startThreadApp(w))).then(noop);
+		},
+		stop() {
+			return Promise.all(this.managedThreads.map((w) => stopThreadApp(w))).then(noop);
+		},
+		shutdown() {
+			return Promise.all(this.managedThreads.map((w) => shutdownThreadApp(w))).then(() => {
+				this.managedThreads = [];
+			});
+		}
+	});
+}
+function createAppThreadInstance({ definition, parentPort, threadId, onShutdown = noop }) {
+	definition = { ...definition };
+	definition.name += "." + threadId;
+	const instance = createAppInstance(definition);
+	const log = instance.logger;
+	const postMessage = (message, cb) => {
+		log.debug(formatLogEvent("child.ipc.send", message));
+		parentPort.postMessage(message, cb);
+	};
+	instance.eventBus.on("state", (newState) => {
+		postMessage(createThreadMessage("app-state", { state: newState }));
+	});
+	parentPort.on("message", async (message) => {
+		if (!isThreadMessage(message)) return;
+		log.debug(formatLogEvent("child.ipc.recv", message));
+		switch (message.type) {
+			case "setup": {
+				const result = await setupApp(instance, message.props);
+				postMessage(createThreadMessage("setup_done", { result }));
+				break;
+			}
+			case "start": {
+				const result = await runApp(instance);
+				postMessage(createThreadMessage("start_done", { result }));
+				break;
+			}
+			case "stop": {
+				const result = await stopApp(instance);
+				postMessage(createThreadMessage("stop_done", { result }));
+				break;
+			}
+			case "shutdown": {
+				const result = await shutdownApp(instance);
+				postMessage(createThreadMessage("shutdown_done", { result }), () => {
+					setImmediate(() => {
+						catchError(onShutdown);
+						if (isFunction(parentPort.close)) parentPort.close();
+					});
+				});
+				break;
+			}
+			case "ping":
+				postMessage(createThreadMessage("pong", {}));
+				break;
+		}
+	});
+	postMessage(createThreadMessage("ready", { pid: process.pid }));
+	return instance;
+}
+const TYPESCRIPT_EXTENSIONS = [
+	"mts",
+	"cts",
+	"ts"
+];
+const JAVASCRIPT_EXTENSIONS = [
+	"js",
+	"mjs",
+	"cjs"
+];
 const ALL_EXTENSIONS = [
-  ...TYPESCRIPT_EXTENSIONS,
-  ...JAVASCRIPT_EXTENSIONS,
-  "json"
+	...TYPESCRIPT_EXTENSIONS,
+	...JAVASCRIPT_EXTENSIONS,
+	"json"
 ];
 function createProject(projectPath) {
-  const packageJsonPath = locateNearestFile(projectPath, "package.json");
-  assert.ok(
-    packageJsonPath,
-    "package.json not found in path: " + path.dirname(projectPath)
-  );
-  const packageJson = importJson(packageJsonPath);
-  const projectLocation = path.dirname(packageJsonPath);
-  const project = {
-    path: projectLocation,
-    name: packageJson.name || path.basename(projectPath),
-    description: packageJson.description || "",
-    version: packageJson.version || "0.0.0",
-    tsconfigPath: locateNearestFile(projectLocation, "tsconfig.json"),
-    dotenvPath: locateNearestFile(projectLocation, ".env"),
-    autoImports: ["inversify.config"],
-    importLookupPaths: createImportLookupPaths(projectLocation),
-    allowTs: false,
-    packageJson
-  };
-  project.autoImports = project.autoImports.map((v) => projectResolveFile(project, v)).filter(isString);
-  return project;
+	const packageJsonPath = locateNearestFile(projectPath, "package.json");
+	assert.ok(packageJsonPath, "package.json not found in path: " + path.dirname(projectPath));
+	const packageJson = importJson(packageJsonPath);
+	const projectLocation = path.dirname(packageJsonPath);
+	const project = {
+		path: projectLocation,
+		name: packageJson.name || path.basename(projectPath),
+		description: packageJson.description || "",
+		version: packageJson.version || "0.0.0",
+		tsconfigPath: locateNearestFile(projectLocation, "tsconfig.json"),
+		dotenvPath: locateNearestFile(projectLocation, ".env"),
+		autoImports: ["inversify.config"],
+		importLookupPaths: createImportLookupPaths(projectLocation),
+		allowTs: false,
+		packageJson
+	};
+	project.autoImports = project.autoImports.map((v) => projectResolveFile(project, v)).filter(isString);
+	return project;
 }
 function projectImportFile(project, filePath) {
-  const existedFile = projectResolveFile(project, filePath);
-  if (!existedFile) {
-    throw new Error(
-      `Cannot resolve import for path.
- Path:
-  ${filePath}
- Available extensions: ${ALL_EXTENSIONS.join(", ")}`
-    );
-  }
-  const ext = getFileExtension(existedFile, false);
-  if (ext === "json") {
-    const data = importJson(existedFile);
-    return Promise.resolve({ default: data });
-  }
-  return import(existedFile);
+	const existedFile = projectResolveFile(project, filePath);
+	if (!existedFile) throw new Error(`Cannot resolve import for path.\n Path:\n  ${filePath}\n Available extensions: ${ALL_EXTENSIONS.join(", ")}`);
+	if (getFileExtension(existedFile, false) === "json") {
+		const data = importJson(existedFile);
+		return Promise.resolve({ default: data });
+	}
+	return import(existedFile);
 }
 function projectResolveFile(project, filePath) {
-  const pathVariants = project.importLookupPaths.map(
-    (dir) => path.resolve(dir, filePath)
-  );
-  for (const filePath2 of pathVariants) {
-    const pathVariants2 = ALL_EXTENSIONS.includes(
-      getFileExtension(filePath2, false)
-    ) ? [filePath2] : [...ALL_EXTENSIONS.map((ext) => `${filePath2}.${ext}`)];
-    const existedPath = pathVariants2.find((v) => fs.existsSync(v));
-    if (existedPath) {
-      return existedPath;
-    }
-  }
-  return null;
-}
-async function projectLoadEnv(project) {
-  if (!project.dotenvPath) {
-    return false;
-  }
-  dotenv.config({
-    path: project.dotenvPath,
-    quiet: true
-  });
-  return true;
-}
-async function projectAutoImport(project) {
-  const result = [];
-  const filePaths = project.autoImports.map(
-    (filePath) => projectResolveFile(project, filePath)
-  );
-  for (const filePath of filePaths) {
-    if (filePath) {
-      await projectImportFile(project, filePath);
-      result.push(filePath.replace(project.path, ""));
-    }
-  }
-  return result;
+	const pathVariants = project.importLookupPaths.map((dir) => path.resolve(dir, filePath));
+	for (const filePath of pathVariants) {
+		const existedPath = (ALL_EXTENSIONS.includes(getFileExtension(filePath, false)) ? [filePath] : [...ALL_EXTENSIONS.map((ext) => `${filePath}.${ext}`)]).find((v) => fs.existsSync(v));
+		if (existedPath) return existedPath;
+	}
+	return null;
+}
+function projectLoadEnv(project) {
+	if (!project.dotenvPath) return Promise.resolve(false);
+	dotenv.config({
+		path: project.dotenvPath,
+		quiet: true
+	});
+	return Promise.resolve(true);
+}
+function projectAutoImport(project) {
+	const result = [];
+	return asyncForEach(project.autoImports.map((filePath) => projectResolveFile(project, filePath)), (filePath) => {
+		if (!filePath) return;
+		return projectImportFile(project, filePath).then(() => {
+			result.push(filePath.replace(project.path, ""));
+		});
+	}, { concurrency: 4 }).then(() => result);
 }
 function projectPrintInfo(project) {
-  const tags = [];
-  if (project.allowTs) {
-    tags.push(getColor("bgBlue")(" TS "));
-  }
-  if (CONFIG.WATCH_MODE) {
-    tags.push(getColor("bgMagenta")(" WATCH "));
-  }
-  if (project.dotenvPath) {
-    tags.push(getColor("bgYellow")(` ${path.basename(project.dotenvPath)} `));
-  }
-  if (project.autoImports.length) {
-    tags.push(
-      getColor("bgGreen")(
-        ` IMPORT: ${project.autoImports.map((v) => path.relative(project.path, v)).join(" | ")} `
-      )
-    );
-  }
-  log.info(
-    "%s (%s)%s",
-    project.name,
-    project.version,
-    tags.length ? ` ${tags.join(" ")}` : ""
-  );
+	const tags = [];
+	if (project.allowTs) tags.push(getColor("bgBlue")(" TS "));
+	if (CONFIG.WATCH_MODE) tags.push(getColor("bgMagenta")(" WATCH "));
+	if (project.dotenvPath) tags.push(getColor("bgYellow")(` ${path.basename(project.dotenvPath)} `));
+	if (project.autoImports.length) tags.push(getColor("bgGreen")(` IMPORT: ${project.autoImports.map((v) => path.relative(project.path, v)).join(" | ")} `));
+	log.info("%s (%s)%s", project.name, project.version, tags.length ? ` ${tags.join(" ")}` : "");
 }
 function createImportLookupPaths(projectPath, appRoot = CONFIG.APP_ROOT) {
-  const cwd = process.cwd();
-  const result = [];
-  if (appRoot) {
-    result.push(path.resolve(cwd, appRoot));
-  }
-  result.push(path.resolve(cwd));
-  result.push(path.resolve(projectPath));
-  return uniq(result);
+	const cwd = process.cwd();
+	const result = [];
+	if (appRoot) result.push(path.resolve(cwd, appRoot));
+	result.push(path.resolve(cwd));
+	result.push(path.resolve(projectPath));
+	return uniq(result);
 }
 function locateNearestFile(location, fileName) {
-  let currentDir = path.extname(location) ? path.dirname(path.resolve(location)) : path.resolve(location);
-  while (currentDir) {
-    const filePath = path.join(currentDir, fileName);
-    if (fs.existsSync(filePath)) {
-      return filePath;
-    }
-    const parentDir = path.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-  }
-  return null;
+	let currentDir = path.extname(location) ? path.dirname(path.resolve(location)) : path.resolve(location);
+	while (currentDir) {
+		const filePath = path.join(currentDir, fileName);
+		if (fs.existsSync(filePath)) return filePath;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return null;
 }
 function importJson(filePath) {
-  if (!filePath.endsWith(".json")) {
-    filePath += ".json";
-  }
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`JSON file not found.
- Path:
-  ${filePath}`);
-  }
-  const data = fs.readFileSync(filePath, { encoding: "utf-8" });
-  return JSON.parse(data);
+	if (!filePath.endsWith(".json")) filePath += ".json";
+	if (!fs.existsSync(filePath)) throw new Error(`JSON file not found.\n Path:\n  ${filePath}`);
+	const data = fs.readFileSync(filePath, { encoding: "utf-8" });
+	return JSON.parse(data);
 }
-
 const LOG_BUFFER_CAP = 2e3;
-class RingBuffer {
-  constructor(cap) {
-    this.cap = cap;
-  }
-  buf = [];
-  start = 0;
-  push(item) {
-    if (this.buf.length < this.cap) {
-      this.buf.push(item);
-    } else {
-      this.buf[this.start] = item;
-      this.start = (this.start + 1) % this.cap;
-    }
-  }
-  size() {
-    return this.buf.length;
-  }
-  toArray() {
-    if (this.start === 0) return this.buf.slice();
-    return this.buf.slice(this.start).concat(this.buf.slice(0, this.start));
-  }
-  clear() {
-    this.buf = [];
-    this.start = 0;
-  }
-}
+var RingBuffer = class {
+	cap;
+	buf = [];
+	start = 0;
+	constructor(cap) {
+		this.cap = cap;
+	}
+	push(item) {
+		if (this.buf.length < this.cap) this.buf.push(item);
+		else {
+			this.buf[this.start] = item;
+			this.start = (this.start + 1) % this.cap;
+		}
+	}
+	size() {
+		return this.buf.length;
+	}
+	toArray() {
+		if (this.start === 0) return this.buf.slice();
+		return this.buf.slice(this.start).concat(this.buf.slice(0, this.start));
+	}
+	clear() {
+		this.buf = [];
+		this.start = 0;
+	}
+};
 const noopHandlers = {
-  stop: () => Promise.resolve(),
-  start: () => Promise.resolve(),
-  restart: () => Promise.resolve()
+	stop: () => Promise.resolve(),
+	start: () => Promise.resolve(),
+	restart: () => Promise.resolve()
 };
 function createTuiStore() {
-  const emitter = new EventEmitter();
-  emitter.setMaxListeners(0);
-  const logs = /* @__PURE__ */ new Map();
-  const apps = [];
-  const bufferOf = (id) => {
-    let buf = logs.get(id);
-    if (!buf) {
-      buf = new RingBuffer(LOG_BUFFER_CAP);
-      logs.set(id, buf);
-    }
-    return buf;
-  };
-  const notify = () => {
-    emitter.emit("change");
-  };
-  const isSelectedFeed = (nodeId) => {
-    if (!store.selectedId) return false;
-    if (store.selectedId === nodeId) return true;
-    for (const app of apps) {
-      if (app.id !== store.selectedId) continue;
-      return !!app.threads?.some((t) => t.id === nodeId);
-    }
-    return false;
-  };
-  const store = {
-    apps,
-    logs,
-    system: null,
-    selectedId: null,
-    filter: "info",
-    logScroll: 0,
-    handlers: noopHandlers,
-    pushLog(nodeId, entry) {
-      bufferOf(nodeId).push(entry);
-      if (store.logScroll > 0 && isSelectedFeed(nodeId) && passesFilter(entry, store.filter)) {
-        store.logScroll += 1;
-      }
-      notify();
-    },
-    setState(nodeId, state) {
-      for (const app of apps) {
-        if (app.id === nodeId) {
-          app.state = state;
-          notify();
-          return;
-        }
-        if (app.threads) {
-          for (const t of app.threads) {
-            if (t.id === nodeId) {
-              t.state = state;
-              notify();
-              return;
-            }
-          }
-        }
-      }
-    },
-    setSelected(nodeId) {
-      store.selectedId = nodeId;
-      store.logScroll = 0;
-      notify();
-    },
-    setFilter(filter) {
-      store.filter = filter;
-      store.logScroll = 0;
-      notify();
-    },
-    setLogScroll(offset) {
-      store.logScroll = Math.max(0, offset);
-      notify();
-    },
-    setSystem(entry) {
-      store.system = entry;
-      notify();
-    },
-    toggleExpand(appId) {
-      for (const app of apps) {
-        if (app.id === appId) {
-          app.expanded = !app.expanded;
-          notify();
-          return;
-        }
-      }
-    },
-    addApp(node) {
-      apps.push(node);
-      if (!store.selectedId) store.selectedId = node.id;
-      notify();
-    },
-    setThreads(appId, threads) {
-      for (const app of apps) {
-        if (app.id === appId) {
-          app.threads = threads;
-          notify();
-          return;
-        }
-      }
-    },
-    setPid(nodeId, pid) {
-      for (const app of apps) {
-        if (app.threads) {
-          for (const t of app.threads) {
-            if (t.id === nodeId) {
-              t.pid = pid;
-              notify();
-              return;
-            }
-          }
-        }
-      }
-    },
-    getLogs(nodeId) {
-      const buf = logs.get(nodeId);
-      return buf ? buf.toArray() : [];
-    },
-    clearLogs(nodeId) {
-      logs.get(nodeId)?.clear();
-      notify();
-    },
-    subscribe(fn) {
-      emitter.on("change", fn);
-      return () => emitter.off("change", fn);
-    }
-  };
-  return store;
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(0);
+	const logs = /* @__PURE__ */ new Map();
+	const apps = [];
+	const bufferOf = (id) => {
+		let buf = logs.get(id);
+		if (!buf) {
+			buf = new RingBuffer(LOG_BUFFER_CAP);
+			logs.set(id, buf);
+		}
+		return buf;
+	};
+	const notify = () => {
+		emitter.emit("change");
+	};
+	const isSelectedFeed = (nodeId) => {
+		if (!store.selectedId) return false;
+		if (store.selectedId === nodeId) return true;
+		for (const app of apps) {
+			if (app.id !== store.selectedId) continue;
+			return !!app.threads?.some((t) => t.id === nodeId);
+		}
+		return false;
+	};
+	const store = {
+		apps,
+		logs,
+		system: null,
+		selectedId: null,
+		filter: "info",
+		logScroll: 0,
+		handlers: noopHandlers,
+		pushLog(nodeId, entry) {
+			bufferOf(nodeId).push(entry);
+			if (store.logScroll > 0 && isSelectedFeed(nodeId) && passesFilter(entry, store.filter)) store.logScroll += 1;
+			notify();
+		},
+		setState(nodeId, state) {
+			for (const app of apps) {
+				if (app.id === nodeId) {
+					app.state = state;
+					notify();
+					return;
+				}
+				if (app.threads) {
+					for (const t of app.threads) if (t.id === nodeId) {
+						t.state = state;
+						notify();
+						return;
+					}
+				}
+			}
+		},
+		setSelected(nodeId) {
+			store.selectedId = nodeId;
+			store.logScroll = 0;
+			notify();
+		},
+		setFilter(filter) {
+			store.filter = filter;
+			store.logScroll = 0;
+			notify();
+		},
+		setLogScroll(offset) {
+			store.logScroll = Math.max(0, offset);
+			notify();
+		},
+		setSystem(entry) {
+			store.system = entry;
+			notify();
+		},
+		toggleExpand(appId) {
+			for (const app of apps) if (app.id === appId) {
+				app.expanded = !app.expanded;
+				notify();
+				return;
+			}
+		},
+		addApp(node) {
+			apps.push(node);
+			if (!store.selectedId) store.selectedId = node.id;
+			notify();
+		},
+		setThreads(appId, threads) {
+			for (const app of apps) if (app.id === appId) {
+				app.threads = threads;
+				notify();
+				return;
+			}
+		},
+		setPid(nodeId, pid) {
+			for (const app of apps) if (app.threads) {
+				for (const t of app.threads) if (t.id === nodeId) {
+					t.pid = pid;
+					notify();
+					return;
+				}
+			}
+		},
+		getLogs(nodeId) {
+			const buf = logs.get(nodeId);
+			return buf ? buf.toArray() : [];
+		},
+		clearLogs(nodeId) {
+			logs.get(nodeId)?.clear();
+			notify();
+		},
+		subscribe(fn) {
+			emitter.on("change", fn);
+			return () => emitter.off("change", fn);
+		}
+	};
+	return store;
 }
 const LEVEL_RANK = {
-  debug: 0,
-  log: 1,
-  info: 2,
-  warn: 3,
-  error: 4
+	debug: 0,
+	log: 1,
+	info: 2,
+	warn: 3,
+	error: 4
 };
 const FILTER_THRESHOLD = {
-  all: 0,
-  info: LEVEL_RANK.info,
-  warn: LEVEL_RANK.warn,
-  error: LEVEL_RANK.error
+	all: 0,
+	info: LEVEL_RANK.info,
+	warn: LEVEL_RANK.warn,
+	error: LEVEL_RANK.error
 };
 function passesFilter(entry, filter) {
-  return LEVEL_RANK[entry.level] >= FILTER_THRESHOLD[filter];
+	return LEVEL_RANK[entry.level] >= FILTER_THRESHOLD[filter];
 }
 function getSelectedFilteredCount(store) {
-  if (!store.selectedId) return 0;
-  const passes = (e) => passesFilter(e, store.filter);
-  for (const app of store.apps) {
-    if (app.id !== store.selectedId) continue;
-    if (!app.threads || app.threads.length === 0) {
-      return store.getLogs(app.id).filter(passes).length;
-    }
-    let count = 0;
-    for (const t of app.threads) {
-      for (const e of store.getLogs(t.id)) if (passes(e)) count += 1;
-    }
-    return count;
-  }
-  return store.getLogs(store.selectedId).filter(passes).length;
+	if (!store.selectedId) return 0;
+	const passes = (e) => passesFilter(e, store.filter);
+	for (const app of store.apps) {
+		if (app.id !== store.selectedId) continue;
+		if (!app.threads || app.threads.length === 0) return store.getLogs(app.id).filter(passes).length;
+		let count = 0;
+		for (const t of app.threads) for (const e of store.getLogs(t.id)) if (passes(e)) count += 1;
+		return count;
+	}
+	return store.getLogs(store.selectedId).filter(passes).length;
 }
 function nextFilter(filter) {
-  switch (filter) {
-    case "all":
-      return "info";
-    case "info":
-      return "warn";
-    case "warn":
-      return "error";
-    case "error":
-      return "all";
-  }
+	switch (filter) {
+		case "all": return "info";
+		case "info": return "warn";
+		case "warn": return "error";
+		case "error": return "all";
+	}
 }
 function flattenVisibleTree(apps) {
-  const out = [];
-  for (const app of apps) {
-    out.push(app);
-    if (app.expanded && app.threads) {
-      for (const t of app.threads) out.push(t);
-    }
-  }
-  return out;
+	const out = [];
+	for (const app of apps) {
+		out.push(app);
+		if (app.expanded && app.threads) for (const t of app.threads) out.push(t);
+	}
+	return out;
 }
-
 const TuiStoreContext = createContext(null);
 function useTuiStore() {
-  const store = useContext(TuiStoreContext);
-  if (!store) throw new Error("TuiStoreContext is not provided");
-  return store;
+	const store = useContext(TuiStoreContext);
+	if (!store) throw new Error("TuiStoreContext is not provided");
+	return store;
 }
 function useStoreSnapshot() {
-  const store = useTuiStore();
-  const [version, setVersion] = useState(0);
-  useEffect(() => {
-    return store.subscribe(() => setVersion((v) => v + 1));
-  }, [store]);
-  return version;
+	const store = useTuiStore();
+	const [version, setVersion] = useState(0);
+	useEffect(() => {
+		return store.subscribe(() => setVersion((v) => v + 1));
+	}, [store]);
+	return version;
 }
-
 const STATE_COLORS = {
-  "in-run": "yellow",
-  run: "green",
-  "in-stop": "yellow",
-  "in-setup": "yellow",
-  setup: "yellow",
-  ready: "gray",
-  "in-shutdown": "yellow",
-  init: "gray",
-  shutdown: "gray",
-  stop: "gray",
-  error: "red"
+	"in-run": "yellow",
+	run: "green",
+	"in-stop": "yellow",
+	"in-setup": "yellow",
+	setup: "yellow",
+	ready: "gray",
+	"in-shutdown": "yellow",
+	init: "gray",
+	shutdown: "gray",
+	stop: "gray",
+	error: "red"
 };
 function isApp(n) {
-  return n.kind === "app";
+	return n.kind === "app";
 }
 function rowLength(n) {
-  if (n.kind === "app") return 1 + 1 + 1 + 1 + 1 + (n.name?.length ?? 0);
-  return 1 + 2 + 1 + 1 + `PID ${n.pid}`.length;
+	if (n.kind === "app") return 5 + (n.name?.length ?? 0);
+	return 5 + `PID ${n.pid}`.length;
 }
 function AppList() {
-  useStoreSnapshot();
-  const store = useTuiStore();
-  const nodes = flattenVisibleTree(store.apps);
-  const maxRow = nodes.reduce(
-    (m, n) => Math.max(m, rowLength(n)),
-    "Apps".length
-  );
-  const width = maxRow + 4;
-  return /* @__PURE__ */ jsxs(
-    Box,
-    {
-      flexDirection: "column",
-      width,
-      flexShrink: 0,
-      borderStyle: "single",
-      paddingX: 1,
-      overflow: "hidden",
-      children: [
-        /* @__PURE__ */ jsx(Text, { bold: true, children: "Apps" }),
-        nodes.map((node) => {
-          const selected = node.id === store.selectedId;
-          const color = STATE_COLORS[node.state];
-          const marker = selected ? "\u258C" : " ";
-          if (isApp(node)) {
-            const caret = node.threads && node.threads.length ? node.expanded ? "\u25BE" : "\u25B8" : " ";
-            return /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", bold: selected, children: [
-              /* @__PURE__ */ jsx(Text, { color: "cyan", children: marker }),
-              caret,
-              " ",
-              /* @__PURE__ */ jsx(Text, { color, children: "\u25CF" }),
-              " ",
-              node.name
-            ] }, node.id);
-          }
-          return /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", bold: selected, children: [
-            /* @__PURE__ */ jsx(Text, { color: "cyan", children: marker }),
-            "  ",
-            /* @__PURE__ */ jsx(Text, { color, children: "\u25CF" }),
-            " ",
-            node.name
-          ] }, node.id);
-        })
-      ]
-    }
-  );
+	useStoreSnapshot();
+	const store = useTuiStore();
+	const nodes = flattenVisibleTree(store.apps);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width: nodes.reduce((m, n) => Math.max(m, rowLength(n)), 4) + 4,
+		flexShrink: 0,
+		borderStyle: "single",
+		paddingX: 1,
+		overflow: "hidden",
+		children: [/* @__PURE__ */ jsx(Text, {
+			bold: true,
+			children: "Apps"
+		}), nodes.map((node) => {
+			const selected = node.id === store.selectedId;
+			const color = STATE_COLORS[node.state];
+			const marker = selected ? "▌" : " ";
+			if (isApp(node)) {
+				const caret = node.threads && node.threads.length ? node.expanded ? "▾" : "▸" : " ";
+				return /* @__PURE__ */ jsxs(Text, {
+					wrap: "truncate-end",
+					bold: selected,
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: marker
+						}),
+						caret,
+						" ",
+						/* @__PURE__ */ jsx(Text, {
+							color,
+							children: "●"
+						}),
+						" ",
+						node.name
+					]
+				}, node.id);
+			}
+			return /* @__PURE__ */ jsxs(Text, {
+				wrap: "truncate-end",
+				bold: selected,
+				children: [
+					/* @__PURE__ */ jsx(Text, {
+						color: "cyan",
+						children: marker
+					}),
+					"  ",
+					/* @__PURE__ */ jsx(Text, {
+						color,
+						children: "●"
+					}),
+					" ",
+					node.name
+				]
+			}, node.id);
+		})]
+	});
 }
-
 const LEVEL_COLORS = {
-  debug: "gray",
-  log: "white",
-  info: "cyan",
-  warn: "yellow",
-  error: "red"
+	debug: "gray",
+	log: "white",
+	info: "cyan",
+	warn: "yellow",
+	error: "red"
 };
 function formatTime(ts) {
-  const d = new Date(ts);
-  const pad = (n) => n.toString().padStart(2, "0");
-  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+	const d = new Date(ts);
+	const pad = (n) => n.toString().padStart(2, "0");
+	return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
 function describeSelection(store) {
-  if (!store.selectedId) return null;
-  for (const app of store.apps) {
-    if (app.id === store.selectedId) {
-      const threads = app.threads ?? [];
-      const pids = Array.from(
-        new Set(threads.map((t) => t.pid).filter((p) => p > 0))
-      );
-      return {
-        appName: app.name,
-        processCount: threads.length,
-        pids,
-        states: threads.map((v) => v.state),
-        showProcessTag: threads.length > 1
-      };
-    }
-    if (app.threads) {
-      for (const t of app.threads) {
-        if (t.id === store.selectedId) {
-          return {
-            appName: app.name,
-            pid: t.pid,
-            pids: t.pid > 0 ? [t.pid] : [],
-            state: t.state,
-            states: [t.state],
-            processCount: app.threads.length,
-            showProcessTag: false
-          };
-        }
-      }
-    }
-  }
-  return null;
+	if (!store.selectedId) return null;
+	for (const app of store.apps) {
+		if (app.id === store.selectedId) {
+			const threads = app.threads ?? [];
+			const pids = Array.from(new Set(threads.map((t) => t.pid).filter((p) => p > 0)));
+			return {
+				appName: app.name,
+				processCount: threads.length,
+				pids,
+				states: threads.map((v) => v.state),
+				showProcessTag: threads.length > 1
+			};
+		}
+		if (app.threads) {
+			for (const t of app.threads) if (t.id === store.selectedId) return {
+				appName: app.name,
+				pid: t.pid,
+				pids: t.pid > 0 ? [t.pid] : [],
+				state: t.state,
+				states: [t.state],
+				processCount: app.threads.length,
+				showProcessTag: false
+			};
+		}
+	}
+	return null;
 }
 function formatPids(pids) {
-  if (pids.length === 0) return "?";
-  if (pids.length === 1) return String(pids[0]);
-  return pids.join(", ");
+	if (pids.length === 0) return "?";
+	if (pids.length === 1) return String(pids[0]);
+	return pids.join(", ");
 }
 function gatherEntries(store, info) {
-  if (!store.selectedId) return [];
-  for (const app of store.apps) {
-    if (app.id !== store.selectedId) continue;
-    if (!app.threads || app.threads.length === 0) {
-      return store.getLogs(app.id);
-    }
-    const merged = [];
-    for (const t of app.threads) {
-      for (const entry of store.getLogs(t.id)) {
-        merged.push(
-          info.showProcessTag ? { ...entry, text: `[${t.pid}] ${entry.text}` } : entry
-        );
-      }
-    }
-    merged.sort((a, b) => a.ts - b.ts);
-    return merged;
-  }
-  return store.getLogs(store.selectedId);
+	if (!store.selectedId) return [];
+	for (const app of store.apps) {
+		if (app.id !== store.selectedId) continue;
+		if (!app.threads || app.threads.length === 0) return store.getLogs(app.id);
+		const merged = [];
+		for (const t of app.threads) for (const entry of store.getLogs(t.id)) merged.push(info.showProcessTag ? {
+			...entry,
+			text: `[${t.pid}] ${entry.text}`
+		} : entry);
+		merged.sort((a, b) => a.ts - b.ts);
+		return merged;
+	}
+	return store.getLogs(store.selectedId);
 }
 function LogView() {
-  useStoreSnapshot();
-  const store = useTuiStore();
-  const { stdout } = useStdout();
-  const rows = stdout?.rows ?? 24;
-  const visibleRows = Math.max(1, rows - 5);
-  const info = describeSelection(store);
-  let entries = [];
-  let scrollLabel = "";
-  if (info) {
-    const all = gatherEntries(store, info);
-    const filtered = all.filter((e) => passesFilter(e, store.filter));
-    const total = filtered.length;
-    const maxOffset = Math.max(0, total - visibleRows);
-    const offset = Math.min(store.logScroll, maxOffset);
-    const end = total - offset;
-    const start = Math.max(0, end - visibleRows);
-    entries = filtered.slice(start, end);
-    if (offset > 0) scrollLabel = ` \xB7 scrolled +${offset}`;
-  }
-  return /* @__PURE__ */ jsxs(
-    Box,
-    {
-      flexDirection: "column",
-      flexGrow: 1,
-      flexShrink: 1,
-      borderStyle: "single",
-      paddingX: 1,
-      overflow: "hidden",
-      children: [
-        /* @__PURE__ */ jsx(Box, { flexShrink: 0, flexDirection: "column", children: info ? /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
-          /* @__PURE__ */ jsxs(Text, { bold: true, wrap: "truncate-end", children: [
-            /* @__PURE__ */ jsx(Text, { color: "cyan", children: info.appName }),
-            info.processCount > 1 && info.pid == null ? /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-              " (",
-              info.processCount,
-              " processes)"
-            ] }) : null,
-            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-              " ",
-              "\xB7 filter: ",
-              store.filter,
-              scrollLabel
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxs(Text, { bold: true, wrap: "truncate-end", children: [
-            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-              "STATE ",
-              info.states.join(", ")
-            ] }),
-            /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 " }),
-            /* @__PURE__ */ jsxs(Text, { color: "magenta", children: [
-              "PID ",
-              formatPids(info.pids)
-            ] })
-          ] })
-        ] }) : /* @__PURE__ */ jsx(Text, { bold: true, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: " (no selection)" }) }) }),
-        /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: entries.map((entry, idx) => /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
-          /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
-            formatTime(entry.ts),
-            " "
-          ] }),
-          /* @__PURE__ */ jsx(Text, { color: LEVEL_COLORS[entry.level], children: entry.level.toUpperCase().padEnd(5) }),
-          " ",
-          entry.text
-        ] }, idx)) })
-      ]
-    }
-  );
+	useStoreSnapshot();
+	const store = useTuiStore();
+	const { stdout } = useStdout();
+	const rows = stdout?.rows ?? 24;
+	const visibleRows = Math.max(1, rows - 5);
+	const info = describeSelection(store);
+	let entries = [];
+	let scrollLabel = "";
+	if (info) {
+		const filtered = gatherEntries(store, info).filter((e) => passesFilter(e, store.filter));
+		const total = filtered.length;
+		const maxOffset = Math.max(0, total - visibleRows);
+		const offset = Math.min(store.logScroll, maxOffset);
+		const end = total - offset;
+		const start = Math.max(0, end - visibleRows);
+		entries = filtered.slice(start, end);
+		if (offset > 0) scrollLabel = ` · scrolled +${offset}`;
+	}
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		flexGrow: 1,
+		flexShrink: 1,
+		borderStyle: "single",
+		paddingX: 1,
+		overflow: "hidden",
+		children: [/* @__PURE__ */ jsx(Box, {
+			flexShrink: 0,
+			flexDirection: "column",
+			children: info ? /* @__PURE__ */ jsxs(Box, {
+				justifyContent: "space-between",
+				children: [/* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					wrap: "truncate-end",
+					children: [
+						/* @__PURE__ */ jsx(Text, {
+							color: "cyan",
+							children: info.appName
+						}),
+						info.processCount > 1 && info.pid == null ? /* @__PURE__ */ jsxs(Text, {
+							color: "gray",
+							children: [
+								" (",
+								info.processCount,
+								" processes)"
+							]
+						}) : null,
+						/* @__PURE__ */ jsxs(Text, {
+							color: "gray",
+							children: [
+								" ",
+								"· filter: ",
+								store.filter,
+								scrollLabel
+							]
+						})
+					]
+				}), /* @__PURE__ */ jsxs(Text, {
+					bold: true,
+					wrap: "truncate-end",
+					children: [
+						/* @__PURE__ */ jsxs(Text, {
+							color: "gray",
+							children: ["STATE ", info.states.join(", ")]
+						}),
+						/* @__PURE__ */ jsx(Text, {
+							color: "gray",
+							children: " · "
+						}),
+						/* @__PURE__ */ jsxs(Text, {
+							color: "magenta",
+							children: ["PID ", formatPids(info.pids)]
+						})
+					]
+				})]
+			}) : /* @__PURE__ */ jsx(Text, {
+				bold: true,
+				children: /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: " (no selection)"
+				})
+			})
+		}), /* @__PURE__ */ jsx(Box, {
+			flexDirection: "column",
+			flexGrow: 1,
+			flexShrink: 1,
+			overflow: "hidden",
+			children: entries.map((entry, idx) => /* @__PURE__ */ jsxs(Text, {
+				wrap: "wrap",
+				children: [
+					/* @__PURE__ */ jsxs(Text, {
+						color: "gray",
+						children: [formatTime(entry.ts), " "]
+					}),
+					/* @__PURE__ */ jsx(Text, {
+						color: LEVEL_COLORS[entry.level],
+						children: entry.level.toUpperCase().padEnd(5)
+					}),
+					" ",
+					entry.text
+				]
+			}, idx))
+		})]
+	});
 }
-
 function StatusBar() {
-  useStoreSnapshot();
-  const store = useTuiStore();
-  const sys = store.system;
-  return /* @__PURE__ */ jsxs(
-    Box,
-    {
-      flexDirection: "row",
-      justifyContent: "space-between",
-      paddingX: 1,
-      flexShrink: 0,
-      height: 1,
-      children: [
-        /* @__PURE__ */ jsx(Box, { flexShrink: 1, overflow: "hidden", children: /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", children: sys ? /* @__PURE__ */ jsxs(Fragment, { children: [
-          /* @__PURE__ */ jsx(Text, { color: "gray", children: "[system] " }),
-          /* @__PURE__ */ jsx(Text, { color: sys.level === "error" ? "red" : "white", children: sys.text })
-        ] }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: "[system] ready" }) }) }),
-        /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2191/\u2193 \xB7 \u2192/\u2190 \xB7 PgUp/PgDn \xB7 s \xB7 \u21E7S \xB7 r \xB7 f \xB7 q" }) })
-      ]
-    }
-  );
+	useStoreSnapshot();
+	const sys = useTuiStore().system;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "row",
+		justifyContent: "space-between",
+		paddingX: 1,
+		flexShrink: 0,
+		height: 1,
+		children: [/* @__PURE__ */ jsx(Box, {
+			flexShrink: 1,
+			overflow: "hidden",
+			children: /* @__PURE__ */ jsx(Text, {
+				wrap: "truncate-end",
+				children: sys ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: "[system] "
+				}), /* @__PURE__ */ jsx(Text, {
+					color: sys.level === "error" ? "red" : "white",
+					children: sys.text
+				})] }) : /* @__PURE__ */ jsx(Text, {
+					color: "gray",
+					children: "[system] ready"
+				})
+			})
+		}), /* @__PURE__ */ jsx(Box, {
+			flexShrink: 0,
+			children: /* @__PURE__ */ jsx(Text, {
+				color: "gray",
+				children: "↑/↓ · →/← · PgUp/PgDn · s · ⇧S · r · f · q"
+			})
+		})]
+	});
 }
-
 function findNodeAndApp(store, id) {
-  for (const app of store.apps) {
-    if (app.id === id) return { node: app, app };
-    if (app.threads) {
-      for (const t of app.threads) {
-        if (t.id === id) return { node: t, app };
-      }
-    }
-  }
-  return null;
+	for (const app of store.apps) {
+		if (app.id === id) return {
+			node: app,
+			app
+		};
+		if (app.threads) {
+			for (const t of app.threads) if (t.id === id) return {
+				node: t,
+				app
+			};
+		}
+	}
+	return null;
 }
 function InnerTui({ store, onExit }) {
-  useStoreSnapshot();
-  const { stdout } = useStdout();
-  const rows = stdout?.rows ?? 24;
-  useInput((input, key) => {
-    const visible = flattenVisibleTree(store.apps);
-    if (visible.length === 0) return;
-    const currentIdx = visible.findIndex((n) => n.id === store.selectedId);
-    const idx = currentIdx < 0 ? 0 : currentIdx;
-    const selected = visible[idx];
-    const visibleLogRows = Math.max(1, rows - 5);
-    const halfPage = Math.max(1, Math.floor(visibleLogRows / 2));
-    if (key.upArrow && key.shift) {
-      const maxOffset = Math.max(
-        0,
-        getSelectedFilteredCount(store) - visibleLogRows
-      );
-      store.setLogScroll(Math.min(maxOffset, store.logScroll + halfPage));
-      return;
-    }
-    if (key.downArrow && key.shift) {
-      store.setLogScroll(Math.max(0, store.logScroll - halfPage));
-      return;
-    }
-    if (key.home) {
-      const total = getSelectedFilteredCount(store);
-      store.setLogScroll(Math.max(0, total - visibleLogRows));
-      return;
-    }
-    if (key.end) {
-      store.setLogScroll(0);
-      return;
-    }
-    if (key.upArrow) {
-      const next = visible[Math.max(0, idx - 1)];
-      if (next) store.setSelected(next.id);
-      return;
-    }
-    if (key.downArrow) {
-      const next = visible[Math.min(visible.length - 1, idx + 1)];
-      if (next) store.setSelected(next.id);
-      return;
-    }
-    if (key.rightArrow) {
-      if (selected.kind === "app" && selected.threads && selected.threads.length) {
-        if (!selected.expanded) store.toggleExpand(selected.id);
-      }
-      return;
-    }
-    if (key.leftArrow) {
-      if (selected.kind === "app" && selected.expanded) {
-        store.toggleExpand(selected.id);
-      } else if (selected.kind === "thread") {
-        store.setSelected(selected.parentId);
-      }
-      return;
-    }
-    if (input === "f") {
-      store.setFilter(nextFilter(store.filter));
-      return;
-    }
-    if (input === "s") {
-      const target = findNodeAndApp(store, selected.id);
-      if (target) void store.handlers.stop(target.node.id);
-      return;
-    }
-    if (input === "S") {
-      const target = findNodeAndApp(store, selected.id);
-      if (target) void store.handlers.start(target.node.id);
-      return;
-    }
-    if (input === "r") {
-      const target = findNodeAndApp(store, selected.id);
-      if (target) void store.handlers.restart(target.node.id);
-      return;
-    }
-    if (input === "q" || key.ctrl && input === "c") {
-      void onExit();
-      return;
-    }
-  });
-  const columns = stdout?.columns ?? 80;
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexGrow: 1, width: columns, children: [
-      /* @__PURE__ */ jsx(AppList, {}),
-      /* @__PURE__ */ jsx(LogView, {})
-    ] }),
-    /* @__PURE__ */ jsx(StatusBar, {})
-  ] });
+	useStoreSnapshot();
+	const { stdout } = useStdout();
+	const rows = stdout?.rows ?? 24;
+	useInput((input, key) => {
+		const visible = flattenVisibleTree(store.apps);
+		if (visible.length === 0) return;
+		const currentIdx = visible.findIndex((n) => n.id === store.selectedId);
+		const idx = currentIdx < 0 ? 0 : currentIdx;
+		const selected = visible[idx];
+		const visibleLogRows = Math.max(1, rows - 5);
+		const halfPage = Math.max(1, Math.floor(visibleLogRows / 2));
+		if (key.upArrow && key.shift) {
+			const maxOffset = Math.max(0, getSelectedFilteredCount(store) - visibleLogRows);
+			store.setLogScroll(Math.min(maxOffset, store.logScroll + halfPage));
+			return;
+		}
+		if (key.downArrow && key.shift) {
+			store.setLogScroll(Math.max(0, store.logScroll - halfPage));
+			return;
+		}
+		if (key.home) {
+			const total = getSelectedFilteredCount(store);
+			store.setLogScroll(Math.max(0, total - visibleLogRows));
+			return;
+		}
+		if (key.end) {
+			store.setLogScroll(0);
+			return;
+		}
+		if (key.upArrow) {
+			const next = visible[Math.max(0, idx - 1)];
+			if (next) store.setSelected(next.id);
+			return;
+		}
+		if (key.downArrow) {
+			const next = visible[Math.min(visible.length - 1, idx + 1)];
+			if (next) store.setSelected(next.id);
+			return;
+		}
+		if (key.rightArrow) {
+			if (selected.kind === "app" && selected.threads && selected.threads.length) {
+				if (!selected.expanded) store.toggleExpand(selected.id);
+			}
+			return;
+		}
+		if (key.leftArrow) {
+			if (selected.kind === "app" && selected.expanded) store.toggleExpand(selected.id);
+			else if (selected.kind === "thread") store.setSelected(selected.parentId);
+			return;
+		}
+		if (input === "f") {
+			store.setFilter(nextFilter(store.filter));
+			return;
+		}
+		if (input === "s") {
+			const target = findNodeAndApp(store, selected.id);
+			if (target) store.handlers.stop(target.node.id);
+			return;
+		}
+		if (input === "S") {
+			const target = findNodeAndApp(store, selected.id);
+			if (target) store.handlers.start(target.node.id);
+			return;
+		}
+		if (input === "r") {
+			const target = findNodeAndApp(store, selected.id);
+			if (target) store.handlers.restart(target.node.id);
+			return;
+		}
+		if (input === "q" || key.ctrl && input === "c") {
+			onExit();
+			return;
+		}
+	});
+	const columns = stdout?.columns ?? 80;
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		width: columns,
+		height: rows,
+		children: [/* @__PURE__ */ jsxs(Box, {
+			flexDirection: "row",
+			flexGrow: 1,
+			width: columns,
+			children: [/* @__PURE__ */ jsx(AppList, {}), /* @__PURE__ */ jsx(LogView, {})]
+		}), /* @__PURE__ */ jsx(StatusBar, {})]
+	});
 }
 function TuiRoot(props) {
-  return /* @__PURE__ */ jsx(TuiStoreContext.Provider, { value: props.store, children: /* @__PURE__ */ jsx(InnerTui, { ...props }) });
+	return /* @__PURE__ */ jsx(TuiStoreContext.Provider, {
+		value: props.store,
+		children: /* @__PURE__ */ jsx(InnerTui, { ...props })
+	});
 }
-
 function getAppProps(definition, props, isSingle) {
-  if (isSingle) return { ...props };
-  return getPrefixedProps(definition, props);
+	if (isSingle) return { ...props };
+	return getPrefixedProps(definition, props);
 }
 function appIdFor(definition, idx) {
-  return `${definition.name}#${idx}`;
+	return `${definition.name}#${idx}`;
 }
 function resolveThreadCount(appProps) {
-  if (isNumber(appProps.threads) && appProps.threads > 0) {
-    return appProps.threads;
-  }
-  return 1;
+	if (isNumber(appProps.threads) && appProps.threads > 0) return appProps.threads;
+	return 1;
 }
 const APP_STATE_RANK = {
-  error: 10,
-  run: 9,
-  "in-run": 8,
-  setup: 7,
-  "in-setup": 6,
-  stop: 5,
-  "in-stop": 4,
-  shutdown: 3,
-  "in-shutdown": 2,
-  ready: 1,
-  init: 0
+	error: 10,
+	run: 9,
+	"in-run": 8,
+	setup: 7,
+	"in-setup": 6,
+	stop: 5,
+	"in-stop": 4,
+	shutdown: 3,
+	"in-shutdown": 2,
+	ready: 1,
+	init: 0
 };
 function aggregateAppState(threads) {
-  let best = "init";
-  for (const w of threads) {
-    const s = APP_STATE_RANK[w.state];
-    if (s > APP_STATE_RANK[best]) best = w.state;
-  }
-  return best;
+	let best = "init";
+	for (const w of threads) if (APP_STATE_RANK[w.state] > APP_STATE_RANK[best]) best = w.state;
+	return best;
 }
 function launchAppsTui(definitions, props) {
-  const store = createTuiStore();
-  const records = [];
-  const isSingle = definitions.length === 1;
-  if (props.watch) {
-    store.setSystem({
-      ts: Date.now(),
-      level: "warn",
-      text: "TUI does not yet support --watch mode;"
-    });
-  }
-  for (let i = 0; i < definitions.length; i++) {
-    const def = definitions[i];
-    const appId = appIdFor(def, i);
-    const appProps = getAppProps(def, props, isSingle);
-    const threadCount = resolveThreadCount(appProps);
-    appProps.__inheritIO = false;
-    delete appProps.threads;
-    const appNode = {
-      kind: "app",
-      id: appId,
-      name: def.name,
-      state: APP_INSTANCE_STATE.INIT,
-      expanded: false,
-      threads: []
-    };
-    store.addApp(appNode);
-    const threads = [];
-    const threadNodes = [];
-    for (let threadId = 1; threadId <= threadCount; threadId++) {
-      const nodeId = `${appId}:${threadId}`;
-      const threadNode = {
-        id: `${appId}:${threadId}`,
-        kind: "thread",
-        name: `${appNode.name}.${threadId}`,
-        parentId: appId,
-        threadId,
-        pid: 0,
-        state: APP_INSTANCE_STATE.INIT
-      };
-      threadNodes.push(threadNode);
-      const w = initThread(threadId, def.filePath, appProps);
-      w.eventBus.on("log", (entry) => {
-        store.pushLog(nodeId, {
-          ts: entry.ts,
-          level: entry.level,
-          text: entry.text
-        });
-      });
-      w.eventBus.on("state", (newState) => {
-        store.setState(nodeId, newState);
-        store.setState(appId, aggregateAppState(threads));
-      });
-      w.eventBus.on("pid", (pid) => {
-        store.setPid(nodeId, pid);
-      });
-      w.eventBus.on("error", (err) => {
-        store.pushLog(nodeId, {
-          ts: Date.now(),
-          level: "error",
-          text: `Thread error: ${err.message}`
-        });
-      });
-      threads.push(w);
-    }
-    store.setThreads(appId, threadNodes);
-    records.push({ appId, node: appNode, threads });
-  }
-  const findRecordByAppId = (id) => records.find((r) => r.appId === id);
-  const findThread = (id) => {
-    for (const r of records) {
-      for (const w of r.threads) {
-        if (`${r.appId}:${w.threadId}` === id) return { record: r, thread: w };
-      }
-    }
-    return void 0;
-  };
-  const startSingleThread = (w) => {
-    if (w.state === APP_INSTANCE_STATE.IN_RUN || APP_INSTANCE_STATE.RUN) {
-      return Promise.resolve();
-    }
-    if (w.state === APP_INSTANCE_STATE.STOP) return startThreadApp(w);
-    return setupThreadApp(w).then(() => startThreadApp(w));
-  };
-  store.handlers = {
-    stop(id) {
-      const r = findRecordByAppId(id);
-      if (r)
-        return Promise.all(r.threads.map((w) => stopThreadApp(w))).then(() => {
-        });
-      const found = findThread(id);
-      if (found) return stopThreadApp(found.thread);
-      return Promise.resolve();
-    },
-    start(id) {
-      const r = findRecordByAppId(id);
-      if (r) {
-        return Promise.all(r.threads.map(startSingleThread)).then(() => {
-        });
-      }
-      const found = findThread(id);
-      if (found) return startSingleThread(found.thread);
-      return Promise.resolve();
-    },
-    restart(id) {
-      const r = findRecordByAppId(id);
-      if (r) {
-        return Promise.all(
-          r.threads.map((w) => {
-            w.restartCount = 0;
-            return restartThreadApp(w);
-          })
-        ).then(() => {
-        });
-      }
-      const found = findThread(id);
-      if (found) {
-        found.thread.restartCount = 0;
-        return restartThreadApp(found.thread);
-      }
-      return Promise.resolve();
-    }
-  };
-  const startRecord = (r) => Promise.all(
-    r.threads.map(
-      (w) => waitForThreadReady(w).then(() => setupThreadApp(w)).then(() => startThreadApp(w))
-    )
-  ).then(noop);
-  onShutdownError((error) => {
-    console.error("[Graceful Shutdown] error:", error);
-  });
-  const q = defer();
-  onShutdown("app", () => {
-    store.setSystem({
-      ts: Date.now(),
-      level: "warn",
-      text: "shutdown initiated"
-    });
-    return Promise.all(
-      records.map((r) => Promise.all(r.threads.map((w) => shutdownThreadApp(w))))
-    ).then(() => {
-      store.setSystem({
-        ts: Date.now(),
-        level: "info",
-        text: "shutdown complete"
-      });
-    }).then(() => inkInstance.waitUntilRenderFlush()).then(() => inkInstance.unmount()).then(() => q.resolve()).catch(console.error);
-  });
-  const onExit = () => {
-    return Promise.resolve().then(() => processGraceful());
-  };
-  const inkInstance = render(/* @__PURE__ */ jsx(TuiRoot, { store, onExit }), {
-    exitOnCtrlC: false
-  });
-  return Promise.all(records.map(startRecord)).then(() => q.promise);
+	const store = createTuiStore();
+	const records = [];
+	const isSingle = definitions.length === 1;
+	if (props.watch) store.setSystem({
+		ts: Date.now(),
+		level: "warn",
+		text: "TUI does not yet support --watch mode;"
+	});
+	for (let i = 0; i < definitions.length; i++) {
+		const def = definitions[i];
+		const appId = appIdFor(def, i);
+		const appProps = getAppProps(def, props, isSingle);
+		const threadCount = resolveThreadCount(appProps);
+		appProps.__inheritIO = false;
+		delete appProps.threads;
+		const appNode = {
+			kind: "app",
+			id: appId,
+			name: def.name,
+			state: APP_INSTANCE_STATE.INIT,
+			expanded: false,
+			threads: []
+		};
+		store.addApp(appNode);
+		const threads = [];
+		const threadNodes = [];
+		for (let threadId = 1; threadId <= threadCount; threadId++) {
+			const nodeId = `${appId}:${threadId}`;
+			const threadNode = {
+				id: `${appId}:${threadId}`,
+				kind: "thread",
+				name: `${appNode.name}.${threadId}`,
+				parentId: appId,
+				threadId,
+				pid: 0,
+				state: APP_INSTANCE_STATE.INIT
+			};
+			threadNodes.push(threadNode);
+			const w = initThread(threadId, def.filePath, appProps);
+			w.eventBus.on("log", (entry) => {
+				store.pushLog(nodeId, {
+					ts: entry.ts,
+					level: entry.level,
+					text: entry.text
+				});
+			});
+			w.eventBus.on("state", (newState) => {
+				store.setState(nodeId, newState);
+				store.setState(appId, aggregateAppState(threads));
+			});
+			w.eventBus.on("pid", (pid) => {
+				store.setPid(nodeId, pid);
+			});
+			w.eventBus.on("error", (err) => {
+				store.pushLog(nodeId, {
+					ts: Date.now(),
+					level: "error",
+					text: `Thread error: ${err.message}`
+				});
+			});
+			threads.push(w);
+		}
+		store.setThreads(appId, threadNodes);
+		records.push({
+			appId,
+			node: appNode,
+			threads
+		});
+	}
+	const findRecordByAppId = (id) => records.find((r) => r.appId === id);
+	const findThread = (id) => {
+		for (const r of records) for (const w of r.threads) if (`${r.appId}:${w.threadId}` === id) return {
+			record: r,
+			thread: w
+		};
+	};
+	const startSingleThread = (w) => {
+		if (w.state === APP_INSTANCE_STATE.IN_RUN || APP_INSTANCE_STATE.RUN) return Promise.resolve();
+		if (w.state === APP_INSTANCE_STATE.STOP) return startThreadApp(w);
+		return setupThreadApp(w).then(() => startThreadApp(w));
+	};
+	store.handlers = {
+		stop(id) {
+			const r = findRecordByAppId(id);
+			if (r) return Promise.all(r.threads.map((w) => stopThreadApp(w))).then(() => {});
+			const found = findThread(id);
+			if (found) return stopThreadApp(found.thread);
+			return Promise.resolve();
+		},
+		start(id) {
+			const r = findRecordByAppId(id);
+			if (r) return Promise.all(r.threads.map(startSingleThread)).then(() => {});
+			const found = findThread(id);
+			if (found) return startSingleThread(found.thread);
+			return Promise.resolve();
+		},
+		restart(id) {
+			const r = findRecordByAppId(id);
+			if (r) return Promise.all(r.threads.map((w) => {
+				w.restartCount = 0;
+				return restartThreadApp(w);
+			})).then(() => {});
+			const found = findThread(id);
+			if (found) {
+				found.thread.restartCount = 0;
+				return restartThreadApp(found.thread);
+			}
+			return Promise.resolve();
+		}
+	};
+	const startRecord = (r) => Promise.all(r.threads.map((w) => waitForThreadReady(w).then(() => setupThreadApp(w)).then(() => startThreadApp(w)))).then(noop);
+	onShutdownError((error) => {
+		console.error("[Graceful Shutdown] error:", error);
+	});
+	const q = defer();
+	onShutdown("app", () => {
+		store.setSystem({
+			ts: Date.now(),
+			level: "warn",
+			text: "shutdown initiated"
+		});
+		return Promise.all(records.map((r) => Promise.all(r.threads.map((w) => shutdownThreadApp(w))))).then(() => {
+			store.setSystem({
+				ts: Date.now(),
+				level: "info",
+				text: "shutdown complete"
+			});
+		}).then(() => inkInstance.waitUntilRenderFlush()).then(() => inkInstance.unmount()).then(() => q.resolve()).catch(console.error);
+	});
+	const onExit = () => {
+		return Promise.resolve().then(() => processGraceful());
+	};
+	const inkInstance = render(/* @__PURE__ */ jsx(TuiRoot, {
+		store,
+		onExit
+	}), { exitOnCtrlC: false });
+	return Promise.all(records.map(startRecord)).then(() => q.promise);
 }
-
 const DB_PATH = path.join(os.tmpdir(), "vrun.json");
-class TempDB {
-  constructor(filepath) {
-    this.filepath = filepath;
-  }
-  _storage = /* @__PURE__ */ new Map();
-  _dirty = false;
-  get isDirty() {
-    return this._dirty;
-  }
-  get(key) {
-    return this._storage.get(key);
-  }
-  set(key, value) {
-    this._storage.set(key, value);
-    this._dirty = true;
-  }
-  save() {
-    if (!this._dirty) return;
-    const data = EJSON.stringify(Array.from(this._storage.entries()));
-    fs.writeFileSync(this.filepath, data);
-    this._dirty = false;
-  }
-  load() {
-    try {
-      const data = EJSON.parse(fs.readFileSync(this.filepath, "utf-8"));
-      for (const [key, value] of data) {
-        this._storage.set(key, value);
-      }
-      return true;
-    } catch (_) {
-      return false;
-    }
-  }
-}
+var TempDB = class {
+	filepath;
+	_storage = /* @__PURE__ */ new Map();
+	_dirty = false;
+	constructor(filepath) {
+		this.filepath = filepath;
+	}
+	get isDirty() {
+		return this._dirty;
+	}
+	get(key) {
+		return this._storage.get(key);
+	}
+	set(key, value) {
+		this._storage.set(key, value);
+		this._dirty = true;
+	}
+	save() {
+		if (!this._dirty) return;
+		const data = EJSON.stringify(Array.from(this._storage.entries()));
+		fs.writeFileSync(this.filepath, data);
+		this._dirty = false;
+	}
+	load() {
+		try {
+			const data = EJSON.parse(fs.readFileSync(this.filepath, "utf-8"));
+			for (const [key, value] of data) this._storage.set(key, value);
+			return true;
+		} catch (_) {
+			return false;
+		}
+	}
+};
 const db = new TempDB(DB_PATH);
 db.load();
-
 const TYPE_TO_PLACEHOLDER = /* @__PURE__ */ new Map([
-  [String, "<string>"],
-  [Boolean, "<boolean>"],
-  [Number, "<number>"],
-  [Date, "<date>"],
-  [Array, "<array>"]
+	[String, "<string>"],
+	[Number, "<number>"],
+	[BigInt, "<bigint>"],
+	[Date, "<date>"],
+	[Array, "<array>"]
 ]);
 function propsToOptions(props) {
-  const result = [];
-  for (const [
-    name,
-    {
-      description,
-      type,
-      default: defaultValue,
-      required,
-      enum: variants,
-      alias,
-      env,
-      parser
-    }
-  ] of Object.entries(props)) {
-    const flagName = kebabCase(name);
-    const typePlaceholder = TYPE_TO_PLACEHOLDER.get(type);
-    const envVariables = arrayable(env);
-    const option = new Option(
-      [alias ? `-${alias}, ` : "", `--${flagName}`, typePlaceholder].filter(Boolean).join(" "),
-      description
-    );
-    if (variants?.length) {
-      option.choices(variants);
-    }
-    if (envVariables.length) {
-      option.env(envVariables.join(", "));
-      option.default(getEnv(envVariables) || defaultValue?.());
-    } else if (defaultValue) {
-      option.default(defaultValue());
-    }
-    if (required) {
-      option.mandatory = true;
-    }
-    option.attributeName();
-    switch (type) {
-      case Boolean: {
-        option.isBoolean();
-        break;
-      }
-      case Number: {
-        option.argParser(parseNumberArgument);
-      }
-    }
-    if (parser) {
-      option.argParser(parser);
-    }
-    result.push(option);
-  }
-  return result;
+	const result = [];
+	for (const [name, { description, type, default: defaultValue, required, enum: variants, alias, env, parser }] of Object.entries(props)) {
+		const flagName = kebabCase(name);
+		const typePlaceholder = TYPE_TO_PLACEHOLDER.get(type);
+		const envVariables = arrayable(env);
+		const option = new Option([
+			alias ? `-${alias}, ` : "",
+			`--${flagName}`,
+			typePlaceholder
+		].filter(Boolean).join(" "), description);
+		if (variants?.length) option.choices(variants);
+		if (envVariables.length) {
+			option.env(envVariables.join(", "));
+			option.default(getEnv(envVariables) || defaultValue?.());
+		} else if (defaultValue) option.default(defaultValue());
+		if (required) option.mandatory = true;
+		option.attributeName();
+		switch (type) {
+			case Number:
+				option.argParser(parseNumberArgument);
+				break;
+			case BigInt:
+				option.argParser(parseBigintArgument);
+				break;
+		}
+		if (parser) option.argParser(parser);
+		result.push(option);
+	}
+	return result;
 }
 function getEnv(variables) {
-  for (const env of variables) {
-    const value = process.env[env];
-    if (value) {
-      return value;
-    }
-  }
+	for (const env of variables) {
+		const value = process.env[env];
+		if (value) return value;
+	}
 }
 function parseNumberArgument(value) {
-  const parsedValue = parseInt(value, 10);
-  if (!isNumber(parsedValue)) {
-    throw new InvalidArgumentError("Not a number.");
-  }
-  return parsedValue;
-}
-
-function runApp({
-  scriptFile,
-  cliName = "app",
-  cliDescription = "Application cli",
-  argv = process.argv
-}) {
-  const promise = scriptFile ? loadScriptCommand(scriptFile) : Promise.resolve(buildRootCommand({ cliName, cliDescription }));
-  return promise.then((program) => program.parseAsync(["node", cliName, ...argv])).then(noop).catch((error) => {
-    log.error("Failed to run app:", error);
-    process.exit(1);
-  });
-}
-function buildRootCommand({
-  cliDescription,
-  cliName
-}) {
-  const program = new Command().name(cliName).description(cliDescription).enablePositionalOptions().passThroughOptions().helpOption(false).helpCommand(false).action(function() {
-    const cmd = this;
-    if (isHelpArgument(cmd.args)) {
-      return cmd.help();
-    }
-  });
-  program.command("start", { isDefault: true }).argument("<string...>", "Path to script file").description("Start application.").addOption(new Option("--watch", "Watch file changes")).addOption(new Option("--dev", "Allow to import ts files")).passThroughOptions(true).allowUnknownOption(true).allowExcessArguments(true).action(function(scriptFiles, _opts) {
-    assert.arrayStrings(scriptFiles, "scriptFiles expected string[]");
-    const cmd = this;
-    const remainingArgs = cmd.args;
-    const flagIdx = scriptFiles.findIndex((v) => v.startsWith("-"));
-    scriptFiles = (flagIdx > -1 ? scriptFiles.slice(0, flagIdx) : scriptFiles).filter((v) => !v.startsWith("-"));
-    if (!scriptFiles.length) {
-      return cmd.parent?.args?.includes("start") ? cmd.help() : program.help();
-    }
-    const project = createProject(path.resolve(scriptFiles[0]));
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(
-      () => Promise.all(scriptFiles.map((f) => loadAppDefinition(project, f)))
-    ).then((apps) => buildStartCommand(apps)).then((appCmd) => {
-      if (isHelpArgument(remainingArgs)) {
-        return appCmd.help();
-      }
-      return appCmd.parseAsync(remainingArgs, { from: "user" });
-    }).then(noop);
-  });
-  program.command("json").description(
-    "Start apps from a JSON file containing an array of script paths."
-  ).argument("[string]", "Path to JSON file").allowUnknownOption(true).allowExcessArguments(true).action(function(jsonFile) {
-    const cmd = this;
-    if (!jsonFile || isHelpArgument(jsonFile)) {
-      return cmd.help();
-    }
-    const project = createProject(path.dirname(path.resolve(jsonFile)));
-    const remainingArgs = cmd.args;
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(
-      () => projectImportFile(
-        project,
-        path.resolve(jsonFile)
-      )
-    ).then((m) => {
-      const paths = m.default;
-      assert.arrayStrings(paths, "JSON file must contain a string[].");
-      return paths.map(
-        (p) => path.resolve(path.dirname(path.resolve(jsonFile)), p)
-      );
-    }).then(
-      (scriptFiles) => Promise.all(scriptFiles.map((f) => loadAppDefinition(project, f)))
-    ).then((apps) => buildStartCommand(apps)).then((appCmd) => {
-      if (isHelpArgument(remainingArgs)) {
-        return appCmd.help();
-      }
-      return appCmd.parseAsync(remainingArgs, { from: "user" });
-    }).then(noop);
-  });
-  program.command("list").description("Interactively pick apps to run from a folder.").argument("[string]", "Path to folder", ".").addOption(
-    new Option("--pattern <glob>", "Glob pattern for app files").default(
-      "**/*.{app,worker}.{ts,js}"
-    )
-  ).allowUnknownOption(true).allowExcessArguments(true).action(function(folderPath, opts) {
-    const cmd = this;
-    if (isHelpArgument(cmd.args)) {
-      return cmd.help();
-    }
-    const remainingArgs = cmd.args;
-    const project = createProject(path.resolve(folderPath));
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path.resolve(folderPath), opts.pattern)).then((scriptFiles) => {
-      if (!scriptFiles.length) {
-        log.error("No files found. Pattern: %s", opts.pattern);
-        process.exit(1);
-      }
-      return log.prompt("Pick apps to run.", {
-        type: "multiselect",
-        options: scriptFiles.map((f) => ({
-          label: path.basename(f),
-          value: f
-        })),
-        initial: db.get("app_last_run"),
-        cancel: "null"
-      });
-    }).then((selected) => {
-      const selectedFiles = selected || [];
-      if (!selectedFiles.length) process.exit(0);
-      db.set("app_last_run", selectedFiles);
-      db.save();
-      return Promise.all(
-        selectedFiles.map((f) => loadAppDefinition(project, f))
-      );
-    }).then((apps) => buildStartCommand(apps)).then((appCmd) => {
-      if (isHelpArgument(remainingArgs)) {
-        return appCmd.help();
-      }
-      return appCmd.parseAsync(remainingArgs, { from: "user" });
-    }).then(noop);
-  });
-  program.command("folder").description("Start all apps found in a folder.").argument("<string>", "Path to folder").addOption(
-    new Option("--pattern <glob>", "Glob pattern for app files").default(
-      "**/*.{ts,js}"
-    )
-  ).allowUnknownOption(true).allowExcessArguments(true).action(function(folderPath, opts) {
-    const cmd = this;
-    if (!folderPath || isHelpArgument(folderPath)) {
-      return cmd.help();
-    }
-    const remainingArgs = cmd.args;
-    const project = createProject(path.resolve(folderPath));
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path.resolve(folderPath), opts.pattern)).then((scriptFiles) => {
-      if (!scriptFiles.length) {
-        log.error("No files found. Pattern: %s", opts.pattern);
-        process.exit(1);
-      }
-      return Promise.all(
-        scriptFiles.map((f) => loadAppDefinition(project, f))
-      );
-    }).then((apps) => {
-      if (!apps.length) {
-        log.error("No valid AppDefinitions found in folder.");
-        process.exit(1);
-      }
-      return apps;
-    }).then((apps) => buildStartCommand(apps)).then((appCmd) => {
-      if (isHelpArgument(remainingArgs)) {
-        return appCmd.help();
-      }
-      return appCmd.parseAsync(remainingArgs, { from: "user" });
-    }).then(noop);
-  });
-  return program;
+	const parsedValue = parseInt(value, 10);
+	if (!isNumber(parsedValue)) throw new InvalidArgumentError("Not a number.");
+	return parsedValue;
+}
+function parseBigintArgument(value) {
+	try {
+		return BigInt(value);
+	} catch (_) {
+		throw new InvalidArgumentError("Not a big number.");
+	}
+}
+function runApp$1({ scriptFile, cliName = "app", cliDescription = "Application cli", argv = process.argv }) {
+	return (scriptFile ? loadScriptCommand(scriptFile) : Promise.resolve(buildRootCommand({
+		cliName,
+		cliDescription
+	}))).then((program) => program.parseAsync([
+		"node",
+		cliName,
+		...argv
+	])).then(noop).catch((error) => {
+		log.error("Failed to run app:", error);
+		process.exit(1);
+	});
+}
+function buildRootCommand({ cliDescription, cliName }) {
+	const program = new Command().name(cliName).description(cliDescription).enablePositionalOptions().passThroughOptions().helpOption(false).helpCommand(false).action(function() {
+		const cmd = this;
+		if (isHelpArgument(cmd.args)) return cmd.help();
+	});
+	program.command("start", { isDefault: true }).argument("<string...>", "Path to script file").description("Start application.").addOption(new Option("--watch", "Watch file changes")).addOption(new Option("--dev", "Allow to import ts files")).passThroughOptions(true).allowUnknownOption(true).allowExcessArguments(true).action(function(scriptFiles, _opts) {
+		assert.arrayStrings(scriptFiles, "scriptFiles expected string[]");
+		const cmd = this;
+		const remainingArgs = cmd.args;
+		const flagIdx = scriptFiles.findIndex((v) => v.startsWith("-"));
+		scriptFiles = (flagIdx > -1 ? scriptFiles.slice(0, flagIdx) : scriptFiles).filter((v) => !v.startsWith("-"));
+		if (!scriptFiles.length) return cmd.parent?.args?.includes("start") ? cmd.help() : program.help();
+		const project = createProject(path.resolve(scriptFiles[0]));
+		return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => Promise.all(scriptFiles.map((f) => loadAppDefinition(project, f)))).then((apps) => buildStartCommand(apps)).then((appCmd) => {
+			if (isHelpArgument(remainingArgs)) return appCmd.help();
+			return appCmd.parseAsync(remainingArgs, { from: "user" });
+		}).then(noop);
+	});
+	program.command("json").description("Start apps from a JSON file containing an array of script paths.").argument("[string]", "Path to JSON file").allowUnknownOption(true).allowExcessArguments(true).action(function(jsonFile) {
+		const cmd = this;
+		if (!jsonFile || isHelpArgument(jsonFile)) return cmd.help();
+		const project = createProject(path.dirname(path.resolve(jsonFile)));
+		const remainingArgs = cmd.args;
+		return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => projectImportFile(project, path.resolve(jsonFile))).then((m) => {
+			const paths = m.default;
+			assert.arrayStrings(paths, "JSON file must contain a string[].");
+			return paths.map((p) => path.resolve(path.dirname(path.resolve(jsonFile)), p));
+		}).then((scriptFiles) => Promise.all(scriptFiles.map((f) => loadAppDefinition(project, f)))).then((apps) => buildStartCommand(apps)).then((appCmd) => {
+			if (isHelpArgument(remainingArgs)) return appCmd.help();
+			return appCmd.parseAsync(remainingArgs, { from: "user" });
+		}).then(noop);
+	});
+	program.command("list").description("Interactively pick apps to run from a folder.").argument("[string]", "Path to folder", ".").addOption(new Option("--pattern <glob>", "Glob pattern for app files").default("**/*.{app,worker}.{ts,js}")).allowUnknownOption(true).allowExcessArguments(true).action(function(folderPath, opts) {
+		const cmd = this;
+		if (isHelpArgument(cmd.args)) return cmd.help();
+		const remainingArgs = cmd.args;
+		const project = createProject(path.resolve(folderPath));
+		return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path.resolve(folderPath), opts.pattern)).then((scriptFiles) => {
+			if (!scriptFiles.length) {
+				log.error("No files found. Pattern: %s", opts.pattern);
+				process.exit(1);
+			}
+			return log.prompt("Pick apps to run.", {
+				type: "multiselect",
+				options: scriptFiles.map((f) => ({
+					label: path.basename(f),
+					value: f
+				})),
+				initial: db.get("app_last_run"),
+				cancel: "null"
+			});
+		}).then((selected) => {
+			const selectedFiles = selected || [];
+			if (!selectedFiles.length) process.exit(0);
+			db.set("app_last_run", selectedFiles);
+			db.save();
+			return Promise.all(selectedFiles.map((f) => loadAppDefinition(project, f)));
+		}).then((apps) => buildStartCommand(apps)).then((appCmd) => {
+			if (isHelpArgument(remainingArgs)) return appCmd.help();
+			return appCmd.parseAsync(remainingArgs, { from: "user" });
+		}).then(noop);
+	});
+	program.command("folder").description("Start all apps found in a folder.").argument("<string>", "Path to folder").addOption(new Option("--pattern <glob>", "Glob pattern for app files").default("**/*.{ts,js}")).allowUnknownOption(true).allowExcessArguments(true).action(function(folderPath, opts) {
+		const cmd = this;
+		if (!folderPath || isHelpArgument(folderPath)) return cmd.help();
+		const remainingArgs = cmd.args;
+		const project = createProject(path.resolve(folderPath));
+		return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path.resolve(folderPath), opts.pattern)).then((scriptFiles) => {
+			if (!scriptFiles.length) {
+				log.error("No files found. Pattern: %s", opts.pattern);
+				process.exit(1);
+			}
+			return Promise.all(scriptFiles.map((f) => loadAppDefinition(project, f)));
+		}).then((apps) => {
+			if (!apps.length) {
+				log.error("No valid AppDefinitions found in folder.");
+				process.exit(1);
+			}
+			return apps;
+		}).then((apps) => buildStartCommand(apps)).then((appCmd) => {
+			if (isHelpArgument(remainingArgs)) return appCmd.help();
+			return appCmd.parseAsync(remainingArgs, { from: "user" });
+		}).then(noop);
+	});
+	return program;
 }
 function findAppFiles(folderPath, pattern) {
-  return fs.globSync(pattern, {
-    cwd: folderPath,
-    exclude: (f) => f.includes("node_modules")
-  }).map((f) => path.resolve(folderPath, f)).sort();
+	return fs.globSync(pattern, {
+		cwd: folderPath,
+		exclude: (f) => f.includes("node_modules")
+	}).map((f) => path.resolve(folderPath, f)).sort();
 }
 function loadScriptCommand(scriptFile) {
-  const project = createProject(path.dirname(scriptFile));
-  return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => loadAppDefinition(project, scriptFile)).then((app) => buildStartCommand([app]));
+	const project = createProject(path.dirname(scriptFile));
+	return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => loadAppDefinition(project, scriptFile)).then((app) => buildStartCommand([app]));
 }
 function registerTsx(project) {
-  if (CONFIG.TS_MODE === "tsx") {
-    project.allowTs = true;
-    return Promise.resolve();
-  }
-  if (CONFIG.TS_MODE === "tsx-register") {
-    return Promise.resolve().then(() => import('tsx/esm/api')).then((m) => m.register({ tsconfig: project.tsconfigPath || false })).then(() => {
-      project.allowTs = true;
-    });
-  }
-  return Promise.resolve();
+	if (CONFIG.TS_MODE === "tsx") {
+		project.allowTs = true;
+		return Promise.resolve();
+	}
+	if (CONFIG.TS_MODE === "tsx-register") return Promise.resolve().then(() => import("tsx/esm/api")).then((m) => m.register({ tsconfig: project.tsconfigPath || false })).then(() => {
+		project.allowTs = true;
+	});
+	return Promise.resolve();
 }
 function loadProject(project) {
-  projectPrintInfo(project);
-  return Promise.resolve().then(() => projectLoadEnv(project)).then(() => projectAutoImport(project)).then(noop);
+	projectPrintInfo(project);
+	return Promise.resolve().then(() => projectLoadEnv(project)).then(() => projectAutoImport(project)).then(noop);
 }
 function loadAppDefinition(project, scriptFile) {
-  return projectImportFile(project, scriptFile).then((appModule) => {
-    const app = appModule.default;
-    if (!isAppDefinition(app)) {
-      log.warn(`Default export must be a app definition: ${scriptFile}`);
-      process.exit(1);
-    }
-    return app;
-  });
+	return projectImportFile(project, scriptFile).then((appModule) => {
+		const app = appModule.default;
+		if (!isAppDefinition(app)) {
+			log.warn(`Default export must be a app definition: ${scriptFile}`);
+			process.exit(1);
+		}
+		return app;
+	});
 }
 function buildStartCommand(definitions) {
-  const rootDefinition = definitions.length > 1 ? createAppHub(definitions.map((v) => createAppThread(v))) : createAppThread(definitions[0]);
-  const program = new Command().name(rootDefinition.name).description(rootDefinition.description || "An application");
-  if (rootDefinition.props) {
-    for (const option of propsToOptions(rootDefinition.props)) {
-      program.addOption(option);
-    }
-  }
-  program.addOption(new Option("--watch", "Watch file changes")).addOption(new Option("--dev", "Allow to import ts files")).addOption(new Option("--tui", "Launch interactive terminal UI")).helpCommand(false).command("start", { isDefault: true, hidden: true }).allowUnknownOption(true).allowExcessArguments(true).action((...args) => {
-    const props = program.optsWithGlobals();
-    if (props.tui) {
-      return launchAppsTui(definitions, props);
-    }
-    return launchApp(
-      definitions.length > 1 || props.threads > 1 ? rootDefinition : definitions[0],
-      props
-    );
-  });
-  return program;
+	const rootDefinition = definitions.length > 1 ? createAppHub(definitions.map((v) => createAppThread(v))) : createAppThread(definitions[0]);
+	const program = new Command().name(rootDefinition.name).description(rootDefinition.description || "An application");
+	if (rootDefinition.props) for (const option of propsToOptions(rootDefinition.props)) program.addOption(option);
+	program.addOption(new Option("--watch", "Watch file changes")).addOption(new Option("--dev", "Allow to import ts files")).addOption(new Option("--tui", "Launch interactive terminal UI")).helpCommand(false).command("start", {
+		isDefault: true,
+		hidden: true
+	}).allowUnknownOption(true).allowExcessArguments(true).action((...args) => {
+		const props = program.optsWithGlobals();
+		if (props.tui) return launchAppsTui(definitions, props);
+		return launchApp(definitions.length > 1 || props.threads > 1 ? rootDefinition : definitions[0], props);
+	});
+	return program;
 }
 function launchApp(definition, props) {
-  const startDefer = defer();
-  let app;
-  onShutdown("app", () => {
-    log.warn("Graceful shutdown initiated, waiting for process to complete");
-    if (CONFIG.TS_MODE === "tsx") {
-      log.warn("Graceful in tsx + watch mode is not supported.");
-    }
-    return startDefer.promise.then(() => {
-      if (app) {
-        return shutdownApp(app);
-      }
-    });
-  });
-  return startApp(definition, props).then((startResult) => {
-    if (isSkip(startResult)) {
-      startDefer.resolve();
-      log.warn("Failed to start %s", startResult, startResult.error);
-      return;
-    }
-    app = startResult.app;
-    startDefer.resolve();
-    return appWaitShutdown(app);
-  }).then(() => processGraceful());
-}
-
-const cli = Object.freeze({
-  runApp
-});
-
-const index = {
-  __proto__: null,
-  cli: cli
+	const startDefer = defer();
+	let app;
+	onShutdown("app", () => {
+		log.warn("Graceful shutdown initiated, waiting for process to complete");
+		if (CONFIG.TS_MODE === "tsx") log.warn("Graceful in tsx + watch mode is not supported.");
+		return startDefer.promise.then(() => {
+			if (app) return shutdownApp(app);
+		});
+	});
+	return startApp(definition, props).then((startResult) => {
+		if (isSkip(startResult)) {
+			startDefer.resolve();
+			log.warn("Failed to start %s", startResult, startResult.error);
+			return;
+		}
+		app = startResult.app;
+		startDefer.resolve();
+		return appWaitShutdown(app);
+	}).then(() => processGraceful());
+}
+const cli = Object.freeze({ runApp: runApp$1 });
+var IntervalStrategy = class {
+	options;
+	timerSequence = 0;
+	timer = null;
+	worker;
+	warnOnBusy;
+	constructor(options) {
+		this.options = options;
+		this.warnOnBusy = options.warnOnBusy ?? true;
+	}
+	doSetup({ worker }) {
+		this.worker = worker;
+	}
+	startSignal() {
+		this.timer = setInterval(() => {
+			if (this.worker.isIdle) this.worker.addTask(this.createTask());
+			else if (this.warnOnBusy) log.warn("[%s] Worker busy, skipping tick", this.worker.definition.name);
+		}, this.options.intervalSeconds * 1e3);
+	}
+	stopSignal(done) {
+		clearInterval(this.timer);
+		this.timer = null;
+		done();
+	}
+	doShutdown() {}
+	createTask() {
+		return { timerSequence: ++this.timerSequence };
+	}
 };
-
-class IntervalStrategy {
-  constructor(options) {
-    this.options = options;
-  }
-  timerSequence = 0;
-  timer = null;
-  worker;
-  doSetup({ worker }) {
-    this.worker = worker;
-  }
-  startSignal() {
-    this.timer = setInterval(() => {
-      if (this.worker.isIdle) {
-        this.worker.addTask(this.createTask());
-      } else {
-        log.warn(
-          "[%s] Worker busy, skipping tick",
-          this.worker.definition.name
-        );
-      }
-    }, this.options.intervalSeconds * 1e3);
-  }
-  stopSignal(done) {
-    clearInterval(this.timer);
-    this.timer = null;
-    done();
-  }
-  doShutdown() {
-  }
-  createTask() {
-    return { timerSequence: ++this.timerSequence };
-  }
-}
-
 const WORKER_DEF = Symbol("worker-definition");
 function createWorkerPool(size) {
-  return new ResourcePool({
-    poolSize: size,
-    auto: true,
-    createResource: () => Symbol("worker-slot")
-  });
+	return new ResourcePool({
+		poolSize: size,
+		auto: true,
+		createResource: () => Symbol("worker-slot")
+	});
 }
 function createWorkerInstance(definition, logger) {
-  const instance = {
-    definition,
-    log: logger,
-    queue: new AsyncIterableQueue(),
-    pool: createWorkerPool(definition.taskParallel ?? 2),
-    runTask: null,
-    queueMaxSize: definition.taskLimit ?? 50,
-    taskParallel: definition.taskParallel ?? 2,
-    overloadedSignaled: false,
-    addTask(ctx) {
-      addWorkerTask(this, ctx);
-    },
-    get isOverloaded() {
-      return this.queueSize > this.queueMaxSize * 0.8;
-    },
-    get isIdle() {
-      return this.pool.isIdle && this.queueSize === 0;
-    },
-    get queueSize() {
-      return this.queue._queue.items.length;
-    }
-  };
-  return instance;
+	return {
+		definition,
+		executeStrategy: null,
+		log: logger,
+		queue: new AsyncIterableQueue(),
+		pool: createWorkerPool(definition.taskParallel ?? 2),
+		runTask: null,
+		queueMaxSize: definition.taskLimit ?? 50,
+		taskParallel: definition.taskParallel ?? 2,
+		overloadedSignaled: false,
+		addTask(ctx) {
+			addWorkerTask(this, ctx);
+		},
+		get isOverloaded() {
+			return this.queueSize > this.queueMaxSize * .8;
+		},
+		get isIdle() {
+			return this.pool.isIdle && this.queueSize === 0;
+		},
+		get queueSize() {
+			return this.queue._queue.items.length;
+		}
+	};
 }
 function addWorkerTask(instance, ctx) {
-  instance.queue.put(ctx);
-  checkWorkerPressure(instance);
-}
-async function executeWorkerTask(instance, entryContext, props, abortSignal) {
-  const { executeStrategy, entry } = instance.definition;
-  if (isFunction(executeStrategy.executeSignal)) {
-    const [signalError, signalResult] = await catchError(
-      () => executeStrategy.executeSignal(entryContext)
-    );
-    if (signalError) {
-      instance.log.error("Strategy executeSignal error, dropping task", {
-        error: signalError
-      });
-      return;
-    }
-    if (isSkip(signalResult)) {
-      instance.log.warn(
-        "Strategy executeSignal returned skip, dropping task",
-        signalResult
-      );
-      return;
-    }
-  }
-  let [executeError, executeResult] = await catchError(
-    () => entry?.call(entryContext, props)
-  );
-  if (executeError) {
-    if (executeStrategy.handleEntryError) {
-      executeResult = executeStrategy.handleEntryError(executeError);
-    }
-    if (!executeResult) {
-      executeResult = {
-        skip: true,
-        error: true,
-        code: "critical_error",
-        reason: executeError.message,
-        stack: executeError.stack
-      };
-    }
-  } else if (!executeResult || Array.isArray(executeResult) && !executeResult.length) {
-    executeResult = { success: true, code: "void" };
-  }
-  const results = Array.isArray(executeResult) ? executeResult : [executeResult];
-  let hasError = false;
-  let hasSkip = false;
-  for (const result of results) {
-    hasError = hasError || isSkip(result) && !!result.error;
-    hasSkip = isSkip(result);
-  }
-  if (hasError) {
-    instance.log.error("Task error", results);
-  } else if (hasSkip) {
-    instance.log.warn("Task skipped", results);
-  } else {
-    instance.log.debug("Task completed", results);
-  }
-  if (executeStrategy.completeSignal) {
-    const [completeError] = await catchError(
-      () => executeStrategy.completeSignal(entryContext, executeResult)
-    );
-    if (completeError) {
-      instance.log.error("Strategy completeSignal error", {
-        error: completeError
-      });
-    }
-  }
+	instance.queue.put(ctx);
+	checkWorkerPressure(instance);
+}
+var NOOP_EXECUTE_SIGNAL = () => ({
+	success: true,
+	code: "ok"
+});
+function executeWorkerTask(instance, entryContext, props, abortSignal) {
+	const { log } = instance;
+	const entry = instance.definition.entry || noop;
+	const executeStrategy = instance.executeStrategy;
+	const completeSignal = executeStrategy.completeSignal || noop;
+	const executeSignal = executeStrategy.executeSignal || NOOP_EXECUTE_SIGNAL;
+	return Promise.resolve().then(() => catchError(() => executeSignal(entryContext))).then(({ 0: signalError, 1: signalResult }) => {
+		if (signalError) {
+			log.error("Strategy executeSignal error, dropping task", { error: signalError });
+			return;
+		} else if (isSkip(signalResult)) {
+			log.warn("Strategy executeSignal returned skip, dropping task", signalResult);
+			return;
+		}
+		const taskAbort = new AbortController();
+		const handleAbort = () => {
+			if (!taskAbort.signal.aborted) taskAbort.abort(abortSignal.reason);
+		};
+		abortSignal.addEventListener("abort", handleAbort);
+		return Promise.resolve().then(() => catchError(() => entry.call(entryContext, props, taskAbort.signal))).then(({ 0: executeError, 1: executeResult }) => {
+			abortSignal.removeEventListener("abort", handleAbort);
+			if (executeError) {
+				if (executeStrategy.handleEntryError) executeResult = executeStrategy.handleEntryError(executeError);
+				if (!executeResult) executeResult = {
+					skip: true,
+					error: true,
+					code: "critical_error",
+					reason: executeError.message,
+					stack: executeError.stack
+				};
+			} else if (!executeResult || Array.isArray(executeResult) && !executeResult.length) executeResult = {
+				success: true,
+				code: "void"
+			};
+			const results = arrayable(executeResult);
+			let hasError = false;
+			let hasSkip = false;
+			for (const result of results) {
+				hasError = hasError || isSkip(result) && !!result.error;
+				hasSkip = isSkip(result);
+			}
+			if (hasError) log.error("Task error", results);
+			else if (hasSkip) log.warn("Task skipped", results);
+			else log.debug("Task completed", results);
+			return catchError(() => completeSignal(entryContext, executeResult));
+		}).then(({ 0: completeError }) => {
+			if (completeError) log.error("Strategy completeSignal error", { error: completeError });
+		});
+	});
 }
 function defineWorker(definition) {
-  const result = defineApp({
-    filePath: filePathFromStack(captureStackTrace(defineWorker)),
-    ...definition,
-    setup(props) {
-      return setupWorker(this, definition, props);
-    },
-    entry(props) {
-      return runWorkerLoop(this, definition, props);
-    },
-    stop(props) {
-      return stopWorker(this, definition, props);
-    },
-    shutdown(props) {
-      return shutdownWorker(this, definition, props);
-    }
-  });
-  result.disabled = result.disabled || CONFIG.WORKER_DISABLED.has(result.name);
-  def(result, WORKER_DEF, true);
-  return result;
+	const result = defineApp({
+		filePath: filePathFromStack(captureStackTrace(defineWorker)),
+		...definition,
+		setup(props) {
+			return setupWorker(this, definition, props);
+		},
+		entry(props) {
+			return runWorkerLoop(this, props);
+		},
+		stop(props) {
+			return stopWorker(this, props);
+		},
+		shutdown(props) {
+			return shutdownWorker(this, props);
+		}
+	});
+	result.disabled = result.disabled || CONFIG.WORKER_DISABLED.has(result.name);
+	def(result, WORKER_DEF, true);
+	return result;
 }
 function setupWorker(setupContext, definition, props) {
-  const setupFn = definition.setup;
-  const ctx = {
-    ...setupContext,
-    worker: createWorkerInstance(definition, setupContext.log)
-  };
-  return Promise.resolve().then(() => setupFn ? setupFn.call(ctx, props) : void 0).then((setupResult) => {
-    return {
-      ...ctx,
-      ...setupResult || {}
-    };
-  });
-}
-async function runWorkerLoop(runtimeContext, definition, props) {
-  const worker = runtimeContext.worker;
-  const { executeStrategy } = definition;
-  await executeStrategy.doSetup({ worker });
-  const abortController = new AbortController();
-  abortController.signal;
-  const onStopSignal = () => {
-    return Promise.resolve().then(() => abortController.abort()).then(
-      () => catchError(
-        () => executeStrategy.stopSignal(() => worker.queue.close())
-      )
-    ).then((stopResult) => {
-      const stopError = stopResult[0];
-      if (stopError) {
-        worker.queue.close();
-        worker.log.error("Strategy stopSignal error", { error: stopError });
-      }
-    });
-  };
-  worker.runTask = new CancellablePromise(
-    async (resolve, _reject, onCancel) => {
-      onCancel(onStopSignal);
-      const [startError] = await catchError(
-        () => executeStrategy.startSignal()
-      );
-      if (startError) {
-        worker.log.error("Strategy startSignal error", { error: startError });
-        worker.runTask = null;
-        return resolve();
-      }
-      worker.log.info("Worker started (parallel=%d)", worker.taskParallel);
-      for await (const taskContext of worker.queue) {
-        const jobTicket = await worker.pool.acquire();
-        const entryContext = {
-          ...runtimeContext,
-          ...taskContext
-        };
-        executeWorkerTask(worker, entryContext, props).finally(
-          () => {
-            worker.pool.release(jobTicket);
-            checkWorkerPressure(worker);
-          }
-        );
-      }
-      if (worker.pool.usedCount > 0) {
-        worker.log.info(
-          "Draining task pool (active=%d)",
-          worker.pool.usedCount
-        );
-      }
-      await worker.pool.destroy();
-      worker.queue = new AsyncIterableQueue();
-      worker.runTask = null;
-      resolve();
-    }
-  );
-  worker.runTask.catch((err) => {
-    worker.log.error("Worker crash: %s", { error: toError(err) });
-  });
+	const setupFn = definition.setup;
+	const ctx = {
+		...setupContext,
+		worker: createWorkerInstance(definition, setupContext.log)
+	};
+	if (isFunction(definition.executeStrategy)) ctx.worker.executeStrategy = definition.executeStrategy(props);
+	else ctx.worker.executeStrategy = definition.executeStrategy;
+	return Promise.resolve().then(() => ctx.worker.executeStrategy.doSetup(ctx)).then(() => setupFn ? setupFn.call(ctx, props) : void 0).then((setupResult) => {
+		return {
+			...ctx,
+			...setupResult || {}
+		};
+	});
+}
+function runWorkerLoop(runtimeContext, props) {
+	const worker = runtimeContext.worker;
+	const executeStrategy = worker.executeStrategy;
+	const abortController = new AbortController();
+	const abortSignal = abortController.signal;
+	const onStopSignal = () => {
+		return Promise.resolve().then(() => abortController.abort()).then(() => catchError(() => executeStrategy.stopSignal(() => worker.queue.close()))).then(({ 0: stopError }) => {
+			if (stopError) {
+				worker.queue.close();
+				worker.log.error("Strategy stopSignal error", { error: stopError });
+			}
+		});
+	};
+	worker.runTask = new CancellablePromise(async (resolve, _reject, onCancel) => {
+		onCancel(onStopSignal);
+		const { 0: startError } = await catchError(() => executeStrategy.startSignal());
+		if (startError) {
+			worker.log.error("Strategy startSignal error", { error: startError });
+			worker.runTask = null;
+			return resolve();
+		}
+		worker.log.info("Worker started (parallel=%d)", worker.taskParallel);
+		for await (const taskContext of worker.queue) {
+			const jobTicket = await worker.pool.acquire();
+			const entryContext = new Proxy(taskContext, {
+				get(target, key, receiver) {
+					if (Object.prototype.hasOwnProperty.call(target, key)) return Reflect.get(target, key, receiver);
+					return Reflect.get(runtimeContext, key);
+				},
+				set(target, key, value) {
+					if (Object.prototype.hasOwnProperty.call(target, key)) Reflect.set(target, key, value, target);
+					else Reflect.set(runtimeContext, key, value, runtimeContext);
+					return true;
+				}
+			});
+			executeWorkerTask(worker, entryContext, props, abortSignal).finally(() => {
+				worker.pool.release(jobTicket);
+				checkWorkerPressure(worker);
+			});
+		}
+		if (worker.pool.usedCount > 0) worker.log.info("Draining task pool (active=%d)", worker.pool.usedCount);
+		await worker.pool.destroy();
+		worker.queue = new AsyncIterableQueue();
+		worker.runTask = null;
+		resolve();
+	});
+	worker.runTask.catch((err) => {
+		worker.log.error("Worker crash: %s", { error: toError(err) });
+	});
 }
 function checkWorkerPressure(worker) {
-  try {
-    if (worker.isOverloaded) {
-      if (!worker.definition.executeStrategy.overloadedSignal)
-        return void worker.log.warn(
-          "Worker under pressure (queue=%d, limit=%d)",
-          worker.queueSize,
-          worker.queueMaxSize
-        );
-      if (worker.overloadedSignaled) return;
-      worker.overloadedSignaled = true;
-      worker.definition.executeStrategy.overloadedSignal();
-    } else {
-      if (!worker.overloadedSignaled) return;
-      if (!worker.definition.executeStrategy.availableSignal) {
-        worker.log.warn("Worker capacity restored");
-      } else {
-        worker.definition.executeStrategy.availableSignal();
-      }
-      worker.overloadedSignaled = false;
-    }
-  } catch (err) {
-    worker.log.error("Backpressure signal error", { error: err });
-  }
-}
-async function stopWorker(runtimeContext, definition, props) {
-  const worker = runtimeContext.worker;
-  const userStop = definition.stop;
-  if (worker.runTask) {
-    if (isFunction(userStop)) {
-      await userStop.call(runtimeContext, props);
-    }
-    if (!worker.runTask) return;
-    worker.runTask.cancel();
-    await worker.runTask.catch(() => {
-    });
-    worker.runTask = null;
-  }
-}
-async function shutdownWorker(runtimeContext, definition, props) {
-  const worker = runtimeContext.worker;
-  const userShutdown = definition.shutdown;
-  if (isFunction(userShutdown)) {
-    await userShutdown.call(runtimeContext, props);
-  }
-  await definition.executeStrategy.doShutdown();
-  worker.queue = new AsyncIterableQueue();
-  worker.pool = createWorkerPool(definition.taskParallel ?? 2);
+	const executeStrategy = worker.executeStrategy;
+	try {
+		if (worker.isOverloaded) {
+			if (!executeStrategy || !executeStrategy.overloadedSignal) return void worker.log.warn("Worker under pressure (queue=%d, limit=%d)", worker.queueSize, worker.queueMaxSize);
+			if (worker.overloadedSignaled) return;
+			worker.overloadedSignaled = true;
+			executeStrategy.overloadedSignal();
+		} else {
+			if (!worker.overloadedSignaled) return;
+			if (!executeStrategy || !executeStrategy.availableSignal) worker.log.warn("Worker capacity restored");
+			else executeStrategy.availableSignal();
+			worker.overloadedSignaled = false;
+		}
+	} catch (err) {
+		worker.log.error("Backpressure signal error", { error: err });
+	}
+}
+function stopWorker(runtimeContext, props) {
+	const worker = runtimeContext.worker;
+	const userStop = worker.definition.stop || noop;
+	const runTask = worker.runTask;
+	if (!runTask) return Promise.resolve();
+	return Promise.resolve().then(() => userStop.call(runtimeContext, props)).finally(() => {
+		runTask.cancel();
+		return runTask.finally(() => {
+			worker.runTask = null;
+		});
+	});
+}
+function shutdownWorker(runtimeContext, props) {
+	const worker = runtimeContext.worker;
+	const executeStrategy = worker.executeStrategy;
+	const definition = worker.definition;
+	const userShutdown = definition.shutdown || noop;
+	return Promise.resolve().then(() => userShutdown.call(runtimeContext, props)).then(() => executeStrategy.doShutdown()).finally(() => {
+		worker.queue = new AsyncIterableQueue();
+		worker.pool = createWorkerPool(definition.taskParallel ?? 2);
+	});
 }
 function isWorkerDefinition(value) {
-  return value?.[WORKER_DEF] === true;
+	return value?.[WORKER_DEF] === true;
 }
 function isWorkerInstance(value) {
-  return isWorkerDefinition(value?.definition);
+	return isWorkerDefinition(value?.definition);
 }
+export { APP_INSTANCE_STATE, IntervalStrategy, addWorkerTask, appWaitShutdown, cli, createAppHub, createAppInstance, createAppThread, createAppThreadInstance, createThreadMessage, createWorkerInstance, defineApp, defineWorker, getPrefixedProps, initThread, isAppDefinition, isThreadExit, isThreadMessage, isWorkerDefinition, isWorkerInstance, prefixifyProps, restartThreadApp, runApp, setupApp, setupThreadApp, shutdownApp, shutdownThreadApp, startApp, startThreadApp, stopApp, stopThreadApp, waitForThreadReady };
 
-export { APP_INSTANCE_STATE, IntervalStrategy, addWorkerTask, appWaitShutdown, cli, createAppHub, createAppInstance, createAppThread, createAppThreadInstance, createThreadMessage, createWorkerInstance, defineApp, defineWorker, getPrefixedProps, initThread, isAppDefinition, isThreadExit, isThreadMessage, isWorkerDefinition, isWorkerInstance, prefixifyProps, restartThreadApp, runApp$1 as runApp, setupApp, setupThreadApp, shutdownApp, shutdownThreadApp, startApp, startThreadApp, stopApp, stopThreadApp, waitForThreadReady };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map