@andrew_l/app 0.3.7

package/dist/index.mjs

@@ -0,0 +1,2624 @@
+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';
+
+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"))
+});
+
+const isHelpArgument = (argv) => {
+  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;
+}
+
+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);
+}
+
+function isMainFile(filepath) {
+  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 = createLogger();
+const noopLogger = {
+  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;
+}
+function formatField(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);
+}
+
+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"
+};
+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;
+}
+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
+  };
+}
+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"
+  };
+}
+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);
+  });
+}
+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;
+}
+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;
+}
+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}`);
+  }
+}
+
+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;
+}
+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 }
+  );
+}
+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;
+}
+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 MAX_RESTARTS = 3;
+const HEARTBEAT_INTERVAL_MS = 5e3;
+const HEARTBEAT_TIMEOUT_MS = 1e4;
+const SHUTDOWN_EXIT_TIMEOUT_MS = 5e3;
+const SHUTDOWN_REPLY_TIMEOUT_MS = 3e4;
+const appModulePath = import.meta.url.endsWith(".ts") ? new URL("./index.js", import.meta.url).href : import.meta.url;
+const bootstrapCode = `
+import { delay } from '@andrew_l/toolkit'
+import { processGraceful, onShutdown, onShutdownError } from '@andrew_l/graceful'
+import process from 'node:process';
+
+const scriptFile = process.env.VRUN_PROCESS_SCRIPT_FILE;
+const threadId = parseInt(process.env.VRUN_PROCESS_ID, 10);
+const appUrl = ${JSON.stringify(appModulePath)};
+
+if (
+  scriptFile.endsWith('.ts') ||
+  appUrl.endsWith('.ts') ||
+  appUrl.includes('/src/')
+) {
+  const { register } = await import('tsx/esm/api');
+  register();
+}
+
+const { isAppDefinition, createAppThreadInstance, shutdownApp } = await import(appUrl);
+
+const definition = await import(scriptFile).then(r => r.default);
+
+if (!isAppDefinition(definition)) {
+  throw new Error('Default export must be an app definition: ' + scriptFile);
+}
+
+const listeners = new Set();
+const port = {
+  on(event, cb) {
+    if (event === 'message') {
+      process.on('message', cb);
+      listeners.add(cb);
+    }
+  },
+  postMessage(msg, cb) {
+    process.send(msg, cb);
+  },
+  close() {
+    for (const cb of listeners) process.off('message', cb);
+  },
+};
+
+const app = createAppThreadInstance({
+  threadId,
+  definition,
+  parentPort: port,
+  // onShutdown: () => processGraceful()
+});
+
+const log = app.logger;
+
+onShutdownError((error) => {
+  log.error('Shutdown error:', error);
+});
+
+onShutdown('app', async () => {
+  log.info('Shutdown signal received');
+  await shutdownApp(app);
+});
+`;
+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);
+}
+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);
+  });
+}
+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);
+}
+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);
+  });
+}
+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);
+  });
+}
+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
+      });
+    }
+  });
+}
+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;
+}
+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;
+    }
+  );
+}
+function setupThreadApp(w) {
+  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);
+}
+function startThreadApp(w) {
+  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);
+      }
+    }
+  );
+}
+function stopThreadApp(w) {
+  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
+  );
+}
+function shutdownThreadApp(w) {
+  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));
+}
+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" }
+  );
+}
+function isThreadMessage(value) {
+  return isObject(value) && !!value.vrun_app_thread_message;
+}
+function createThreadMessage(type, msg) {
+  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 };
+}
+function isThreadExit(w) {
+  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 ALL_EXTENSIONS = [
+  ...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;
+}
+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);
+}
+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;
+}
+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(" ")}` : ""
+  );
+}
+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);
+}
+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;
+}
+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);
+}
+
+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;
+  }
+}
+const noopHandlers = {
+  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 LEVEL_RANK = {
+  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
+};
+function passesFilter(entry, 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;
+}
+function nextFilter(filter) {
+  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 TuiStoreContext = createContext(null);
+function useTuiStore() {
+  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 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"
+};
+function isApp(n) {
+  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;
+}
+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);
+        })
+      ]
+    }
+  );
+}
+
+const LEVEL_COLORS = {
+  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())}`;
+}
+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;
+}
+function formatPids(pids) {
+  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);
+}
+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)) })
+      ]
+    }
+  );
+}
+
+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" }) })
+      ]
+    }
+  );
+}
+
+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;
+}
+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, {})
+  ] });
+}
+function TuiRoot(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);
+}
+function appIdFor(definition, idx) {
+  return `${definition.name}#${idx}`;
+}
+function resolveThreadCount(appProps) {
+  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
+};
+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;
+}
+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 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;
+    }
+  }
+}
+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>"]
+]);
+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;
+}
+function getEnv(variables) {
+  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;
+}
+function findAppFiles(folderPath, pattern) {
+  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]));
+}
+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();
+}
+function loadProject(project) {
+  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;
+  });
+}
+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;
+}
+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
+};
+
+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")
+  });
+}
+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;
+}
+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
+      });
+    }
+  }
+}
+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;
+}
+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) });
+  });
+}
+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);
+}
+function isWorkerDefinition(value) {
+  return value?.[WORKER_DEF] === true;
+}
+function isWorkerInstance(value) {
+  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$1 as runApp, setupApp, setupThreadApp, shutdownApp, shutdownThreadApp, startApp, startThreadApp, stopApp, stopThreadApp, waitForThreadReady };
+//# sourceMappingURL=index.mjs.map