elit 3.6.6 → 3.6.7

package/dist/pm.mjs

@@ -0,0 +1,3196 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shares/runtime.ts
+var runtime, isNode, isBun, isDeno;
+var init_runtime = __esm({
+  "src/shares/runtime.ts"() {
+    "use strict";
+    runtime = (() => {
+      if (typeof Deno !== "undefined") return "deno";
+      if (typeof Bun !== "undefined") return "bun";
+      return "node";
+    })();
+    isNode = runtime === "node";
+    isBun = runtime === "bun";
+    isDeno = runtime === "deno";
+  }
+});
+
+// src/server/fs/node-modules.ts
+var fs, fsPromises;
+var init_node_modules = __esm({
+  "src/server/fs/node-modules.ts"() {
+    "use strict";
+    init_runtime();
+    if (isNode || isBun) {
+      fs = __require("fs");
+      fsPromises = __require("fs/promises");
+    }
+  }
+});
+
+// src/server/fs/utils.ts
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function processDenoEntriesAsync(iterator, withFileTypes) {
+  const entries = [];
+  for await (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+var init_utils = __esm({
+  "src/server/fs/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/server/fs/file-ops.ts
+async function readFile(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fsPromises.readFile(path, opts);
+  } else if (isDeno) {
+    const content = await Deno.readFile(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readFileSync2(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fs.readFileSync(path, opts);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function writeFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fsPromises.writeFile(path, data, opts);
+  } else if (isDeno) {
+    await Deno.writeFile(path, dataToUint8Array(data));
+  }
+}
+function writeFileSync2(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+async function appendFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.appendFile(path, data, opts);
+  }
+  if (await exists(path)) {
+    const existing = await readFile(path);
+    const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+    await writeFile(path, combined, opts);
+  } else {
+    await writeFile(path, data, opts);
+  }
+}
+function appendFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.appendFileSync(path, data, opts);
+    return;
+  }
+  if (existsSync4(path)) {
+    const existing = readFileSync2(path);
+    const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+    writeFileSync2(path, combined, opts);
+  } else {
+    writeFileSync2(path, data, opts);
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync4(path) {
+  try {
+    statSync2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stat(path) {
+  if (isNode || isBun) {
+    return fsPromises.stat(path);
+  } else if (isDeno) {
+    const info = await Deno.stat(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function statSync2(path) {
+  if (isNode || isBun) {
+    return fs.statSync(path);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+var init_file_ops = __esm({
+  "src/server/fs/file-ops.ts"() {
+    "use strict";
+    init_runtime();
+    init_node_modules();
+    init_utils();
+  }
+});
+
+// src/server/fs/directory-ops.ts
+async function mkdir(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode || isBun) {
+    await fsPromises.mkdir(path, opts);
+  } else if (isDeno) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  }
+}
+function mkdirSync2(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode || isBun) {
+    fs.mkdirSync(path, opts);
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+async function readdir(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fsPromises.readdir(path, opts);
+  } else if (isDeno) {
+    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readdirSync2(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fs.readdirSync(path, opts);
+  } else if (isDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function unlink(path) {
+  if (isNode || isBun) {
+    return fsPromises.unlink(path);
+  } else if (isDeno) {
+    await Deno.remove(path);
+  }
+}
+function unlinkSync(path) {
+  if (isNode || isBun) {
+    fs.unlinkSync(path);
+  } else if (isDeno) {
+    Deno.removeSync(path);
+  }
+}
+async function rmdir(path, options) {
+  if (isNode || isBun) {
+    return fsPromises.rmdir(path, options);
+  } else if (isDeno) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  }
+}
+function rmdirSync(path, options) {
+  if (isNode || isBun) {
+    fs.rmdirSync(path, options);
+  } else if (isDeno) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  }
+}
+var init_directory_ops = __esm({
+  "src/server/fs/directory-ops.ts"() {
+    "use strict";
+    init_runtime();
+    init_node_modules();
+    init_utils();
+  }
+});
+
+// src/server/fs/path-ops.ts
+async function rename(oldPath, newPath) {
+  if (isNode || isBun) {
+    return fsPromises.rename(oldPath, newPath);
+  } else if (isDeno) {
+    await Deno.rename(oldPath, newPath);
+  }
+}
+function renameSync(oldPath, newPath) {
+  if (isNode || isBun) {
+    fs.renameSync(oldPath, newPath);
+  } else if (isDeno) {
+    Deno.renameSync(oldPath, newPath);
+  }
+}
+async function copyFile(src, dest, flags) {
+  if (isNode || isBun) {
+    return fsPromises.copyFile(src, dest, flags);
+  } else if (isDeno) {
+    await Deno.copyFile(src, dest);
+  }
+}
+function copyFileSync(src, dest, flags) {
+  if (isNode || isBun) {
+    fs.copyFileSync(src, dest, flags);
+  } else if (isDeno) {
+    Deno.copyFileSync(src, dest);
+  }
+}
+async function realpath(path, options) {
+  if (isNode || isBun) {
+    return fsPromises.realpath(path, options);
+  } else if (isDeno) {
+    return await Deno.realPath(path);
+  }
+  return path;
+}
+function realpathSync(path, options) {
+  if (isNode || isBun) {
+    return fs.realpathSync(path, options);
+  } else if (isDeno) {
+    return Deno.realPathSync(path);
+  }
+  return path;
+}
+var init_path_ops = __esm({
+  "src/server/fs/path-ops.ts"() {
+    "use strict";
+    init_runtime();
+    init_node_modules();
+  }
+});
+
+// src/server/fs/index.ts
+var fs_exports = {};
+__export(fs_exports, {
+  appendFile: () => appendFile,
+  appendFileSync: () => appendFileSync,
+  copyFile: () => copyFile,
+  copyFileSync: () => copyFileSync,
+  default: () => fs_default,
+  exists: () => exists,
+  existsSync: () => existsSync4,
+  getRuntime: () => getRuntime,
+  mkdir: () => mkdir,
+  mkdirSync: () => mkdirSync2,
+  promises: () => promises,
+  readFile: () => readFile,
+  readFileSync: () => readFileSync2,
+  readdir: () => readdir,
+  readdirSync: () => readdirSync2,
+  realpath: () => realpath,
+  realpathSync: () => realpathSync,
+  rename: () => rename,
+  renameSync: () => renameSync,
+  rmdir: () => rmdir,
+  rmdirSync: () => rmdirSync,
+  stat: () => stat,
+  statSync: () => statSync2,
+  unlink: () => unlink,
+  unlinkSync: () => unlinkSync,
+  writeFile: () => writeFile,
+  writeFileSync: () => writeFileSync2
+});
+function getRuntime() {
+  return runtime;
+}
+var promises, fs_default;
+var init_fs = __esm({
+  "src/server/fs/index.ts"() {
+    "use strict";
+    init_runtime();
+    init_file_ops();
+    init_directory_ops();
+    init_path_ops();
+    init_file_ops();
+    init_directory_ops();
+    init_path_ops();
+    promises = {
+      readFile,
+      writeFile,
+      appendFile,
+      stat,
+      mkdir,
+      readdir,
+      unlink,
+      rmdir,
+      rename,
+      copyFile,
+      realpath
+    };
+    fs_default = {
+      readFile,
+      readFileSync: readFileSync2,
+      writeFile,
+      writeFileSync: writeFileSync2,
+      appendFile,
+      appendFileSync,
+      exists,
+      existsSync: existsSync4,
+      stat,
+      statSync: statSync2,
+      mkdir,
+      mkdirSync: mkdirSync2,
+      readdir,
+      readdirSync: readdirSync2,
+      unlink,
+      unlinkSync,
+      rmdir,
+      rmdirSync,
+      rename,
+      renameSync,
+      copyFile,
+      copyFileSync,
+      realpath,
+      realpathSync,
+      promises,
+      getRuntime
+    };
+  }
+});
+
+// src/cli/pm/shared.ts
+import { join } from "path";
+var DEFAULT_PM_DATA_DIR = join(".elit", "pm");
+var DEFAULT_PM_DUMP_FILE = "dump.json";
+var DEFAULT_RESTART_DELAY = 1e3;
+var DEFAULT_MAX_RESTARTS = 10;
+var DEFAULT_WATCH_DEBOUNCE = 250;
+var DEFAULT_MIN_UPTIME = 0;
+var DEFAULT_HEALTHCHECK_GRACE_PERIOD = 5e3;
+var DEFAULT_HEALTHCHECK_INTERVAL = 1e4;
+var DEFAULT_HEALTHCHECK_TIMEOUT = 3e3;
+var DEFAULT_HEALTHCHECK_MAX_FAILURES = 3;
+var DEFAULT_LOG_LINES = 40;
+var DEFAULT_PM_STOP_POLL_MS = 100;
+var DEFAULT_PM_STOP_GRACE_PERIOD_MS = 5e3;
+var PM_WAPK_ONLINE_STDIN_SHUTDOWN_ENV = "ELIT_PM_WAPK_ONLINE_STDIN_SHUTDOWN";
+var PM_WAPK_ONLINE_SHUTDOWN_COMMAND = "__ELIT_PM_WAPK_ONLINE_SHUTDOWN__";
+var PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS = 8e3;
+var PM_RECORD_EXTENSION = ".json";
+var SUPPORTED_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
+var DEFAULT_WATCH_IGNORE = ["**/.git/**", "**/node_modules/**", "**/.elit/**"];
+var SIMPLE_PREVIEW_SEGMENT = /^[A-Za-z0-9_./:=+-]+$/;
+
+// src/cli/pm/helpers.ts
+import { existsSync, statSync } from "fs";
+import { extname, join as join2, resolve } from "path";
+function normalizePmRuntime(value, optionName = "--runtime") {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${optionName} must be one of: node, bun, deno`);
+  }
+  const runtime2 = value.trim().toLowerCase();
+  if (runtime2 === "node" || runtime2 === "bun" || runtime2 === "deno") {
+    return runtime2;
+  }
+  throw new Error(`${optionName} must be one of: node, bun, deno`);
+}
+function normalizePmRestartPolicy(value, optionName = "--restart-policy") {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${optionName} must be one of: always, on-failure, never`);
+  }
+  const policy = value.trim().toLowerCase();
+  if (policy === "always" || policy === "on-failure" || policy === "never") {
+    return policy;
+  }
+  throw new Error(`${optionName} must be one of: always, on-failure, never`);
+}
+function normalizeIntegerOption(value, optionName, min = 0) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < min) {
+    throw new Error(`${optionName} must be a number >= ${min}`);
+  }
+  return parsed;
+}
+function normalizeNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function hasPmGoogleDriveConfig(config) {
+  return Boolean(
+    normalizeNonEmptyString(config?.fileId) || normalizeNonEmptyString(config?.accessToken) || normalizeNonEmptyString(config?.accessTokenEnv) || typeof config?.supportsAllDrives === "boolean"
+  );
+}
+function isPmWapkOnlineRunConfig(config) {
+  return Boolean(config?.online || normalizeNonEmptyString(config?.onlineUrl));
+}
+function hasPmWapkRunConfig(config) {
+  return Boolean(
+    normalizeNonEmptyString(config?.file) || hasPmGoogleDriveConfig(config?.googleDrive) || isPmWapkOnlineRunConfig(config) || normalizeNonEmptyString(config?.runtime) || typeof config?.syncInterval === "number" || typeof config?.useWatcher === "boolean" || typeof config?.watchArchive === "boolean" || typeof config?.archiveSyncInterval === "number" || normalizeNonEmptyString(config?.password)
+  );
+}
+function mergePmWapkRunConfig(base, override) {
+  if (!base && !override) {
+    return void 0;
+  }
+  const googleDrive = hasPmGoogleDriveConfig(base?.googleDrive) || hasPmGoogleDriveConfig(override?.googleDrive) ? {
+    fileId: override?.googleDrive?.fileId ?? base?.googleDrive?.fileId,
+    accessToken: override?.googleDrive?.accessToken ?? base?.googleDrive?.accessToken,
+    accessTokenEnv: override?.googleDrive?.accessTokenEnv ?? base?.googleDrive?.accessTokenEnv,
+    supportsAllDrives: override?.googleDrive?.supportsAllDrives ?? base?.googleDrive?.supportsAllDrives
+  } : void 0;
+  const merged = {
+    file: override?.file ?? base?.file,
+    googleDrive,
+    online: override?.online ?? base?.online,
+    onlineUrl: override?.onlineUrl ?? base?.onlineUrl,
+    runtime: override?.runtime ?? base?.runtime,
+    syncInterval: override?.syncInterval ?? base?.syncInterval,
+    useWatcher: override?.useWatcher ?? base?.useWatcher,
+    watchArchive: override?.watchArchive ?? base?.watchArchive,
+    archiveSyncInterval: override?.archiveSyncInterval ?? base?.archiveSyncInterval,
+    password: override?.password ?? base?.password
+  };
+  return hasPmWapkRunConfig(merged) ? merged : void 0;
+}
+function stripPmWapkSourceFromRunConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const googleDrive = hasPmGoogleDriveConfig({
+    ...config.googleDrive,
+    fileId: void 0
+  }) ? {
+    ...config.googleDrive,
+    fileId: void 0
+  } : void 0;
+  const stripped = {
+    file: void 0,
+    googleDrive,
+    online: config.online,
+    onlineUrl: config.onlineUrl,
+    runtime: void 0,
+    syncInterval: config.syncInterval,
+    useWatcher: config.useWatcher,
+    watchArchive: config.watchArchive,
+    archiveSyncInterval: config.archiveSyncInterval,
+    password: void 0
+  };
+  return hasPmWapkRunConfig(stripped) ? stripped : void 0;
+}
+function isRemoteWapkArchiveSpecifier(value) {
+  return /^(?:gdrive|google-drive):\/\/.+/i.test(value.trim());
+}
+function isWapkArchiveSpecifier(value) {
+  const normalized = value.trim();
+  return normalized.toLowerCase().endsWith(".wapk") || isRemoteWapkArchiveSpecifier(normalized);
+}
+function buildGoogleDriveWapkSpecifier(fileId) {
+  return `gdrive://${fileId}`;
+}
+function resolvePmWapkSource(value, cwd) {
+  const normalized = normalizeNonEmptyString(value);
+  if (!normalized) {
+    return void 0;
+  }
+  return isRemoteWapkArchiveSpecifier(normalized) ? normalized : resolve(cwd, normalized);
+}
+function resolvePmWapkSourceToken(wapk, wapkRun) {
+  const googleDriveFileId = normalizeNonEmptyString(wapkRun?.googleDrive?.fileId);
+  return normalizeNonEmptyString(wapk) ?? normalizeNonEmptyString(wapkRun?.file) ?? (googleDriveFileId ? buildGoogleDriveWapkSpecifier(googleDriveFileId) : void 0);
+}
+function countDefinedPmWapkSources(wapk, wapkRun) {
+  const values = [
+    normalizeNonEmptyString(wapk),
+    normalizeNonEmptyString(wapkRun?.file),
+    normalizeNonEmptyString(wapkRun?.googleDrive?.fileId)
+  ].filter((entry) => Boolean(entry));
+  return new Set(values).size;
+}
+function appendPmWapkRunArgs(args, previewParts, wapkRun) {
+  if (!wapkRun) {
+    return;
+  }
+  if (isPmWapkOnlineRunConfig(wapkRun)) {
+    args.push("--online");
+    previewParts.push("--online");
+  }
+  const onlineUrl = normalizeNonEmptyString(wapkRun.onlineUrl);
+  if (onlineUrl) {
+    args.push("--online-url", onlineUrl);
+    previewParts.push("--online-url", onlineUrl);
+  }
+  if (typeof wapkRun.syncInterval === "number" && Number.isFinite(wapkRun.syncInterval) && wapkRun.syncInterval >= 50) {
+    const value = String(Math.trunc(wapkRun.syncInterval));
+    args.push("--sync-interval", value);
+    previewParts.push("--sync-interval", value);
+  }
+  if (wapkRun.useWatcher) {
+    args.push("--watcher");
+    previewParts.push("--watcher");
+  }
+  if (typeof wapkRun.watchArchive === "boolean") {
+    const flag = wapkRun.watchArchive ? "--archive-watch" : "--no-archive-watch";
+    args.push(flag);
+    previewParts.push(flag);
+  }
+  if (typeof wapkRun.archiveSyncInterval === "number" && Number.isFinite(wapkRun.archiveSyncInterval) && wapkRun.archiveSyncInterval >= 50) {
+    const value = String(Math.trunc(wapkRun.archiveSyncInterval));
+    args.push("--archive-sync-interval", value);
+    previewParts.push("--archive-sync-interval", value);
+  }
+  const tokenEnv = normalizeNonEmptyString(wapkRun.googleDrive?.accessTokenEnv);
+  if (tokenEnv) {
+    args.push("--google-drive-token-env", tokenEnv);
+    previewParts.push("--google-drive-token-env", tokenEnv);
+  }
+  const accessToken = normalizeNonEmptyString(wapkRun.googleDrive?.accessToken);
+  if (accessToken) {
+    args.push("--google-drive-access-token", accessToken);
+    previewParts.push("--google-drive-access-token", "******");
+  }
+  if (wapkRun.googleDrive?.supportsAllDrives) {
+    args.push("--google-drive-shared-drive");
+    previewParts.push("--google-drive-shared-drive");
+  }
+}
+function quoteCommandSegment(value) {
+  return SIMPLE_PREVIEW_SEGMENT.test(value) ? value : JSON.stringify(value);
+}
+function buildPmWapkPreview(wapk, runtime2, password, wapkRun) {
+  const previewParts = ["elit", "wapk", "run", quoteCommandSegment(wapk)];
+  const online = isPmWapkOnlineRunConfig(wapkRun);
+  if (runtime2 && !online) {
+    previewParts.push("--runtime", runtime2);
+  }
+  if (password) {
+    previewParts.push("--password", "******");
+  }
+  appendPmWapkRunArgs([], previewParts, wapkRun);
+  return previewParts.join(" ");
+}
+function sanitizePmProcessName(name) {
+  const sanitized = name.trim().toLowerCase().replace(/[<>:"/\\|?*\x00-\x1f]+/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-");
+  return sanitized.length > 0 ? sanitized : "process";
+}
+function isTypescriptFile(filePath) {
+  const extension = extname(filePath).toLowerCase();
+  return extension === ".ts" || extension === ".mts" || extension === ".cts";
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function toWatchGlob(candidatePath) {
+  if (!existsSync(candidatePath)) {
+    return candidatePath;
+  }
+  try {
+    return statSync(candidatePath).isDirectory() ? join2(candidatePath, "**", "*").replace(/\\/g, "/") : candidatePath;
+  } catch {
+    return candidatePath;
+  }
+}
+function normalizeWatchPatterns(paths, cwd) {
+  return paths.map((entry) => resolve(cwd, entry)).map(toWatchGlob).map((entry) => entry.replace(/\\/g, "/"));
+}
+function normalizeWatchIgnorePatterns(paths, cwd) {
+  return paths.map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => {
+    if (entry.includes("*") || entry.includes("?")) {
+      return entry.replace(/\\/g, "/");
+    }
+    const resolvedPath = resolve(cwd, entry);
+    return toWatchGlob(resolvedPath).replace(/\\/g, "/");
+  });
+}
+function matchesGlobPattern(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexPattern = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+}
+function isIgnoredWatchPath(filePath, patterns) {
+  return patterns.some((pattern) => matchesGlobPattern(filePath, pattern));
+}
+function normalizeHealthCheckConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const config = value;
+  if (typeof config.url !== "string" || config.url.trim().length === 0) {
+    return void 0;
+  }
+  return {
+    url: config.url.trim(),
+    gracePeriod: typeof config.gracePeriod === "number" && Number.isFinite(config.gracePeriod) ? Math.max(0, Math.trunc(config.gracePeriod)) : DEFAULT_HEALTHCHECK_GRACE_PERIOD,
+    interval: typeof config.interval === "number" && Number.isFinite(config.interval) ? Math.max(250, Math.trunc(config.interval)) : DEFAULT_HEALTHCHECK_INTERVAL,
+    timeout: typeof config.timeout === "number" && Number.isFinite(config.timeout) ? Math.max(250, Math.trunc(config.timeout)) : DEFAULT_HEALTHCHECK_TIMEOUT,
+    maxFailures: typeof config.maxFailures === "number" && Number.isFinite(config.maxFailures) ? Math.max(1, Math.trunc(config.maxFailures)) : DEFAULT_HEALTHCHECK_MAX_FAILURES
+  };
+}
+function looksLikeManagedFile(value, cwd) {
+  const normalized = value.trim();
+  if (!normalized) {
+    return false;
+  }
+  if (isRemoteWapkArchiveSpecifier(normalized)) {
+    return false;
+  }
+  if (normalized.toLowerCase().endsWith(".wapk")) {
+    return true;
+  }
+  const extension = extname(normalized).toLowerCase();
+  if (SUPPORTED_FILE_EXTENSIONS.has(extension)) {
+    return true;
+  }
+  if (normalized.includes("/") || normalized.includes("\\") || normalized.startsWith(".")) {
+    return existsSync(resolve(cwd, normalized));
+  }
+  return false;
+}
+function normalizeEnvMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const normalized = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (typeof entryValue === "string") {
+      normalized[key] = entryValue;
+      continue;
+    }
+    if (typeof entryValue === "number" || typeof entryValue === "boolean") {
+      normalized[key] = String(entryValue);
+    }
+  }
+  return normalized;
+}
+function parsePmEnvEntry(input) {
+  const separatorIndex = input.indexOf("=");
+  if (separatorIndex <= 0) {
+    throw new Error("--env expects KEY=VALUE");
+  }
+  const key = input.slice(0, separatorIndex).trim();
+  const value = input.slice(separatorIndex + 1);
+  if (!key) {
+    throw new Error("--env expects KEY=VALUE");
+  }
+  return [key, value];
+}
+function readRequiredValue(args, index, optionName) {
+  const value = args[index];
+  if (value === void 0) {
+    throw new Error(`${optionName} requires a value.`);
+  }
+  return value;
+}
+
+// src/cli/pm/records.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join as join3, resolve as resolve2 } from "path";
+function resolvePmPaths(config, workspaceRoot) {
+  const dataDir = resolve2(workspaceRoot, config?.dataDir ?? DEFAULT_PM_DATA_DIR);
+  const dumpFile = config?.dumpFile ? resolve2(workspaceRoot, config.dumpFile) : join3(dataDir, DEFAULT_PM_DUMP_FILE);
+  return {
+    dataDir,
+    appsDir: join3(dataDir, "apps"),
+    logsDir: join3(dataDir, "logs"),
+    dumpFile
+  };
+}
+function ensurePmDirectories(paths) {
+  mkdirSync(paths.dataDir, { recursive: true });
+  mkdirSync(paths.appsDir, { recursive: true });
+  mkdirSync(paths.logsDir, { recursive: true });
+  mkdirSync(dirname(paths.dumpFile), { recursive: true });
+}
+function getPmRecordPath(paths, id) {
+  return join3(paths.appsDir, `${id}${PM_RECORD_EXTENSION}`);
+}
+function readPmRecord(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function writePmRecord(filePath, record) {
+  writeFileSync(filePath, JSON.stringify(record, null, 2));
+}
+function toSavedAppDefinition(record) {
+  return {
+    name: record.name,
+    type: record.type,
+    cwd: record.cwd,
+    runtime: record.runtime,
+    env: record.env,
+    script: record.script,
+    file: record.file,
+    wapk: record.wapk,
+    password: record.password,
+    wapkRun: record.wapkRun,
+    restartPolicy: record.restartPolicy,
+    autorestart: record.autorestart,
+    restartDelay: record.restartDelay,
+    maxRestarts: record.maxRestarts,
+    minUptime: record.minUptime,
+    watch: record.watch,
+    watchPaths: record.watchPaths,
+    watchIgnore: record.watchIgnore,
+    watchDebounce: record.watchDebounce,
+    healthCheck: record.healthCheck
+  };
+}
+function writePmDumpFile(filePath, apps) {
+  const dump = {
+    version: 1,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    apps
+  };
+  writeFileSync(filePath, JSON.stringify(dump, null, 2));
+}
+function readPmDumpFile(filePath) {
+  const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  if (parsed.version !== 1 || !Array.isArray(parsed.apps)) {
+    throw new Error(`Invalid PM dump file: ${filePath}`);
+  }
+  return {
+    version: 1,
+    savedAt: typeof parsed.savedAt === "string" ? parsed.savedAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+    apps: parsed.apps
+  };
+}
+function deriveDefaultWatchPaths(type, cwd, file, wapk) {
+  if (type === "file" && file) {
+    return [file];
+  }
+  if (type === "wapk" && wapk) {
+    return [isRemoteWapkArchiveSpecifier(wapk) ? cwd : wapk];
+  }
+  return [cwd];
+}
+function normalizeResolvedWatchPaths(paths, cwd, type, file, wapk) {
+  const sourcePaths = paths.length > 0 ? paths : deriveDefaultWatchPaths(type, cwd, file, wapk);
+  return normalizeWatchPatterns(sourcePaths, cwd);
+}
+function normalizeResolvedWatchIgnorePaths(paths, cwd) {
+  return normalizeWatchIgnorePatterns(paths, cwd);
+}
+function listPmRecordMatches(paths) {
+  if (!existsSync2(paths.appsDir)) {
+    return [];
+  }
+  return readdirSync(paths.appsDir).filter((entry) => entry.endsWith(PM_RECORD_EXTENSION)).map((entry) => {
+    const filePath = join3(paths.appsDir, entry);
+    return {
+      filePath,
+      record: readPmRecord(filePath)
+    };
+  }).sort((left, right) => left.record.name.localeCompare(right.record.name));
+}
+function findPmRecordMatch(paths, nameOrId) {
+  const directPath = getPmRecordPath(paths, sanitizePmProcessName(nameOrId));
+  if (existsSync2(directPath)) {
+    return {
+      filePath: directPath,
+      record: readPmRecord(directPath)
+    };
+  }
+  return listPmRecordMatches(paths).find((match) => match.record.name === nameOrId);
+}
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    return code === "EPERM";
+  }
+}
+function syncPmRecordLiveness(match) {
+  const { record } = match;
+  if (record.desiredState === "running" && record.runnerPid && !isProcessAlive(record.runnerPid)) {
+    const updated = {
+      ...record,
+      status: record.status === "stopping" ? "stopped" : record.status === "errored" ? "errored" : "exited",
+      runnerPid: void 0,
+      childPid: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(match.filePath, updated);
+    return { ...match, record: updated };
+  }
+  if (record.childPid && !isProcessAlive(record.childPid)) {
+    const updated = {
+      ...record,
+      childPid: void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(match.filePath, updated);
+    return { ...match, record: updated };
+  }
+  return match;
+}
+function readLatestPmRecord(filePath, fallback) {
+  return existsSync2(filePath) ? readPmRecord(filePath) : fallback;
+}
+function toPmAppConfig(record) {
+  return {
+    name: record.name,
+    script: record.script,
+    file: record.file,
+    wapk: record.wapk,
+    wapkRun: record.wapkRun,
+    runtime: record.runtime,
+    cwd: record.cwd,
+    env: record.env,
+    autorestart: record.autorestart,
+    restartDelay: record.restartDelay,
+    maxRestarts: record.maxRestarts,
+    password: record.password,
+    restartPolicy: record.restartPolicy,
+    minUptime: record.minUptime,
+    watch: record.watch,
+    watchPaths: record.watchPaths,
+    watchIgnore: record.watchIgnore,
+    watchDebounce: record.watchDebounce,
+    healthCheck: record.healthCheck
+  };
+}
+function toSavedPmAppConfig(app) {
+  return {
+    name: app.name,
+    script: app.script,
+    file: app.file,
+    wapk: app.wapk,
+    wapkRun: app.wapkRun,
+    runtime: app.runtime,
+    cwd: app.cwd,
+    env: app.env,
+    autorestart: app.autorestart,
+    restartDelay: app.restartDelay,
+    maxRestarts: app.maxRestarts,
+    password: app.password,
+    restartPolicy: app.restartPolicy,
+    minUptime: app.minUptime,
+    watch: app.watch,
+    watchPaths: app.watchPaths,
+    watchIgnore: app.watchIgnore,
+    watchDebounce: app.watchDebounce,
+    healthCheck: app.healthCheck
+  };
+}
+
+// src/cli/pm/config.ts
+import { resolve as resolve3 } from "path";
+function parsePmTarget(parsed, workspaceRoot) {
+  if (parsed.script) {
+    return { script: parsed.script };
+  }
+  if (parsed.file) {
+    return { file: parsed.file };
+  }
+  if (parsed.wapk) {
+    return { wapk: parsed.wapk };
+  }
+  if (!parsed.targetToken) {
+    return {};
+  }
+  if (isWapkArchiveSpecifier(parsed.targetToken)) {
+    return { wapk: parsed.targetToken };
+  }
+  if (looksLikeManagedFile(parsed.targetToken, resolve3(workspaceRoot, parsed.cwd ?? "."))) {
+    return { file: parsed.targetToken };
+  }
+  return { configName: parsed.targetToken };
+}
+function getConfiguredPmApps(config) {
+  return Array.isArray(config?.pm?.apps) ? config.pm.apps : [];
+}
+function defaultProcessName(base, explicitName) {
+  if (explicitName && explicitName.trim()) {
+    return explicitName.trim();
+  }
+  if (base.file) {
+    const fileName = base.file.split(/[\\/]/).pop()?.replace(/\.[^.]+$/, "");
+    return fileName || "process";
+  }
+  if (base.wapk) {
+    const fileName = base.wapk.split(/[\\/]/).pop()?.replace(/\.[^.]+$/, "");
+    return fileName || "wapk-app";
+  }
+  if (base.script) {
+    const candidate = base.script.trim().split(/\s+/).slice(0, 2).join("-");
+    return candidate || "process";
+  }
+  return "process";
+}
+function countDefinedTargets(app) {
+  return [app.script, app.file, app.wapk].filter(Boolean).length;
+}
+function resolveStartSelection(configApps, parsed, workspaceRoot) {
+  const target = parsePmTarget(parsed, workspaceRoot);
+  const hasExplicitWapkSource = Boolean(resolvePmWapkSourceToken(parsed.wapk, parsed.wapkRun));
+  const selectedName = target.configName ?? (!target.script && !target.file && !target.wapk && !hasExplicitWapkSource ? parsed.name : void 0);
+  const selected = selectedName ? configApps.find((app) => app.name === selectedName) : void 0;
+  return {
+    selected,
+    startAll: !target.script && !target.file && !target.wapk && !hasExplicitWapkSource && !selectedName,
+    target
+  };
+}
+function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
+  const target = parsePmTarget(parsed, workspaceRoot);
+  const resolvedCwd = resolve3(workspaceRoot, parsed.cwd ?? base?.cwd ?? ".");
+  if (countDefinedPmWapkSources(parsed.wapk, parsed.wapkRun) > 1) {
+    throw new Error("Use only one WAPK archive source per pm start: --wapk or --google-drive-file-id.");
+  }
+  if (countDefinedPmWapkSources(base?.wapk, base?.wapkRun) > 1) {
+    throw new Error(`Configured pm app "${base?.name ?? parsed.name ?? "app"}" must define only one WAPK archive source.`);
+  }
+  const explicitWapk = resolvePmWapkSource(resolvePmWapkSourceToken(target.wapk, parsed.wapkRun), resolvedCwd);
+  const baseWapk = resolvePmWapkSource(resolvePmWapkSourceToken(base?.wapk, base?.wapkRun), resolvedCwd);
+  const hasExplicitTarget = Boolean(target.script || target.file || explicitWapk);
+  const script = target.script ?? (hasExplicitTarget ? void 0 : base?.script);
+  const file = target.file ? resolve3(resolvedCwd, target.file) : hasExplicitTarget ? void 0 : base?.file ? resolve3(resolvedCwd, base.file) : void 0;
+  const wapk = explicitWapk ?? (hasExplicitTarget ? void 0 : baseWapk);
+  const targetCount = countDefinedTargets({ script, file, wapk });
+  if (targetCount === 0) {
+    throw new Error("pm start requires one target: --script, --file, --wapk, or a configured app name.");
+  }
+  if (targetCount > 1) {
+    throw new Error("A pm app must define exactly one of script, file, or wapk.");
+  }
+  const name = defaultProcessName({ script, file, wapk }, parsed.name ?? base?.name);
+  const mergedWapkRun = mergePmWapkRunConfig(base?.wapkRun, parsed.wapkRun);
+  const runtime2 = normalizePmRuntime(parsed.runtime ?? mergedWapkRun?.runtime ?? base?.runtime, "--runtime");
+  let restartPolicy = normalizePmRestartPolicy(parsed.restartPolicy ?? base?.restartPolicy, "--restart-policy") ?? (base?.autorestart ?? true ? "always" : "never");
+  if (parsed.autorestart === false) {
+    restartPolicy = "never";
+  }
+  const autorestart = restartPolicy !== "never";
+  const watch2 = parsed.watch ?? base?.watch ?? false;
+  const configuredWatchPaths = parsed.watchPaths.length > 0 ? parsed.watchPaths : normalizeStringArray(base?.watchPaths);
+  const configuredWatchIgnore = [
+    ...DEFAULT_WATCH_IGNORE,
+    ...normalizeStringArray(base?.watchIgnore),
+    ...parsed.watchIgnore
+  ];
+  const healthCheck = normalizeHealthCheckConfig(parsed.healthCheckUrl ? {
+    url: parsed.healthCheckUrl,
+    gracePeriod: parsed.healthCheckGracePeriod,
+    interval: parsed.healthCheckInterval,
+    timeout: parsed.healthCheckTimeout,
+    maxFailures: parsed.healthCheckMaxFailures
+  } : base?.healthCheck);
+  const password = parsed.password ?? mergedWapkRun?.password ?? base?.password;
+  const wapkRun = stripPmWapkSourceFromRunConfig(mergedWapkRun);
+  if (password && !wapk) {
+    throw new Error("--password is only supported when starting a WAPK app.");
+  }
+  if (wapkRun && !wapk) {
+    throw new Error("WAPK run options are only supported when starting a WAPK app.");
+  }
+  return {
+    name,
+    type: script ? "script" : wapk ? "wapk" : "file",
+    source,
+    cwd: resolvedCwd,
+    runtime: runtime2,
+    env: {
+      ...normalizeEnvMap(base?.env),
+      ...parsed.env
+    },
+    script,
+    file,
+    wapk,
+    wapkRun,
+    autorestart,
+    restartDelay: parsed.restartDelay ?? base?.restartDelay ?? DEFAULT_RESTART_DELAY,
+    maxRestarts: parsed.maxRestarts ?? base?.maxRestarts ?? DEFAULT_MAX_RESTARTS,
+    password,
+    restartPolicy,
+    minUptime: parsed.minUptime ?? base?.minUptime ?? DEFAULT_MIN_UPTIME,
+    watch: watch2,
+    watchPaths: watch2 ? normalizeResolvedWatchPaths(configuredWatchPaths, resolvedCwd, script ? "script" : wapk ? "wapk" : "file", file, wapk) : [],
+    watchIgnore: watch2 ? normalizeResolvedWatchIgnorePaths(configuredWatchIgnore, resolvedCwd) : [],
+    watchDebounce: parsed.watchDebounce ?? base?.watchDebounce ?? DEFAULT_WATCH_DEBOUNCE,
+    healthCheck
+  };
+}
+function resolvePmStartDefinitions(parsed, config, workspaceRoot) {
+  const configApps = getConfiguredPmApps(config);
+  const selection = resolveStartSelection(configApps, parsed, workspaceRoot);
+  if (selection.startAll) {
+    if (configApps.length === 0) {
+      throw new Error("No pm apps configured in elit.config.* and no start target was provided.");
+    }
+    return configApps.map((app) => resolvePmAppDefinition(app, { ...parsed, name: app.name }, workspaceRoot, "config"));
+  }
+  if (selection.selected) {
+    return [resolvePmAppDefinition(selection.selected, parsed, workspaceRoot, "config")];
+  }
+  return [resolvePmAppDefinition(void 0, parsed, workspaceRoot, "cli")];
+}
+function parsePmStartArgs(args) {
+  const parsed = {
+    env: {},
+    watchPaths: [],
+    watchIgnore: []
+  };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--script":
+        parsed.script = readRequiredValue(args, ++index, "--script");
+        break;
+      case "--file":
+      case "-f":
+        parsed.file = readRequiredValue(args, ++index, arg);
+        break;
+      case "--wapk":
+        parsed.wapk = readRequiredValue(args, ++index, "--wapk");
+        break;
+      case "--google-drive-file-id":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            fileId: readRequiredValue(args, ++index, "--google-drive-file-id")
+          }
+        };
+        break;
+      case "--google-drive-token-env":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            accessTokenEnv: readRequiredValue(args, ++index, "--google-drive-token-env")
+          }
+        };
+        break;
+      case "--google-drive-access-token":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            accessToken: readRequiredValue(args, ++index, "--google-drive-access-token")
+          }
+        };
+        break;
+      case "--google-drive-shared-drive":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          googleDrive: {
+            ...parsed.wapkRun?.googleDrive,
+            supportsAllDrives: true
+          }
+        };
+        break;
+      case "--runtime":
+      case "-r":
+        parsed.runtime = normalizePmRuntime(readRequiredValue(args, ++index, arg), arg);
+        break;
+      case "--name":
+      case "-n":
+        parsed.name = readRequiredValue(args, ++index, arg);
+        break;
+      case "--cwd":
+        parsed.cwd = readRequiredValue(args, ++index, "--cwd");
+        break;
+      case "--env": {
+        const [key, value] = parsePmEnvEntry(readRequiredValue(args, ++index, "--env"));
+        parsed.env[key] = value;
+        break;
+      }
+      case "--password":
+        parsed.password = readRequiredValue(args, ++index, "--password");
+        break;
+      case "--online":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          online: true
+        };
+        break;
+      case "--online-url":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          online: true,
+          onlineUrl: readRequiredValue(args, ++index, "--online-url")
+        };
+        break;
+      case "--sync-interval":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          syncInterval: normalizeIntegerOption(readRequiredValue(args, ++index, "--sync-interval"), "--sync-interval", 50)
+        };
+        break;
+      case "--watcher":
+      case "--use-watcher":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          useWatcher: true
+        };
+        break;
+      case "--archive-watch":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          watchArchive: true
+        };
+        break;
+      case "--no-archive-watch":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          watchArchive: false
+        };
+        break;
+      case "--archive-sync-interval":
+        parsed.wapkRun = {
+          ...parsed.wapkRun,
+          archiveSyncInterval: normalizeIntegerOption(readRequiredValue(args, ++index, "--archive-sync-interval"), "--archive-sync-interval", 50)
+        };
+        break;
+      case "--restart-policy":
+        parsed.restartPolicy = normalizePmRestartPolicy(readRequiredValue(args, ++index, "--restart-policy"));
+        break;
+      case "--min-uptime":
+        parsed.minUptime = normalizeIntegerOption(readRequiredValue(args, ++index, "--min-uptime"), "--min-uptime");
+        break;
+      case "--watch":
+        parsed.watch = true;
+        break;
+      case "--watch-path":
+        parsed.watch = true;
+        parsed.watchPaths.push(readRequiredValue(args, ++index, "--watch-path"));
+        break;
+      case "--watch-ignore":
+        parsed.watch = true;
+        parsed.watchIgnore.push(readRequiredValue(args, ++index, "--watch-ignore"));
+        break;
+      case "--watch-debounce":
+        parsed.watch = true;
+        parsed.watchDebounce = normalizeIntegerOption(readRequiredValue(args, ++index, "--watch-debounce"), "--watch-debounce");
+        break;
+      case "--health-url":
+        parsed.healthCheckUrl = readRequiredValue(args, ++index, "--health-url");
+        break;
+      case "--health-grace-period":
+        parsed.healthCheckGracePeriod = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-grace-period"), "--health-grace-period");
+        break;
+      case "--health-interval":
+        parsed.healthCheckInterval = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-interval"), "--health-interval", 250);
+        break;
+      case "--health-timeout":
+        parsed.healthCheckTimeout = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-timeout"), "--health-timeout", 250);
+        break;
+      case "--health-max-failures":
+        parsed.healthCheckMaxFailures = normalizeIntegerOption(readRequiredValue(args, ++index, "--health-max-failures"), "--health-max-failures", 1);
+        break;
+      case "--no-autorestart":
+        parsed.autorestart = false;
+        break;
+      case "--restart-delay":
+        parsed.restartDelay = normalizeIntegerOption(readRequiredValue(args, ++index, "--restart-delay"), "--restart-delay");
+        break;
+      case "--max-restarts":
+        parsed.maxRestarts = normalizeIntegerOption(readRequiredValue(args, ++index, "--max-restarts"), "--max-restarts");
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown pm option: ${arg}`);
+        }
+        if (parsed.targetToken) {
+          throw new Error("pm start accepts at most one positional target.");
+        }
+        parsed.targetToken = arg;
+        break;
+    }
+  }
+  if (countDefinedPmWapkSources(parsed.wapk, parsed.wapkRun) > 1) {
+    throw new Error("Use only one WAPK archive source per pm start: --wapk or --google-drive-file-id.");
+  }
+  const explicitTargets = [parsed.script, parsed.file, resolvePmWapkSourceToken(parsed.wapk, parsed.wapkRun)].filter(Boolean);
+  if (explicitTargets.length > 1) {
+    throw new Error("Use only one target type per pm start: --script, --file, or --wapk.");
+  }
+  if (parsed.healthCheckUrl && !/^https?:\/\//i.test(parsed.healthCheckUrl)) {
+    throw new Error("--health-url must be an absolute http:// or https:// URL");
+  }
+  return parsed;
+}
+function printPmHelp() {
+  console.log([
+    "",
+    "Elit PM - lightweight process manager",
+    "",
+    "Usage:",
+    '  elit pm start --script "npm start" --name my-app --runtime node',
+    "  elit pm start --wapk ./test.wapk --name my-app",
+    "  elit pm start --wapk gdrive://<fileId> --name my-app",
+    "  elit pm start --google-drive-file-id <fileId> --name my-app",
+    "  elit pm start ./app.ts --name my-app",
+    "  elit pm start --file ./app.js --name my-app",
+    "  elit pm start my-app",
+    "  elit pm start",
+    "  elit pm list",
+    "  elit pm stop <name|all>",
+    "  elit pm restart <name|all>",
+    "  elit pm delete <name|all>",
+    "  elit pm save",
+    "  elit pm resurrect",
+    "  elit pm logs <name> --lines 100",
+    "",
+    "Start Options:",
+    "  --script <command>          Run a shell command, for example: npm start",
+    "  --file, -f <path>           Run a .js/.mjs/.cjs/.ts file",
+    "  --wapk <source>             Run a local .wapk file or a remote source like gdrive://<fileId>",
+    "  --google-drive-file-id <id> Run a WAPK archive directly from Google Drive",
+    "  --google-drive-token-env <name>  Env var containing the Google Drive OAuth token",
+    "  --google-drive-access-token <value>  OAuth token forwarded to elit wapk run",
+    "  --google-drive-shared-drive Forward supportsAllDrives=true for shared drives",
+    "  --runtime, -r <name>        Runtime override: node, bun, deno",
+    "  --name, -n <name>           Process name used by list/stop/restart",
+    "  --cwd <dir>                 Working directory for the managed process",
+    "  --env KEY=VALUE             Add or override an environment variable",
+    "  --password <value>          Password for locked WAPK archives",
+    "  --online                    Host the WAPK on Elit Run through PM instead of a local runtime",
+    "  --online-url <url>          Elit Run URL used for PM-managed online WAPK hosting",
+    "  --sync-interval <ms>        Forward WAPK live-sync write interval (>= 50ms)",
+    "  --watcher, --use-watcher    Forward event-driven WAPK file watching",
+    "  --archive-watch             Pull archive source changes back into the temp WAPK workdir",
+    "  --no-archive-watch          Disable archive-source read sync for WAPK apps",
+    "  --archive-sync-interval <ms>  Forward WAPK archive read-sync interval (>= 50ms)",
+    "  --restart-policy <mode>     Restart policy: always, on-failure, never",
+    "  --min-uptime <ms>           Reset crash counter after this healthy uptime",
+    "  --watch                     Restart when watched files change",
+    "  --watch-path <path>         Add a file or directory to watch",
+    "  --watch-ignore <pattern>    Ignore watched paths matching this glob-like pattern",
+    "  --watch-debounce <ms>       Debounce file-triggered restarts (default 250)",
+    "  --health-url <url>          Poll an HTTP endpoint and restart after repeated failures",
+    "  --health-grace-period <ms>  Delay before the first health check (default 5000)",
+    "  --health-interval <ms>      Health check interval (default 10000)",
+    "  --health-timeout <ms>       Per-request health check timeout (default 3000)",
+    "  --health-max-failures <n>   Consecutive failures before restart (default 3)",
+    "  --no-autorestart            Disable automatic restart",
+    "  --restart-delay <ms>        Delay between restart attempts (default 1000)",
+    "  --max-restarts <count>      Maximum restart attempts (default 10)",
+    "",
+    "Config:",
+    "  Add pm.apps[] to elit.config.* and run elit pm start to boot all configured apps.",
+    "",
+    "Example:",
+    "  export default {",
+    "    pm: {",
+    "      apps: [",
+    '        { name: "api", script: "npm start", cwd: ".", runtime: "node" },',
+    '        { name: "worker", file: "./src/worker.ts", runtime: "bun" },',
+    '        { name: "desktop-app", wapk: "./dist/app.wapk", runtime: "node" },',
+    '        { name: "drive-app", wapkRun: { googleDrive: { fileId: "1AbCdEfGhIjKlMnOp", accessTokenEnv: "GOOGLE_DRIVE_ACCESS_TOKEN" }, useWatcher: true, watchArchive: true } }',
+    '        { name: "online-app", wapk: "./dist/app.wapk", wapkRun: { online: true, onlineUrl: "http://localhost:4179" } }',
+    "      ]",
+    "    }",
+    "  }",
+    "",
+    "Notes:",
+    "  - PM state and logs are stored in ./.elit/pm by default.",
+    "  - elit pm save persists running apps to pm.dumpFile or ./.elit/pm/dump.json.",
+    "  - elit pm resurrect restarts whatever was last saved by elit pm save.",
+    "  - elit pm start <name> starts a configured app by name.",
+    "  - TypeScript files with runtime node require tsx, otherwise use --runtime bun.",
+    "  - WAPK processes are executed through elit wapk run inside the manager.",
+    "  - WAPK PM apps can use local archives, gdrive://<fileId>, or pm.apps[].wapkRun.googleDrive.",
+    "  - PM-managed WAPK online hosts close their Elit Run share session when you use elit pm stop, restart, or delete."
+  ].join("\n"));
+}
+
+// src/cli/pm/process.ts
+import { spawn, spawnSync } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { basename, join as join4 } from "path";
+function readCurrentCliInvocation() {
+  const cliEntry = process.argv[1];
+  if (!cliEntry) {
+    throw new Error("Unable to resolve the current Elit CLI entrypoint for pm runner startup.");
+  }
+  return {
+    command: process.execPath,
+    args: [...process.execArgv, cliEntry]
+  };
+}
+function preferCurrentExecutable(runtime2) {
+  const executableName = basename(process.execPath).toLowerCase();
+  if (runtime2 === "node" && process.release?.name === "node" && executableName.startsWith("node")) {
+    return process.execPath;
+  }
+  if (runtime2 === "bun" && process.versions?.bun && executableName.startsWith("bun")) {
+    return process.execPath;
+  }
+  return runtime2;
+}
+function commandExists(command) {
+  if (command.includes("\\") || command.includes("/")) {
+    return existsSync3(command);
+  }
+  const result = spawnSync(command, ["--version"], {
+    stdio: "ignore",
+    windowsHide: true
+  });
+  return !result.error;
+}
+function ensureCommandAvailable(command, displayName) {
+  if (commandExists(command)) {
+    return;
+  }
+  throw new Error(`${displayName} was not found in PATH.`);
+}
+function resolveTsxExecutable(cwd) {
+  const localPath = join4(cwd, "node_modules", ".bin", process.platform === "win32" ? "tsx.cmd" : "tsx");
+  if (existsSync3(localPath)) {
+    return localPath;
+  }
+  const globalCommand = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  return commandExists(globalCommand) ? globalCommand : void 0;
+}
+function inferRuntimeFromFile(filePath) {
+  if (isTypescriptFile(filePath) && commandExists("bun")) {
+    return "bun";
+  }
+  return "node";
+}
+function isPmOnlineWapkRecord(record) {
+  return record.type === "wapk" && isPmWapkOnlineRunConfig(record.wapkRun);
+}
+function buildPmCommand(record) {
+  if (record.type === "script") {
+    return {
+      command: record.script,
+      args: [],
+      shell: true,
+      runtime: record.runtime,
+      preview: record.script
+    };
+  }
+  if (record.type === "wapk") {
+    const cliInvocation = readCurrentCliInvocation();
+    const args = [
+      ...cliInvocation.args,
+      "wapk",
+      "run",
+      record.wapk
+    ];
+    const previewParts = ["elit", "wapk", "run", quoteCommandSegment(record.wapk)];
+    const online = isPmOnlineWapkRecord(record);
+    if (record.runtime && !online) {
+      args.push("--runtime", record.runtime);
+      previewParts.push("--runtime", record.runtime);
+    }
+    if (record.password) {
+      args.push("--password", record.password);
+      previewParts.push("--password", "******");
+    }
+    appendPmWapkRunArgs(args, previewParts, record.wapkRun);
+    return {
+      command: cliInvocation.command,
+      args,
+      env: online ? { [PM_WAPK_ONLINE_STDIN_SHUTDOWN_ENV]: "1" } : void 0,
+      preview: previewParts.join(" "),
+      runtime: online ? void 0 : record.runtime
+    };
+  }
+  const runtime2 = record.runtime ?? inferRuntimeFromFile(record.file);
+  if (runtime2 === "bun") {
+    const executable2 = preferCurrentExecutable("bun");
+    ensureCommandAvailable(executable2, "Bun runtime");
+    return {
+      command: executable2,
+      args: ["run", record.file],
+      runtime: runtime2,
+      preview: `${basename(executable2)} run ${quoteCommandSegment(record.file)}`
+    };
+  }
+  if (runtime2 === "deno") {
+    const executable2 = preferCurrentExecutable("deno");
+    ensureCommandAvailable(executable2, "Deno runtime");
+    return {
+      command: executable2,
+      args: ["run", "--allow-all", record.file],
+      runtime: runtime2,
+      preview: `${basename(executable2)} run --allow-all ${quoteCommandSegment(record.file)}`
+    };
+  }
+  if (isTypescriptFile(record.file)) {
+    const tsxExecutable = resolveTsxExecutable(record.cwd);
+    if (!tsxExecutable) {
+      throw new Error('TypeScript file execution with runtime "node" requires tsx to be installed, or use --runtime bun.');
+    }
+    return {
+      command: tsxExecutable,
+      args: [record.file],
+      runtime: runtime2,
+      preview: `${basename(tsxExecutable)} ${quoteCommandSegment(record.file)}`
+    };
+  }
+  const executable = preferCurrentExecutable("node");
+  ensureCommandAvailable(executable, "Node.js runtime");
+  return {
+    command: executable,
+    args: [record.file],
+    runtime: runtime2,
+    preview: `${basename(executable)} ${quoteCommandSegment(record.file)}`
+  };
+}
+function createRecordFromDefinition(definition, paths, existing) {
+  const id = sanitizePmProcessName(definition.name);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const preview = definition.type === "script" ? definition.script : definition.type === "wapk" ? buildPmWapkPreview(definition.wapk, definition.runtime, definition.password, definition.wapkRun) : `${definition.runtime ?? "auto"} ${quoteCommandSegment(definition.file)}`;
+  return {
+    id,
+    name: definition.name,
+    type: definition.type,
+    source: definition.source,
+    cwd: definition.cwd,
+    runtime: definition.runtime,
+    env: definition.env,
+    script: definition.script,
+    file: definition.file,
+    wapk: definition.wapk,
+    wapkRun: definition.wapkRun,
+    autorestart: definition.autorestart,
+    restartDelay: definition.restartDelay,
+    maxRestarts: definition.maxRestarts,
+    password: definition.password,
+    restartPolicy: definition.restartPolicy,
+    minUptime: definition.minUptime,
+    watch: definition.watch,
+    watchPaths: definition.watchPaths,
+    watchIgnore: definition.watchIgnore,
+    watchDebounce: definition.watchDebounce,
+    healthCheck: definition.healthCheck,
+    desiredState: "running",
+    status: "starting",
+    commandPreview: preview,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    startedAt: void 0,
+    stoppedAt: void 0,
+    runnerPid: void 0,
+    childPid: void 0,
+    restartCount: existing?.restartCount ?? 0,
+    lastExitCode: existing?.lastExitCode,
+    error: void 0,
+    logFiles: existing?.logFiles ?? {
+      out: join4(paths.logsDir, `${id}.out.log`),
+      err: join4(paths.logsDir, `${id}.err.log`)
+    }
+  };
+}
+function terminateProcessTree(pid) {
+  if (process.platform === "win32") {
+    const result = spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    if (result.error && result.error.code !== "ENOENT") {
+      throw result.error;
+    }
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ESRCH") {
+      throw error;
+    }
+  }
+}
+async function startManagedProcess(definition, paths) {
+  ensurePmDirectories(paths);
+  const id = sanitizePmProcessName(definition.name);
+  const recordPath = getPmRecordPath(paths, id);
+  const existingMatch = existsSync3(recordPath) ? syncPmRecordLiveness({ filePath: recordPath, record: readPmRecord(recordPath) }) : void 0;
+  if (existingMatch?.record.runnerPid && isProcessAlive(existingMatch.record.runnerPid)) {
+    throw new Error(`Process "${definition.name}" is already running.`);
+  }
+  const record = createRecordFromDefinition(definition, paths, existingMatch?.record);
+  writePmRecord(recordPath, record);
+  const cliInvocation = readCurrentCliInvocation();
+  const runner = spawn(cliInvocation.command, [
+    ...cliInvocation.args,
+    "pm",
+    "__run",
+    "--data-dir",
+    paths.dataDir,
+    "--id",
+    record.id
+  ], {
+    cwd: definition.cwd,
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: {
+      ...process.env,
+      ELIT_PM_INTERNAL: "1"
+    }
+  });
+  if (!runner.pid) {
+    throw new Error(`Failed to start process runner for "${definition.name}".`);
+  }
+  runner.unref();
+  const startedRecord = {
+    ...record,
+    runnerPid: runner.pid,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writePmRecord(recordPath, startedRecord);
+  return startedRecord;
+}
+
+// src/cli/pm/runner.ts
+import { spawn as spawn2 } from "child_process";
+import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
+import { EOL } from "os";
+import { dirname as dirname3, join as join6, resolve as resolve5 } from "path";
+
+// src/server/chokidar/watch.ts
+init_runtime();
+
+// src/server/chokidar/utils.ts
+init_fs();
+
+// src/server/path/platform.ts
+init_runtime();
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  }
+  if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  }
+  if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+
+// src/server/path/operations.ts
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
+    if (part === "" || part === ".") {
+      if (index === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let finalPath = result.join(separator);
+  if (finalPath.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+    finalPath += separator;
+  }
+  return finalPath;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let index = 0; index < paths.length; index++) {
+    const path = paths[index];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let absolute = false;
+  for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+    const path = paths[index];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!absolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  const resolvedFrom = resolvePaths([from], isWin);
+  const resolvedTo = resolvePaths([to], isWin);
+  if (resolvedFrom === resolvedTo) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+  const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
+  const minLength = Math.min(fromParts.length, toParts.length);
+  let commonLength = 0;
+  for (let index = 0; index < minLength; index++) {
+    if (fromParts[index] === toParts[index]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const result = [];
+  const upCount = fromParts.length - commonLength;
+  for (let index = 0; index < upCount; index++) {
+    result.push("..");
+  }
+  for (let index = commonLength; index < toParts.length; index++) {
+    result.push(toParts[index]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSeparatorIndex = normalized.lastIndexOf(separator);
+  if (lastSeparatorIndex === -1) return ".";
+  if (lastSeparatorIndex === 0) return separator;
+  return normalized.slice(0, lastSeparatorIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSeparatorIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else if (path[0] === "/") {
+    root = "/";
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+
+// src/server/path/runtime.ts
+init_runtime();
+
+// src/server/path/index.ts
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function join5(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function resolve4(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+function dirname2(path) {
+  return getDirname(path, isWindows);
+}
+
+// src/server/chokidar/utils.ts
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/");
+}
+function emitEvent(watcher, eventType, path) {
+  watcher.emit(eventType, path);
+  watcher.emit("all", eventType, path);
+}
+function matchesPattern(filePath, pattern) {
+  const regexPattern = normalizePath2(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const normalizedPath = normalizePath2(filePath);
+  return regex.test(normalizedPath);
+}
+function matchesAnyPattern(path, patterns) {
+  return patterns.some((pattern) => matchesPattern(path, pattern));
+}
+function getBaseDirectory(pattern) {
+  const normalizedPattern = normalizePath2(pattern);
+  const parts = normalizedPattern.split(/[\\/]/);
+  let baseDir = "";
+  let sawGlob = false;
+  for (const part of parts) {
+    if (part.includes("*") || part.includes("?")) {
+      sawGlob = true;
+      break;
+    }
+    baseDir = baseDir ? `${baseDir}/${part}` : part;
+  }
+  if (sawGlob) {
+    return baseDir || ".";
+  }
+  if (normalizedPattern && existsSync4(normalizedPattern)) {
+    try {
+      return statSync2(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname2(normalizedPattern)) || ".";
+    } catch {
+      return normalizePath2(dirname2(normalizedPattern)) || ".";
+    }
+  }
+  const lastSegment = parts[parts.length - 1] || "";
+  if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
+    return normalizePath2(dirname2(normalizedPattern)) || ".";
+  }
+  return normalizedPattern || ".";
+}
+
+// src/server/chokidar/native-watch.ts
+function handleRenameEvent(watcher, fullPath, fs2) {
+  try {
+    fs2.statSync(fullPath);
+    emitEvent(watcher, "add", fullPath);
+  } catch {
+    emitEvent(watcher, "unlink", fullPath);
+  }
+}
+function setupFsWatch(watcher, baseDir, patterns, fs2) {
+  try {
+    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = normalizePath2(`${baseDir}/${filename}`);
+      if (!matchesAnyPattern(fullPath, patterns)) return;
+      if (eventType === "rename") {
+        handleRenameEvent(watcher, fullPath, fs2);
+      } else if (eventType === "change") {
+        emitEvent(watcher, "change", fullPath);
+      }
+    });
+    watcher._setWatcher(nativeWatcher);
+    watcher._trackWatchedPath(baseDir);
+    queueMicrotask(() => watcher.emit("ready"));
+  } catch (error) {
+    watcher.emit("error", error);
+  }
+}
+
+// src/server/chokidar/watcher.ts
+init_runtime();
+import { EventEmitter } from "events";
+var FSWatcher = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this._closed = false;
+    this._watched = /* @__PURE__ */ new Set();
+    this.options = options || {};
+  }
+  /**
+   * Add paths to be watched
+   */
+  add(paths) {
+    if (this._closed) {
+      throw new Error("Watcher has been closed");
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (this._watcher && typeof this._watcher.add === "function") {
+      this._watcher.add(pathArray);
+    }
+    if (runtime !== "node" || !this._watcher || typeof this._watcher.add !== "function") {
+      pathArray.forEach((path) => this._trackWatchedPath(path));
+    }
+    return this;
+  }
+  /**
+   * Stop watching paths
+   */
+  unwatch(paths) {
+    if (this._closed) {
+      return this;
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (this._watcher && typeof this._watcher.unwatch === "function") {
+      this._watcher.unwatch(pathArray);
+    }
+    if (runtime !== "node" || !this._watcher || typeof this._watcher.unwatch !== "function") {
+      pathArray.forEach((path) => this._untrackWatchedPath(path));
+    }
+    return this;
+  }
+  /**
+   * Close the watcher
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (this._watcher && typeof this._watcher.close === "function") {
+      await this._watcher.close();
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    if (this._watcher && typeof this._watcher.getWatched === "function") {
+      return this._watcher.getWatched();
+    }
+    const result = {};
+    this._watched.forEach((path) => {
+      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
+      const file = path.substring(path.lastIndexOf("/") + 1);
+      if (!result[dir]) {
+        result[dir] = [];
+      }
+      result[dir].push(file);
+    });
+    return result;
+  }
+  /**
+   * Internal method to set native watcher
+   * @internal
+   */
+  _setWatcher(watcher) {
+    this._watcher = watcher;
+  }
+  /**
+   * Internal method to track watched paths
+   * @internal
+   */
+  _trackWatchedPath(path) {
+    this._watched.add(path);
+  }
+  /**
+   * Internal method to untrack watched paths
+   * @internal
+   */
+  _untrackWatchedPath(path) {
+    this._watched.delete(path);
+  }
+  /**
+   * Internal method to read closed state
+   * @internal
+   */
+  _isClosed() {
+    return this._closed;
+  }
+};
+
+// src/server/chokidar/watch.ts
+function createWatchMap(paths) {
+  const watchMap = /* @__PURE__ */ new Map();
+  paths.forEach((path) => {
+    const baseDir = getBaseDirectory(path);
+    if (!watchMap.has(baseDir)) {
+      watchMap.set(baseDir, []);
+    }
+    watchMap.get(baseDir).push(path);
+  });
+  return watchMap;
+}
+function setupDenoWatch(watcher, watchMap, pathArray) {
+  const baseDirs = Array.from(watchMap.keys());
+  const allPatterns = Array.from(watchMap.values()).flat();
+  (async () => {
+    try {
+      const denoWatcher = Deno.watchFs(baseDirs);
+      for await (const event of denoWatcher) {
+        if (watcher._isClosed()) break;
+        for (const path of event.paths) {
+          const normalizedPath = normalizePath2(path);
+          if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
+          switch (event.kind) {
+            case "create":
+              emitEvent(watcher, "add", path);
+              break;
+            case "modify":
+              emitEvent(watcher, "change", path);
+              break;
+            case "remove":
+              emitEvent(watcher, "unlink", path);
+              break;
+          }
+        }
+      }
+    } catch (error) {
+      if (!watcher._isClosed()) {
+        watcher.emit("error", error);
+      }
+    }
+  })();
+  pathArray.forEach((path) => watcher.add(path));
+  queueMicrotask(() => watcher.emit("ready"));
+}
+function watch(paths, options) {
+  const watcher = new FSWatcher(options);
+  const pathArray = Array.isArray(paths) ? paths : [paths];
+  const watchMap = createWatchMap(pathArray);
+  if (runtime === "node" || runtime === "bun") {
+    const fs2 = __require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+  } else if (runtime === "deno") {
+    setupDenoWatch(watcher, watchMap, pathArray);
+  }
+  return watcher;
+}
+
+// src/cli/pm/runner.ts
+function writePmLog(stream, message) {
+  stream.write(`[elit pm] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}${EOL}`);
+}
+function waitForExit(code, signal) {
+  if (typeof code === "number") {
+    return code;
+  }
+  if (signal === "SIGINT" || signal === "SIGTERM") {
+    return 0;
+  }
+  return 1;
+}
+async function delay(milliseconds) {
+  await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+async function waitForProcessTermination(pid, timeoutMs) {
+  if (!pid || !isProcessAlive(pid)) {
+    return true;
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await delay(DEFAULT_PM_STOP_POLL_MS);
+  }
+  return !isProcessAlive(pid);
+}
+async function waitForManagedChildExit(child) {
+  return await new Promise((resolvePromise) => {
+    let resolved = false;
+    child.once("error", (error) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolvePromise({ code: 1, signal: null, error: error instanceof Error ? error.message : String(error) });
+    });
+    child.once("close", (code, signal) => {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolvePromise({ code, signal });
+    });
+  });
+}
+async function createPmWatchController(record, onChange, onError) {
+  if (!record.watch || record.watchPaths.length === 0) {
+    return {
+      async close() {
+      }
+    };
+  }
+  const watcher = watch(record.watchPaths);
+  let debounceTimer = null;
+  const scheduleRestart = (filePath) => {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (isIgnoredWatchPath(normalizedPath, record.watchIgnore)) {
+      return;
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      onChange(normalizedPath);
+    }, record.watchDebounce);
+    debounceTimer.unref?.();
+  };
+  watcher.on("add", scheduleRestart);
+  watcher.on("change", scheduleRestart);
+  watcher.on("unlink", scheduleRestart);
+  watcher.on("error", (error) => onError(error instanceof Error ? error.message : String(error)));
+  return {
+    async close() {
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      await watcher.close();
+    }
+  };
+}
+function createPmHealthMonitor(record, onFailure, onLog) {
+  if (!record.healthCheck) {
+    return {
+      stop() {
+      }
+    };
+  }
+  const healthCheck = record.healthCheck;
+  let stopped = false;
+  let timer = null;
+  let initialDelay = null;
+  let inFlight = false;
+  let failureCount = 0;
+  const runHealthCheck = async () => {
+    if (stopped || inFlight) {
+      return;
+    }
+    inFlight = true;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), healthCheck.timeout);
+    timeoutId.unref?.();
+    try {
+      const response = await fetch(healthCheck.url, {
+        method: "GET",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`health check returned ${response.status}`);
+      }
+      failureCount = 0;
+    } catch (error) {
+      failureCount += 1;
+      const message = error instanceof Error ? error.message : String(error);
+      onLog(`health check failed (${failureCount}/${healthCheck.maxFailures}): ${message}`);
+      if (failureCount >= healthCheck.maxFailures) {
+        stopped = true;
+        onFailure(`health check failed ${failureCount} times: ${message}`);
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      inFlight = false;
+    }
+  };
+  initialDelay = setTimeout(() => {
+    void runHealthCheck();
+    timer = setInterval(() => {
+      void runHealthCheck();
+    }, healthCheck.interval);
+    timer.unref?.();
+  }, healthCheck.gracePeriod);
+  initialDelay.unref?.();
+  return {
+    stop() {
+      stopped = true;
+      if (initialDelay) {
+        clearTimeout(initialDelay);
+        initialDelay = null;
+      }
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+}
+function readPlannedRestartRequest(state) {
+  return state.request;
+}
+async function runManagedProcessLoop(filePath, initialRecord) {
+  let record = initialRecord;
+  let activeChild = null;
+  let activeChildStopTimer = null;
+  let stopRequested = false;
+  const restartState = { request: null };
+  mkdirSync3(dirname3(initialRecord.logFiles.out), { recursive: true });
+  mkdirSync3(dirname3(initialRecord.logFiles.err), { recursive: true });
+  const stdoutLog = createWriteStream(initialRecord.logFiles.out, { flags: "a" });
+  const stderrLog = createWriteStream(initialRecord.logFiles.err, { flags: "a" });
+  const persist = (mutator) => {
+    const current = readLatestPmRecord(filePath, record);
+    record = mutator(current);
+    writePmRecord(filePath, record);
+    return record;
+  };
+  const clearActiveChildStopTimer = () => {
+    if (activeChildStopTimer) {
+      clearTimeout(activeChildStopTimer);
+      activeChildStopTimer = null;
+    }
+  };
+  const stopActiveChild = () => {
+    if (!activeChild?.pid || !isProcessAlive(activeChild.pid)) {
+      return;
+    }
+    const current = readLatestPmRecord(filePath, record);
+    if (isPmOnlineWapkRecord(current) && activeChild.stdin && !activeChild.stdin.destroyed && activeChild.stdin.writable) {
+      try {
+        activeChild.stdin.end(`${PM_WAPK_ONLINE_SHUTDOWN_COMMAND}
+`);
+        clearActiveChildStopTimer();
+        activeChildStopTimer = setTimeout(() => {
+          if (activeChild?.pid && isProcessAlive(activeChild.pid)) {
+            writePmLog(
+              stderrLog,
+              `graceful WAPK online shutdown timed out after ${PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS}ms; forcing process termination`
+            );
+            terminateProcessTree(activeChild.pid);
+          }
+        }, PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS);
+        activeChildStopTimer.unref?.();
+        return;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writePmLog(stderrLog, `graceful WAPK online shutdown failed: ${message}`);
+      }
+    }
+    terminateProcessTree(activeChild.pid);
+  };
+  const requestManagedStop = (reason) => {
+    if (stopRequested) {
+      return;
+    }
+    stopRequested = true;
+    persist((current) => ({
+      ...current,
+      desiredState: "stopped",
+      status: "stopping",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    writePmLog(stdoutLog, reason);
+    stopActiveChild();
+  };
+  const handleStopSignal = (signal) => {
+    requestManagedStop(`received ${signal}, stopping managed process`);
+  };
+  process.on("SIGINT", handleStopSignal);
+  process.on("SIGTERM", handleStopSignal);
+  persist((current) => ({
+    ...current,
+    runnerPid: process.pid,
+    desiredState: "running",
+    status: "starting",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  try {
+    while (!stopRequested) {
+      restartState.request = null;
+      const latest = readLatestPmRecord(filePath, record);
+      if (latest.desiredState === "stopped") {
+        break;
+      }
+      let command;
+      try {
+        command = buildPmCommand(latest);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writePmLog(stderrLog, message);
+        persist((current2) => ({
+          ...current2,
+          status: "errored",
+          error: message,
+          runnerPid: void 0,
+          childPid: void 0,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return;
+      }
+      const onlineStdinShutdownEnabled = isPmOnlineWapkRecord(latest);
+      const child = spawn2(command.command, command.args, {
+        cwd: latest.cwd,
+        env: {
+          ...process.env,
+          ...latest.env,
+          ...command.env,
+          ELIT_PM_NAME: latest.name,
+          ELIT_PM_ID: latest.id
+        },
+        stdio: [onlineStdinShutdownEnabled ? "pipe" : "ignore", "pipe", "pipe"],
+        windowsHide: true,
+        shell: command.shell
+      });
+      const childStartedAt = Date.now();
+      activeChild = child;
+      if (child.stdout) {
+        child.stdout.pipe(stdoutLog, { end: false });
+      }
+      if (child.stderr) {
+        child.stderr.pipe(stderrLog, { end: false });
+      }
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      persist((current2) => ({
+        ...current2,
+        status: "online",
+        commandPreview: command.preview,
+        runtime: command.runtime ?? current2.runtime,
+        runnerPid: process.pid,
+        childPid: child.pid,
+        startedAt,
+        stoppedAt: void 0,
+        error: void 0,
+        updatedAt: startedAt
+      }));
+      writePmLog(stdoutLog, `started ${command.preview}${child.pid ? ` (pid ${child.pid})` : ""}`);
+      const requestPlannedRestart = (kind, detail) => {
+        if (stopRequested || restartState.request) {
+          return;
+        }
+        restartState.request = { kind, detail };
+        writePmLog(kind === "health" ? stderrLog : stdoutLog, `${kind} restart requested: ${detail}`);
+        persist((current2) => ({
+          ...current2,
+          status: "restarting",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        stopActiveChild();
+      };
+      const watchController = await createPmWatchController(
+        latest,
+        (changedPath) => requestPlannedRestart("watch", changedPath),
+        (message) => writePmLog(stderrLog, `watch error: ${message}`)
+      );
+      const healthMonitor = createPmHealthMonitor(
+        latest,
+        (message) => requestPlannedRestart("health", message),
+        (message) => writePmLog(stdoutLog, message)
+      );
+      const desiredStatePoller = setInterval(() => {
+        const latestRecord = readLatestPmRecord(filePath, record);
+        if (!stopRequested && latestRecord.desiredState === "stopped") {
+          requestManagedStop("stop requested by PM control state");
+        }
+      }, DEFAULT_PM_STOP_POLL_MS);
+      desiredStatePoller.unref?.();
+      const exitResult = await waitForManagedChildExit(child);
+      clearInterval(desiredStatePoller);
+      await watchController.close();
+      healthMonitor.stop();
+      clearActiveChildStopTimer();
+      activeChild = null;
+      const exitCode = waitForExit(exitResult.code, exitResult.signal);
+      const current = readLatestPmRecord(filePath, record);
+      const plannedRestart = readPlannedRestartRequest(restartState);
+      const uptime = Math.max(0, Date.now() - childStartedAt);
+      const wasStable = current.minUptime > 0 && uptime >= current.minUptime;
+      if (exitResult.error) {
+        writePmLog(stderrLog, exitResult.error);
+      } else if (!plannedRestart) {
+        writePmLog(stdoutLog, `process exited with code ${exitCode}`);
+      }
+      if (stopRequested || current.desiredState === "stopped") {
+        break;
+      }
+      const shouldRestartForExit = plannedRestart ? true : current.restartPolicy === "always" ? true : current.restartPolicy === "on-failure" ? exitCode !== 0 || Boolean(exitResult.error) : false;
+      if (!shouldRestartForExit) {
+        persist((latestRecord) => ({
+          ...latestRecord,
+          status: exitCode === 0 && !exitResult.error ? "exited" : "errored",
+          childPid: void 0,
+          runnerPid: void 0,
+          lastExitCode: exitCode,
+          error: exitCode === 0 && !exitResult.error ? void 0 : exitResult.error ?? `Process exited with code ${exitCode}.`,
+          stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        return;
+      }
+      const shouldCountRestart = plannedRestart?.kind !== "watch";
+      const baseRestartCount = wasStable ? 0 : current.restartCount ?? 0;
+      const nextRestartCount = shouldCountRestart ? baseRestartCount + 1 : current.restartCount ?? 0;
+      if (nextRestartCount > current.maxRestarts) {
+        persist((latestRecord) => ({
+          ...latestRecord,
+          status: "errored",
+          childPid: void 0,
+          runnerPid: void 0,
+          restartCount: nextRestartCount,
+          lastExitCode: exitCode,
+          error: plannedRestart ? `Reached max restart attempts (${current.maxRestarts}) after ${plannedRestart.kind} restart requests.` : `Reached max restart attempts (${current.maxRestarts}).`,
+          stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+        writePmLog(stderrLog, `max restart attempts reached (${current.maxRestarts})`);
+        return;
+      }
+      persist((latestRecord) => ({
+        ...latestRecord,
+        status: "restarting",
+        childPid: void 0,
+        lastExitCode: exitCode,
+        restartCount: nextRestartCount,
+        error: void 0,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      if (plannedRestart) {
+        writePmLog(
+          plannedRestart.kind === "health" ? stderrLog : stdoutLog,
+          `restarting in ${current.restartDelay}ms after ${plannedRestart.kind}: ${plannedRestart.detail}`
+        );
+      } else {
+        writePmLog(stdoutLog, `restarting in ${current.restartDelay}ms`);
+      }
+      await delay(current.restartDelay);
+    }
+  } finally {
+    stopRequested = true;
+    stopActiveChild();
+    clearActiveChildStopTimer();
+    const finalRecord = readLatestPmRecord(filePath, record);
+    writePmRecord(filePath, {
+      ...finalRecord,
+      desiredState: "stopped",
+      status: finalRecord.status === "errored" ? "errored" : finalRecord.status === "exited" ? "exited" : "stopped",
+      runnerPid: void 0,
+      childPid: void 0,
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    process.off("SIGINT", handleStopSignal);
+    process.off("SIGTERM", handleStopSignal);
+    await new Promise((resolvePromise) => stdoutLog.end(resolvePromise));
+    await new Promise((resolvePromise) => stderrLog.end(resolvePromise));
+  }
+}
+function parseRunnerArgs(args) {
+  let dataDir;
+  let id;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--data-dir":
+        dataDir = readRequiredValue(args, ++index, "--data-dir");
+        break;
+      case "--id":
+        id = readRequiredValue(args, ++index, "--id");
+        break;
+      default:
+        throw new Error(`Unknown internal pm runner option: ${arg}`);
+    }
+  }
+  if (!dataDir || !id) {
+    throw new Error("Usage: elit pm __run --data-dir <dir> --id <name>");
+  }
+  return {
+    dataDir: resolve5(dataDir),
+    id
+  };
+}
+async function runPmRunner(args) {
+  const options = parseRunnerArgs(args);
+  const paths = {
+    dataDir: options.dataDir,
+    appsDir: join6(options.dataDir, "apps"),
+    logsDir: join6(options.dataDir, "logs"),
+    dumpFile: join6(options.dataDir, DEFAULT_PM_DUMP_FILE)
+  };
+  const match = findPmRecordMatch(paths, options.id);
+  if (!match) {
+    throw new Error(`PM record not found: ${options.id}`);
+  }
+  await runManagedProcessLoop(match.filePath, match.record);
+}
+async function stopPmMatches(matches) {
+  let stopped = 0;
+  for (const match of matches) {
+    const updated = {
+      ...match.record,
+      desiredState: "stopped",
+      status: match.record.runnerPid ? "stopping" : "stopped",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    writePmRecord(match.filePath, updated);
+    const runnerStopped = await waitForProcessTermination(match.record.runnerPid, DEFAULT_PM_STOP_GRACE_PERIOD_MS);
+    const childStopped = await waitForProcessTermination(
+      match.record.childPid,
+      runnerStopped ? DEFAULT_PM_STOP_POLL_MS : DEFAULT_PM_STOP_GRACE_PERIOD_MS
+    );
+    if (!runnerStopped && match.record.runnerPid && isProcessAlive(match.record.runnerPid)) {
+      terminateProcessTree(match.record.runnerPid);
+      await waitForProcessTermination(match.record.runnerPid, DEFAULT_PM_STOP_POLL_MS);
+    }
+    if (!childStopped && match.record.childPid && isProcessAlive(match.record.childPid)) {
+      terminateProcessTree(match.record.childPid);
+      await waitForProcessTermination(match.record.childPid, DEFAULT_PM_STOP_POLL_MS);
+    }
+    writePmRecord(match.filePath, {
+      ...updated,
+      runnerPid: void 0,
+      childPid: void 0,
+      status: "stopped",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    stopped += 1;
+  }
+  return stopped;
+}
+
+// src/cli/pm/commands.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, rmSync } from "fs";
+import { EOL as EOL2 } from "os";
+
+// src/shares/config/constants.ts
+var ELIT_CONFIG_FILES = [
+  "elit.config.ts",
+  "elit.config.mts",
+  "elit.config.js",
+  "elit.config.mjs",
+  "elit.config.cjs",
+  "elit.config.json"
+];
+
+// src/shares/config/env.ts
+init_fs();
+
+// src/shares/config/utils.ts
+init_fs();
+function readFileAsString(filePath) {
+  const contentBuffer = readFileSync2(filePath, "utf-8");
+  return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+}
+function normalizeRelativeImportPath(fromDirectory, targetPath) {
+  const relativePath2 = relative(fromDirectory, targetPath).replace(/\\/g, "/");
+  return relativePath2.startsWith(".") ? relativePath2 : `./${relativePath2}`;
+}
+async function importConfigModule(configPath) {
+  const { pathToFileURL } = await import("url");
+  const configModule = await import(pathToFileURL(configPath).href);
+  return configModule.default || configModule;
+}
+async function safeCleanup(filePath) {
+  try {
+    const { unlinkSync: unlinkSync2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
+
+// src/shares/config/loader.ts
+init_fs();
+
+// src/shares/workspace-package/roots.ts
+init_fs();
+
+// src/shares/workspace-package/package-json.ts
+init_fs();
+function readPackageJson(filePath) {
+  try {
+    const packageJsonBuffer = readFileSync2(filePath, "utf-8");
+    const packageJsonText = typeof packageJsonBuffer === "string" ? packageJsonBuffer : packageJsonBuffer.toString("utf-8");
+    return JSON.parse(packageJsonText);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/shares/workspace-package/roots.ts
+function findPackageDirectory(startDir, resolveMatch) {
+  let currentDir = resolve4(startDir);
+  while (true) {
+    const match = resolveMatch(currentDir);
+    if (match) {
+      return match;
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function findWorkspacePackageRoot(startDir, packageName) {
+  return findPackageDirectory(startDir, (currentDir) => {
+    const packageJsonPath = join5(currentDir, "package.json");
+    const packageJson = existsSync4(packageJsonPath) ? readPackageJson(packageJsonPath) : void 0;
+    return packageJson?.name === packageName ? currentDir : void 0;
+  });
+}
+function findInstalledPackageRoot(startDir, packageName) {
+  return findPackageDirectory(startDir, (currentDir) => {
+    const candidate = join5(currentDir, "node_modules", ...packageName.split("/"));
+    return existsSync4(candidate) ? candidate : void 0;
+  });
+}
+
+// src/shares/workspace-package/resolve.ts
+init_fs();
+
+// src/shares/workspace-package/candidates.ts
+function getWorkspacePackageImportCandidates(packageRoot, specifier, options = {}) {
+  const subpath = specifier === "elit" ? "index" : specifier.slice("elit/".length);
+  const builtCandidates = options.preferredBuiltFormat === "cjs" ? [
+    resolve4(packageRoot, "dist", `${subpath}.cjs`),
+    resolve4(packageRoot, "dist", `${subpath}.js`),
+    resolve4(packageRoot, "dist", `${subpath}.mjs`)
+  ] : [
+    resolve4(packageRoot, "dist", `${subpath}.mjs`),
+    resolve4(packageRoot, "dist", `${subpath}.js`),
+    resolve4(packageRoot, "dist", `${subpath}.cjs`)
+  ];
+  const sourceCandidates = [
+    resolve4(packageRoot, "src", `${subpath}.ts`),
+    resolve4(packageRoot, "src", `${subpath}.tsx`)
+  ];
+  return options.preferBuilt ? [...builtCandidates, ...sourceCandidates] : [...sourceCandidates, ...builtCandidates];
+}
+
+// src/shares/workspace-package/resolve.ts
+function isWorkspacePackageSpecifier(specifier) {
+  return specifier === "elit" || specifier.startsWith("elit/");
+}
+function resolveWorkspacePackageImport(specifier, startDir, options = {}) {
+  if (!isWorkspacePackageSpecifier(specifier)) {
+    return void 0;
+  }
+  const packageRoots = /* @__PURE__ */ new Set();
+  const workspacePackageRoot = findWorkspacePackageRoot(startDir, "elit");
+  const installedPackageRoot = findInstalledPackageRoot(startDir, "elit");
+  if (workspacePackageRoot) {
+    packageRoots.add(workspacePackageRoot);
+  }
+  if (installedPackageRoot) {
+    packageRoots.add(installedPackageRoot);
+  }
+  for (const packageRoot of packageRoots) {
+    for (const candidate of getWorkspacePackageImportCandidates(packageRoot, specifier, options)) {
+      if (existsSync4(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/shares/config/loader.ts
+function resolveConfigPath(cwd = process.cwd()) {
+  for (const configFile of ELIT_CONFIG_FILES) {
+    const configPath = resolve4(cwd, configFile);
+    if (existsSync4(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = resolveConfigPath(cwd);
+  if (configPath) {
+    try {
+      return await loadConfigFile(configPath);
+    } catch (error) {
+      console.error(`Error loading config file: ${configPath.split(/[/\\]/).pop()}`);
+      console.error(error);
+      throw error;
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath) {
+  const ext = configPath.split(".").pop();
+  if (ext === "json") {
+    const content = readFileAsString(configPath);
+    return JSON.parse(content);
+  }
+  if (ext === "ts" || ext === "mts") {
+    try {
+      const { build } = await import("esbuild");
+      const configDir = dirname2(configPath);
+      const tempFile = join5(configDir, `.elit-config-${Date.now()}.mjs`);
+      const externalAllPlugin = {
+        name: "external-all",
+        setup(buildContext) {
+          buildContext.onResolve({ filter: /.*/ }, (args) => {
+            const workspacePackageImport = resolveWorkspacePackageImport(args.path, args.resolveDir || configDir, {
+              preferBuilt: true,
+              preferredBuiltFormat: "esm"
+            });
+            if (workspacePackageImport) {
+              return {
+                path: normalizeRelativeImportPath(configDir, workspacePackageImport),
+                external: true
+              };
+            }
+            if (args.path.startsWith("./") || args.path.startsWith("../")) {
+              return void 0;
+            }
+            if (args.path.includes("node_modules") || args.resolveDir?.includes("node_modules")) {
+              return { path: args.path, external: true };
+            }
+            const knownPackages = ["esbuild", "elit", "fs", "path", "os", "vm", "crypto", "http", "https", "url", "bun"];
+            if (knownPackages.some((pkg) => args.path === pkg || args.path.startsWith(pkg + "/"))) {
+              return { path: args.path, external: true };
+            }
+            if (args.resolveDir?.includes("elit/dist") || args.path.includes("elit/dist")) {
+              return { path: args.path, external: true };
+            }
+            return void 0;
+          });
+        }
+      };
+      await build({
+        entryPoints: [configPath],
+        bundle: true,
+        banner: {
+          js: `import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);`
+        },
+        format: "esm",
+        platform: "node",
+        outfile: tempFile,
+        write: true,
+        target: "es2020",
+        plugins: [externalAllPlugin],
+        external: [
+          "node:*",
+          "fs",
+          "path",
+          "os",
+          "vm",
+          "crypto",
+          "http",
+          "https",
+          "bun",
+          "bun:*",
+          "deno",
+          "deno:*"
+        ],
+        absWorkingDir: configDir
+      });
+      const config = await importConfigModule(tempFile);
+      await safeCleanup(tempFile);
+      return config;
+    } catch (error) {
+      console.error("Failed to load TypeScript config file.");
+      console.error("You can use a .js, .mjs, or .json config file instead.");
+      throw error;
+    }
+  }
+  return await importConfigModule(configPath);
+}
+
+// src/cli/pm/commands.ts
+async function runPmStart(args) {
+  const parsed = parsePmStartArgs(args);
+  const workspaceRoot = process.cwd();
+  const config = await loadConfig(workspaceRoot);
+  const paths = resolvePmPaths(config?.pm, workspaceRoot);
+  const definitions = resolvePmStartDefinitions(parsed, config, workspaceRoot);
+  const errors = [];
+  for (const definition of definitions) {
+    try {
+      const record = await startManagedProcess(definition, paths);
+      console.log(`[pm] started ${record.name} (${record.type})`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[pm] ${definition.name}: ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(errors.join(EOL2));
+  }
+}
+async function loadPmContext() {
+  const workspaceRoot = process.cwd();
+  const config = await loadConfig(workspaceRoot);
+  return {
+    config,
+    paths: resolvePmPaths(config?.pm, workspaceRoot)
+  };
+}
+function resolveNamedMatches(paths, value) {
+  if (value === "all") {
+    return listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  }
+  const match = findPmRecordMatch(paths, value);
+  return match ? [syncPmRecordLiveness(match)] : [];
+}
+function padCell(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function tailLogFile(filePath, lineCount) {
+  if (!existsSync5(filePath)) {
+    return "";
+  }
+  const lines = readFileSync3(filePath, "utf8").split(/\r?\n/).filter((line) => line.length > 0);
+  return lines.slice(-lineCount).join(EOL2);
+}
+function printPmList(paths) {
+  const matches = listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  if (matches.length === 0) {
+    console.log("No managed processes found.");
+    return;
+  }
+  const headers = [
+    padCell("name", 20),
+    padCell("status", 12),
+    padCell("pid", 8),
+    padCell("restarts", 10),
+    padCell("type", 8),
+    "runtime"
+  ];
+  console.log(headers.join("  "));
+  for (const { record } of matches) {
+    console.log([
+      padCell(record.name, 20),
+      padCell(record.status, 12),
+      padCell(record.childPid ? String(record.childPid) : "-", 8),
+      padCell(String(record.restartCount ?? 0), 10),
+      padCell(record.type, 8),
+      record.runtime ?? "-"
+    ].join("  "));
+  }
+}
+async function runPmStop(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm stop <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches = resolveNamedMatches(paths, target);
+  if (matches.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  const count = await stopPmMatches(matches);
+  console.log(`[pm] stopped ${count} process${count === 1 ? "" : "es"}`);
+}
+async function runPmRestart(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm restart <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches = resolveNamedMatches(paths, target);
+  if (matches.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  await stopPmMatches(matches);
+  const restarted = [];
+  for (const match of matches) {
+    const definition = resolvePmAppDefinition(
+      toPmAppConfig(match.record),
+      { name: match.record.name, env: {}, watchPaths: [], watchIgnore: [] },
+      process.cwd(),
+      match.record.source
+    );
+    await startManagedProcess(definition, paths);
+    restarted.push(match.record.name);
+  }
+  console.log(`[pm] restarted ${restarted.join(", ")}`);
+}
+async function runPmSave() {
+  const { paths } = await loadPmContext();
+  ensurePmDirectories(paths);
+  const runningApps = listPmRecordMatches(paths).map(syncPmRecordLiveness).filter((match) => match.record.desiredState === "running" && (match.record.status === "starting" || match.record.status === "online" || match.record.status === "restarting")).map((match) => toSavedAppDefinition(match.record));
+  writePmDumpFile(paths.dumpFile, runningApps);
+  console.log(`[pm] saved ${runningApps.length} process${runningApps.length === 1 ? "" : "es"} to ${paths.dumpFile}`);
+}
+async function runPmResurrect() {
+  const { paths } = await loadPmContext();
+  if (!existsSync5(paths.dumpFile)) {
+    throw new Error(`PM dump file not found: ${paths.dumpFile}`);
+  }
+  const dump = readPmDumpFile(paths.dumpFile);
+  if (dump.apps.length === 0) {
+    console.log("[pm] dump file is empty, nothing to resurrect");
+    return;
+  }
+  const errors = [];
+  let restored = 0;
+  for (const app of dump.apps) {
+    try {
+      const definition = resolvePmAppDefinition(
+        toSavedPmAppConfig(app),
+        { name: app.name, env: {}, watchPaths: [], watchIgnore: [] },
+        process.cwd(),
+        "cli"
+      );
+      await startManagedProcess(definition, paths);
+      restored += 1;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[pm] ${app.name}: ${message}`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error([`[pm] resurrected ${restored} process${restored === 1 ? "" : "es"}`, ...errors].join(EOL2));
+  }
+  console.log(`[pm] resurrected ${restored} process${restored === 1 ? "" : "es"} from ${paths.dumpFile}`);
+}
+async function runPmDelete(args) {
+  const target = args[0];
+  if (!target) {
+    throw new Error("Usage: elit pm delete <name|all>");
+  }
+  const { paths } = await loadPmContext();
+  const matches = resolveNamedMatches(paths, target);
+  if (matches.length === 0) {
+    throw new Error(`No managed process found for: ${target}`);
+  }
+  await stopPmMatches(matches);
+  for (const match of matches) {
+    if (existsSync5(match.record.logFiles.out)) {
+      rmSync(match.record.logFiles.out, { force: true });
+    }
+    if (existsSync5(match.record.logFiles.err)) {
+      rmSync(match.record.logFiles.err, { force: true });
+    }
+    rmSync(match.filePath, { force: true });
+  }
+  console.log(`[pm] deleted ${matches.length} process${matches.length === 1 ? "" : "es"}`);
+}
+async function runPmLogs(args) {
+  if (args.length === 0) {
+    throw new Error("Usage: elit pm logs <name> [--lines <n>] [--stderr]");
+  }
+  let name;
+  let lineCount = DEFAULT_LOG_LINES;
+  let stderrOnly = false;
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    switch (arg) {
+      case "--lines":
+        lineCount = normalizeIntegerOption(readRequiredValue(args, ++index, "--lines"), "--lines", 1);
+        break;
+      case "--stderr":
+        stderrOnly = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown pm logs option: ${arg}`);
+        }
+        if (name) {
+          throw new Error("pm logs accepts exactly one process name.");
+        }
+        name = arg;
+        break;
+    }
+  }
+  if (!name) {
+    throw new Error("Usage: elit pm logs <name> [--lines <n>] [--stderr]");
+  }
+  const { paths } = await loadPmContext();
+  const match = findPmRecordMatch(paths, name);
+  if (!match) {
+    throw new Error(`No managed process found for: ${name}`);
+  }
+  const stdoutContent = stderrOnly ? "" : tailLogFile(match.record.logFiles.out, lineCount);
+  const stderrContent = tailLogFile(match.record.logFiles.err, lineCount);
+  if (!stderrOnly) {
+    console.log(`== stdout: ${match.record.logFiles.out} ==`);
+    console.log(stdoutContent || "(empty)");
+  }
+  console.log(`== stderr: ${match.record.logFiles.err} ==`);
+  console.log(stderrContent || "(empty)");
+}
+async function runPmCommand(args) {
+  if (args.length === 0 || args[0] === "help" || args.includes("--help") || args.includes("-h")) {
+    printPmHelp();
+    return;
+  }
+  const command = args[0];
+  switch (command) {
+    case "start":
+      await runPmStart(args.slice(1));
+      return;
+    case "list":
+    case "ls": {
+      const { paths } = await loadPmContext();
+      printPmList(paths);
+      return;
+    }
+    case "stop":
+      await runPmStop(args.slice(1));
+      return;
+    case "restart":
+      await runPmRestart(args.slice(1));
+      return;
+    case "delete":
+    case "remove":
+    case "rm":
+      await runPmDelete(args.slice(1));
+      return;
+    case "save":
+      await runPmSave();
+      return;
+    case "resurrect":
+      await runPmResurrect();
+      return;
+    case "logs":
+      await runPmLogs(args.slice(1));
+      return;
+    case "__run":
+      await runPmRunner(args.slice(1));
+      return;
+    default:
+      throw new Error(`Unknown pm command: ${command}`);
+  }
+}
+export {
+  DEFAULT_HEALTHCHECK_GRACE_PERIOD,
+  DEFAULT_HEALTHCHECK_INTERVAL,
+  DEFAULT_HEALTHCHECK_MAX_FAILURES,
+  DEFAULT_HEALTHCHECK_TIMEOUT,
+  DEFAULT_LOG_LINES,
+  DEFAULT_MAX_RESTARTS,
+  DEFAULT_MIN_UPTIME,
+  DEFAULT_PM_DATA_DIR,
+  DEFAULT_PM_DUMP_FILE,
+  DEFAULT_PM_STOP_GRACE_PERIOD_MS,
+  DEFAULT_PM_STOP_POLL_MS,
+  DEFAULT_RESTART_DELAY,
+  DEFAULT_WATCH_DEBOUNCE,
+  DEFAULT_WATCH_IGNORE,
+  PM_RECORD_EXTENSION,
+  PM_WAPK_ONLINE_SHUTDOWN_COMMAND,
+  PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS,
+  PM_WAPK_ONLINE_STDIN_SHUTDOWN_ENV,
+  SIMPLE_PREVIEW_SEGMENT,
+  SUPPORTED_FILE_EXTENSIONS,
+  appendPmWapkRunArgs,
+  buildGoogleDriveWapkSpecifier,
+  buildPmCommand,
+  buildPmWapkPreview,
+  countDefinedPmWapkSources,
+  deriveDefaultWatchPaths,
+  ensurePmDirectories,
+  findPmRecordMatch,
+  getPmRecordPath,
+  hasPmGoogleDriveConfig,
+  hasPmWapkRunConfig,
+  isIgnoredWatchPath,
+  isPmOnlineWapkRecord,
+  isPmWapkOnlineRunConfig,
+  isProcessAlive,
+  isRemoteWapkArchiveSpecifier,
+  isTypescriptFile,
+  isWapkArchiveSpecifier,
+  listPmRecordMatches,
+  looksLikeManagedFile,
+  matchesGlobPattern,
+  mergePmWapkRunConfig,
+  normalizeEnvMap,
+  normalizeHealthCheckConfig,
+  normalizeIntegerOption,
+  normalizeNonEmptyString,
+  normalizePmRestartPolicy,
+  normalizePmRuntime,
+  normalizeResolvedWatchIgnorePaths,
+  normalizeResolvedWatchPaths,
+  normalizeStringArray,
+  normalizeWatchIgnorePatterns,
+  normalizeWatchPatterns,
+  parsePmEnvEntry,
+  parsePmStartArgs,
+  printPmHelp,
+  quoteCommandSegment,
+  readLatestPmRecord,
+  readPmDumpFile,
+  readPmRecord,
+  readRequiredValue,
+  resolvePmAppDefinition,
+  resolvePmPaths,
+  resolvePmStartDefinitions,
+  resolvePmWapkSource,
+  resolvePmWapkSourceToken,
+  runManagedProcessLoop,
+  runPmCommand,
+  runPmRunner,
+  sanitizePmProcessName,
+  startManagedProcess,
+  stopPmMatches,
+  stripPmWapkSourceFromRunConfig,
+  syncPmRecordLiveness,
+  terminateProcessTree,
+  toPmAppConfig,
+  toSavedAppDefinition,
+  toSavedPmAppConfig,
+  toWatchGlob,
+  waitForProcessTermination,
+  writePmDumpFile,
+  writePmRecord
+};