@andrew_l/app 0.3.8 → 0.4.1

package/dist/index.cjs

@@ -1,2678 +0,0 @@
-'use strict';
-
-const toolkit = require('@andrew_l/toolkit');
-const os = require('node:os');
-const path = require('node:path');
-const consola = require('consola');
-const graceful = require('@andrew_l/graceful');
-const cp = require('node:child_process');
-const node_events = require('node:events');
-const commander = require('commander');
-const fs = require('node:fs');
-const dotenv = require('dotenv');
-const utils = require('consola/utils');
-const jsxRuntime = require('react/jsx-runtime');
-const ink = require('ink');
-const react = require('react');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      n[k] = e[k];
-    }
-  }
-  n.default = e;
-  return n;
-}
-
-const os__default = /*#__PURE__*/_interopDefaultCompat(os);
-const path__default = /*#__PURE__*/_interopDefaultCompat(path);
-const cp__namespace = /*#__PURE__*/_interopNamespaceCompat(cp);
-const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
-const dotenv__default = /*#__PURE__*/_interopDefaultCompat(dotenv);
-
-const CONFIG = Object.freeze({
-  IS_VRUN: toolkit.env.bool("VRUN", false),
-  WATCH_MODE: toolkit.env.bool("VRUN_WATCH", false),
-  /**
-   * Root path of application
-   */
-  APP_ROOT: toolkit.env.string("APP_ROOT") || null,
-  /**
-   * Typescript resolver mode
-   */
-  TS_MODE: toolkit.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(toolkit.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__default.resolve(filePath);
-    }
-  }
-  return path__default.normalize(filePath);
-}
-
-function isMainFile(filepath) {
-  const cwd = process.cwd();
-  return process.argv.some((arg) => filepath.endsWith(path__default.resolve(cwd, arg)));
-}
-
-const createLogger = (tagName) => {
-  const log2 = consola.createConsola({
-    formatOptions: { date: false },
-    level: consola.LogLevels[toolkit.getLoggerLevel()],
-    fancy: true,
-    defaults: {
-      tag: tagName
-    }
-  });
-  log2.extend = (tagName2) => createLogger(tagName2);
-  return log2;
-};
-const log = createLogger();
-const noopLogger = {
-  debug: toolkit.noop,
-  error: toolkit.noop,
-  extend: () => noopLogger,
-  info: toolkit.noop,
-  log: toolkit.noop,
-  warn: toolkit.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 (toolkit.typeOf(value)) {
-    case "array":
-    case "object":
-      return toolkit.EJSON.stringify(value);
-    default: {
-      return String(value);
-    }
-  }
-}
-function createAppLogger(definition) {
-  return definition.logger === false ? noopLogger : toolkit.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(toolkit.captureStackTrace(defineApp)),
-    ...definition
-  };
-  toolkit.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 toolkit.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 (toolkit.isSkip(setupResult)) {
-    return setupResult;
-  }
-  const runResult = await runApp$1(instance);
-  if (toolkit.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 (toolkit.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: toolkit.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 (toolkit.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: toolkit.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 (toolkit.isFunction(stop)) {
-    try {
-      await stop.call(instance.setupState, instance.props);
-    } catch (err) {
-      setState$1(instance, APP_INSTANCE_STATE.ERROR);
-      stopErr = toolkit.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 (toolkit.isFunction(shutdown)) {
-    try {
-      await shutdown.call(instance.setupState, instance.props);
-    } catch (err) {
-      shutdownErr = toolkit.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 = toolkit.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 toolkit.asyncForEach(definitions, (definition) => {
-        const appProps = getPrefixedProps(definition, props);
-        const instance = createAppInstance(definition);
-        instances.push(instance);
-        return setupApp(instance, appProps).then((setupResult) => {
-          if (toolkit.isSkip(setupResult)) {
-            setupSkips.push({ ...setupResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (setupSkips.length) {
-          throw skipExecsToError("setup", setupSkips);
-        }
-        return { instances };
-      });
-    },
-    entry() {
-      const runSkips = [];
-      return toolkit.asyncForEach(this.instances, (instance) => {
-        return runApp$1(instance).then((runResult) => {
-          if (toolkit.isSkip(runResult)) {
-            runSkips.push({ ...runResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (runSkips.length) {
-          throw skipExecsToError("start", runSkips);
-        }
-      });
-    },
-    stop() {
-      const stopSkips = [];
-      return toolkit.asyncForEach(this.instances, (instance) => {
-        return stopApp(instance).then((stopResult) => {
-          if (toolkit.isSkip(stopResult)) {
-            stopSkips.push({ ...stopResult, app: instance });
-          }
-        });
-      }).then(() => {
-        if (stopSkips.length) {
-          throw skipExecsToError("stop", stopSkips);
-        }
-      });
-    },
-    shutdown() {
-      const shutdownSkips = [];
-      return toolkit.asyncForEach(this.instances, (instance) => {
-        return shutdownApp(instance).then((shutdownResult) => {
-          if (toolkit.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 && toolkit.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 = toolkit.pickPrefixed(props, {
-    prefix: toolkit.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[toolkit.camelCase(`${definition.name}${toolkit.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 = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)).endsWith(".ts") ? new URL("./index.js", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href));
-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__default.basename(w.scriptFile),
-    thread: w.threadId
-  });
-  setState(w, "init");
-  const child = cp__namespace.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__default.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 = toolkit.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 toolkit.Scheduler(),
-    eventBus: new node_events.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 && !graceful.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(toolkit.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(
-    toolkit.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 toolkit.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;
-  toolkit.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;
-      toolkit.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(
-        toolkit.noop
-      );
-    },
-    stop() {
-      return Promise.all(this.managedThreads.map((w) => stopThreadApp(w))).then(
-        toolkit.noop
-      );
-    },
-    shutdown() {
-      return Promise.all(
-        this.managedThreads.map((w) => shutdownThreadApp(w))
-      ).then(() => {
-        this.managedThreads = [];
-      });
-    }
-  });
-  return app;
-}
-function createAppThreadInstance({
-  definition,
-  parentPort,
-  threadId,
-  onShutdown = toolkit.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(() => {
-            toolkit.catchError(onShutdown);
-            if (toolkit.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");
-  toolkit.assert.ok(
-    packageJsonPath,
-    "package.json not found in path: " + path__default.dirname(projectPath)
-  );
-  const packageJson = importJson(packageJsonPath);
-  const projectLocation = path__default.dirname(packageJsonPath);
-  const project = {
-    path: projectLocation,
-    name: packageJson.name || path__default.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(toolkit.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 = toolkit.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__default.resolve(dir, filePath)
-  );
-  for (const filePath2 of pathVariants) {
-    const pathVariants2 = ALL_EXTENSIONS.includes(
-      toolkit.getFileExtension(filePath2, false)
-    ) ? [filePath2] : [...ALL_EXTENSIONS.map((ext) => `${filePath2}.${ext}`)];
-    const existedPath = pathVariants2.find((v) => fs__default.existsSync(v));
-    if (existedPath) {
-      return existedPath;
-    }
-  }
-  return null;
-}
-async function projectLoadEnv(project) {
-  if (!project.dotenvPath) {
-    return false;
-  }
-  dotenv__default.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(utils.getColor("bgBlue")(" TS "));
-  }
-  if (CONFIG.WATCH_MODE) {
-    tags.push(utils.getColor("bgMagenta")(" WATCH "));
-  }
-  if (project.dotenvPath) {
-    tags.push(utils.getColor("bgYellow")(` ${path__default.basename(project.dotenvPath)} `));
-  }
-  if (project.autoImports.length) {
-    tags.push(
-      utils.getColor("bgGreen")(
-        ` IMPORT: ${project.autoImports.map((v) => path__default.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__default.resolve(cwd, appRoot));
-  }
-  result.push(path__default.resolve(cwd));
-  result.push(path__default.resolve(projectPath));
-  return toolkit.uniq(result);
-}
-function locateNearestFile(location, fileName) {
-  let currentDir = path__default.extname(location) ? path__default.dirname(path__default.resolve(location)) : path__default.resolve(location);
-  while (currentDir) {
-    const filePath = path__default.join(currentDir, fileName);
-    if (fs__default.existsSync(filePath)) {
-      return filePath;
-    }
-    const parentDir = path__default.dirname(currentDir);
-    if (parentDir === currentDir) break;
-    currentDir = parentDir;
-  }
-  return null;
-}
-function importJson(filePath) {
-  if (!filePath.endsWith(".json")) {
-    filePath += ".json";
-  }
-  if (!fs__default.existsSync(filePath)) {
-    throw new Error(`JSON file not found.
- Path:
-  ${filePath}`);
-  }
-  const data = fs__default.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 node_events.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 = react.createContext(null);
-function useTuiStore() {
-  const store = react.useContext(TuiStoreContext);
-  if (!store) throw new Error("TuiStoreContext is not provided");
-  return store;
-}
-function useStoreSnapshot() {
-  const store = useTuiStore();
-  const [version, setVersion] = react.useState(0);
-  react.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__ */ jsxRuntime.jsxs(
-    ink.Box,
-    {
-      flexDirection: "column",
-      width,
-      flexShrink: 0,
-      borderStyle: "single",
-      paddingX: 1,
-      overflow: "hidden",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ink.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__ */ jsxRuntime.jsxs(ink.Text, { wrap: "truncate-end", bold: selected, children: [
-              /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "cyan", children: marker }),
-              caret,
-              " ",
-              /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color, children: "\u25CF" }),
-              " ",
-              node.name
-            ] }, node.id);
-          }
-          return /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { wrap: "truncate-end", bold: selected, children: [
-            /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "cyan", children: marker }),
-            "  ",
-            /* @__PURE__ */ jsxRuntime.jsx(ink.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 } = ink.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__ */ jsxRuntime.jsxs(
-    ink.Box,
-    {
-      flexDirection: "column",
-      flexGrow: 1,
-      flexShrink: 1,
-      borderStyle: "single",
-      paddingX: 1,
-      overflow: "hidden",
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexShrink: 0, flexDirection: "column", children: info ? /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { justifyContent: "space-between", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { bold: true, wrap: "truncate-end", children: [
-            /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "cyan", children: info.appName }),
-            info.processCount > 1 && info.pid == null ? /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
-              " (",
-              info.processCount,
-              " processes)"
-            ] }) : null,
-            /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
-              " ",
-              "\xB7 filter: ",
-              store.filter,
-              scrollLabel
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { bold: true, wrap: "truncate-end", children: [
-            /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
-              "STATE ",
-              info.states.join(", ")
-            ] }),
-            /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: " \xB7 " }),
-            /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "magenta", children: [
-              "PID ",
-              formatPids(info.pids)
-            ] })
-          ] })
-        ] }) : /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: " (no selection)" }) }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, overflow: "hidden", children: entries.map((entry, idx) => /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { wrap: "wrap", children: [
-          /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "gray", children: [
-            formatTime(entry.ts),
-            " "
-          ] }),
-          /* @__PURE__ */ jsxRuntime.jsx(ink.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__ */ jsxRuntime.jsxs(
-    ink.Box,
-    {
-      flexDirection: "row",
-      justifyContent: "space-between",
-      paddingX: 1,
-      flexShrink: 0,
-      height: 1,
-      children: [
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexShrink: 1, overflow: "hidden", children: /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { wrap: "truncate-end", children: sys ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "[system] " }),
-          /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: sys.level === "error" ? "red" : "white", children: sys.text })
-        ] }) : /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "gray", children: "[system] ready" }) }) }),
-        /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { flexShrink: 0, children: /* @__PURE__ */ jsxRuntime.jsx(ink.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 } = ink.useStdout();
-  const rows = stdout?.rows ?? 24;
-  ink.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__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", width: columns, height: rows, children: [
-    /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "row", flexGrow: 1, width: columns, children: [
-      /* @__PURE__ */ jsxRuntime.jsx(AppList, {}),
-      /* @__PURE__ */ jsxRuntime.jsx(LogView, {})
-    ] }),
-    /* @__PURE__ */ jsxRuntime.jsx(StatusBar, {})
-  ] });
-}
-function TuiRoot(props) {
-  return /* @__PURE__ */ jsxRuntime.jsx(TuiStoreContext.Provider, { value: props.store, children: /* @__PURE__ */ jsxRuntime.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 (toolkit.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(toolkit.noop);
-  graceful.onShutdownError((error) => {
-    console.error("[Graceful Shutdown] error:", error);
-  });
-  const q = toolkit.defer();
-  graceful.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(() => graceful.processGraceful());
-  };
-  const inkInstance = ink.render(/* @__PURE__ */ jsxRuntime.jsx(TuiRoot, { store, onExit }), {
-    exitOnCtrlC: false
-  });
-  return Promise.all(records.map(startRecord)).then(() => q.promise);
-}
-
-const DB_PATH = path__default.join(os__default.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 = toolkit.EJSON.stringify(Array.from(this._storage.entries()));
-    fs__default.writeFileSync(this.filepath, data);
-    this._dirty = false;
-  }
-  load() {
-    try {
-      const data = toolkit.EJSON.parse(fs__default.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 = toolkit.kebabCase(name);
-    const typePlaceholder = TYPE_TO_PLACEHOLDER.get(type);
-    const envVariables = toolkit.arrayable(env);
-    const option = new commander.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 (!toolkit.isNumber(parsedValue)) {
-    throw new commander.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(toolkit.noop).catch((error) => {
-    log.error("Failed to run app:", error);
-    process.exit(1);
-  });
-}
-function buildRootCommand({
-  cliDescription,
-  cliName
-}) {
-  const program = new commander.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 commander.Option("--watch", "Watch file changes")).addOption(new commander.Option("--dev", "Allow to import ts files")).passThroughOptions(true).allowUnknownOption(true).allowExcessArguments(true).action(function(scriptFiles, _opts) {
-    toolkit.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__default.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(toolkit.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__default.dirname(path__default.resolve(jsonFile)));
-    const remainingArgs = cmd.args;
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(
-      () => projectImportFile(
-        project,
-        path__default.resolve(jsonFile)
-      )
-    ).then((m) => {
-      const paths = m.default;
-      toolkit.assert.arrayStrings(paths, "JSON file must contain a string[].");
-      return paths.map(
-        (p) => path__default.resolve(path__default.dirname(path__default.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(toolkit.noop);
-  });
-  program.command("list").description("Interactively pick apps to run from a folder.").argument("[string]", "Path to folder", ".").addOption(
-    new commander.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__default.resolve(folderPath));
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path__default.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__default.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(toolkit.noop);
-  });
-  program.command("folder").description("Start all apps found in a folder.").argument("<string>", "Path to folder").addOption(
-    new commander.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__default.resolve(folderPath));
-    return Promise.resolve().then(() => registerTsx(project)).then(() => loadProject(project)).then(() => findAppFiles(path__default.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(toolkit.noop);
-  });
-  return program;
-}
-function findAppFiles(folderPath, pattern) {
-  return fs__default.globSync(pattern, {
-    cwd: folderPath,
-    exclude: (f) => f.includes("node_modules")
-  }).map((f) => path__default.resolve(folderPath, f)).sort();
-}
-function loadScriptCommand(scriptFile) {
-  const project = createProject(path__default.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(toolkit.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 commander.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 commander.Option("--watch", "Watch file changes")).addOption(new commander.Option("--dev", "Allow to import ts files")).addOption(new commander.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 = toolkit.defer();
-  let app;
-  graceful.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 (toolkit.isSkip(startResult)) {
-      startDefer.resolve();
-      log.warn("Failed to start %s", startResult, startResult.error);
-      return;
-    }
-    app = startResult.app;
-    startDefer.resolve();
-    return appWaitShutdown(app);
-  }).then(() => graceful.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 toolkit.ResourcePool({
-    poolSize: size,
-    auto: true,
-    createResource: () => Symbol("worker-slot")
-  });
-}
-function createWorkerInstance(definition, logger) {
-  const instance = {
-    definition,
-    log: logger,
-    queue: new toolkit.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 (toolkit.isFunction(executeStrategy.executeSignal)) {
-    const [signalError, signalResult] = await toolkit.catchError(
-      () => executeStrategy.executeSignal(entryContext)
-    );
-    if (signalError) {
-      instance.log.error("Strategy executeSignal error, dropping task", {
-        error: signalError
-      });
-      return;
-    }
-    if (toolkit.isSkip(signalResult)) {
-      instance.log.warn(
-        "Strategy executeSignal returned skip, dropping task",
-        signalResult
-      );
-      return;
-    }
-  }
-  let [executeError, executeResult] = await toolkit.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 || toolkit.isSkip(result) && !!result.error;
-    hasSkip = toolkit.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 toolkit.catchError(
-      () => executeStrategy.completeSignal(entryContext, executeResult)
-    );
-    if (completeError) {
-      instance.log.error("Strategy completeSignal error", {
-        error: completeError
-      });
-    }
-  }
-}
-function defineWorker(definition) {
-  const result = defineApp({
-    filePath: filePathFromStack(toolkit.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);
-  toolkit.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(
-      () => toolkit.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 toolkit.CancellablePromise(
-    async (resolve, _reject, onCancel) => {
-      onCancel(onStopSignal);
-      const [startError] = await toolkit.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 toolkit.AsyncIterableQueue();
-      worker.runTask = null;
-      resolve();
-    }
-  );
-  worker.runTask.catch((err) => {
-    worker.log.error("Worker crash: %s", { error: toolkit.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 (toolkit.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 (toolkit.isFunction(userShutdown)) {
-    await userShutdown.call(runtimeContext, props);
-  }
-  await definition.executeStrategy.doShutdown();
-  worker.queue = new toolkit.AsyncIterableQueue();
-  worker.pool = createWorkerPool(definition.taskParallel ?? 2);
-}
-function isWorkerDefinition(value) {
-  return value?.[WORKER_DEF] === true;
-}
-function isWorkerInstance(value) {
-  return isWorkerDefinition(value?.definition);
-}
-
-exports.APP_INSTANCE_STATE = APP_INSTANCE_STATE;
-exports.IntervalStrategy = IntervalStrategy;
-exports.addWorkerTask = addWorkerTask;
-exports.appWaitShutdown = appWaitShutdown;
-exports.cli = cli;
-exports.createAppHub = createAppHub;
-exports.createAppInstance = createAppInstance;
-exports.createAppThread = createAppThread;
-exports.createAppThreadInstance = createAppThreadInstance;
-exports.createThreadMessage = createThreadMessage;
-exports.createWorkerInstance = createWorkerInstance;
-exports.defineApp = defineApp;
-exports.defineWorker = defineWorker;
-exports.getPrefixedProps = getPrefixedProps;
-exports.initThread = initThread;
-exports.isAppDefinition = isAppDefinition;
-exports.isThreadExit = isThreadExit;
-exports.isThreadMessage = isThreadMessage;
-exports.isWorkerDefinition = isWorkerDefinition;
-exports.isWorkerInstance = isWorkerInstance;
-exports.prefixifyProps = prefixifyProps;
-exports.restartThreadApp = restartThreadApp;
-exports.runApp = runApp$1;
-exports.setupApp = setupApp;
-exports.setupThreadApp = setupThreadApp;
-exports.shutdownApp = shutdownApp;
-exports.shutdownThreadApp = shutdownThreadApp;
-exports.startApp = startApp;
-exports.startThreadApp = startThreadApp;
-exports.stopApp = stopApp;
-exports.stopThreadApp = stopThreadApp;
-exports.waitForThreadReady = waitForThreadReady;
-//# sourceMappingURL=index.cjs.map